31263 lines
1 MiB
31263 lines
1 MiB
/*
|
|
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
|
|
if you want to view the source visit the plugins github repository (https://github.com/denolehov/obsidian-git)
|
|
*/
|
|
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
|
|
var __esm = (fn, res) => function __init() {
|
|
return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
|
|
};
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
__markAsModule(target);
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __reExport = (target, module2, desc) => {
|
|
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
|
|
for (let key2 of __getOwnPropNames(module2))
|
|
if (!__hasOwnProp.call(target, key2) && key2 !== "default")
|
|
__defProp(target, key2, { get: () => module2[key2], enumerable: !(desc = __getOwnPropDesc(module2, key2)) || desc.enumerable });
|
|
}
|
|
return target;
|
|
};
|
|
var __toModule = (module2) => {
|
|
return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
|
|
};
|
|
|
|
// node_modules/base64-js/index.js
|
|
var require_base64_js = __commonJS({
|
|
"node_modules/base64-js/index.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
exports.byteLength = byteLength;
|
|
exports.toByteArray = toByteArray;
|
|
exports.fromByteArray = fromByteArray;
|
|
var lookup = [];
|
|
var revLookup = [];
|
|
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
|
|
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
for (i = 0, len = code.length; i < len; ++i) {
|
|
lookup[i] = code[i];
|
|
revLookup[code.charCodeAt(i)] = i;
|
|
}
|
|
var i;
|
|
var len;
|
|
revLookup["-".charCodeAt(0)] = 62;
|
|
revLookup["_".charCodeAt(0)] = 63;
|
|
function getLens(b64) {
|
|
var len2 = b64.length;
|
|
if (len2 % 4 > 0) {
|
|
throw new Error("Invalid string. Length must be a multiple of 4");
|
|
}
|
|
var validLen = b64.indexOf("=");
|
|
if (validLen === -1)
|
|
validLen = len2;
|
|
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
|
|
return [validLen, placeHoldersLen];
|
|
}
|
|
function byteLength(b64) {
|
|
var lens = getLens(b64);
|
|
var validLen = lens[0];
|
|
var placeHoldersLen = lens[1];
|
|
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
|
}
|
|
function _byteLength(b64, validLen, placeHoldersLen) {
|
|
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
|
}
|
|
function toByteArray(b64) {
|
|
var tmp;
|
|
var lens = getLens(b64);
|
|
var validLen = lens[0];
|
|
var placeHoldersLen = lens[1];
|
|
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
|
|
var curByte = 0;
|
|
var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
|
|
var i2;
|
|
for (i2 = 0; i2 < len2; i2 += 4) {
|
|
tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
|
|
arr[curByte++] = tmp >> 16 & 255;
|
|
arr[curByte++] = tmp >> 8 & 255;
|
|
arr[curByte++] = tmp & 255;
|
|
}
|
|
if (placeHoldersLen === 2) {
|
|
tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
|
|
arr[curByte++] = tmp & 255;
|
|
}
|
|
if (placeHoldersLen === 1) {
|
|
tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
|
|
arr[curByte++] = tmp >> 8 & 255;
|
|
arr[curByte++] = tmp & 255;
|
|
}
|
|
return arr;
|
|
}
|
|
function tripletToBase64(num2) {
|
|
return lookup[num2 >> 18 & 63] + lookup[num2 >> 12 & 63] + lookup[num2 >> 6 & 63] + lookup[num2 & 63];
|
|
}
|
|
function encodeChunk(uint8, start, end) {
|
|
var tmp;
|
|
var output = [];
|
|
for (var i2 = start; i2 < end; i2 += 3) {
|
|
tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
|
|
output.push(tripletToBase64(tmp));
|
|
}
|
|
return output.join("");
|
|
}
|
|
function fromByteArray(uint8) {
|
|
var tmp;
|
|
var len2 = uint8.length;
|
|
var extraBytes = len2 % 3;
|
|
var parts = [];
|
|
var maxChunkLength = 16383;
|
|
for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
|
|
parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
|
|
}
|
|
if (extraBytes === 1) {
|
|
tmp = uint8[len2 - 1];
|
|
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
|
|
} else if (extraBytes === 2) {
|
|
tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
|
|
parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
|
|
}
|
|
return parts.join("");
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/ieee754/index.js
|
|
var require_ieee754 = __commonJS({
|
|
"node_modules/ieee754/index.js"(exports) {
|
|
init_polyfill_buffer();
|
|
exports.read = function(buffer2, offset, isLE, mLen, nBytes) {
|
|
var e, m;
|
|
var eLen = nBytes * 8 - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var nBits = -7;
|
|
var i = isLE ? nBytes - 1 : 0;
|
|
var d = isLE ? -1 : 1;
|
|
var s = buffer2[offset + i];
|
|
i += d;
|
|
e = s & (1 << -nBits) - 1;
|
|
s >>= -nBits;
|
|
nBits += eLen;
|
|
for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) {
|
|
}
|
|
m = e & (1 << -nBits) - 1;
|
|
e >>= -nBits;
|
|
nBits += mLen;
|
|
for (; nBits > 0; m = m * 256 + buffer2[offset + i], i += d, nBits -= 8) {
|
|
}
|
|
if (e === 0) {
|
|
e = 1 - eBias;
|
|
} else if (e === eMax) {
|
|
return m ? NaN : (s ? -1 : 1) * Infinity;
|
|
} else {
|
|
m = m + Math.pow(2, mLen);
|
|
e = e - eBias;
|
|
}
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
|
|
};
|
|
exports.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
|
|
var e, m, c;
|
|
var eLen = nBytes * 8 - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
|
|
var i = isLE ? 0 : nBytes - 1;
|
|
var d = isLE ? 1 : -1;
|
|
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
|
|
value = Math.abs(value);
|
|
if (isNaN(value) || value === Infinity) {
|
|
m = isNaN(value) ? 1 : 0;
|
|
e = eMax;
|
|
} else {
|
|
e = Math.floor(Math.log(value) / Math.LN2);
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
e--;
|
|
c *= 2;
|
|
}
|
|
if (e + eBias >= 1) {
|
|
value += rt / c;
|
|
} else {
|
|
value += rt * Math.pow(2, 1 - eBias);
|
|
}
|
|
if (value * c >= 2) {
|
|
e++;
|
|
c /= 2;
|
|
}
|
|
if (e + eBias >= eMax) {
|
|
m = 0;
|
|
e = eMax;
|
|
} else if (e + eBias >= 1) {
|
|
m = (value * c - 1) * Math.pow(2, mLen);
|
|
e = e + eBias;
|
|
} else {
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
|
e = 0;
|
|
}
|
|
}
|
|
for (; mLen >= 8; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
|
|
}
|
|
e = e << mLen | m;
|
|
eLen += mLen;
|
|
for (; eLen > 0; buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
|
|
}
|
|
buffer2[offset + i - d] |= s * 128;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/buffer/index.js
|
|
var require_buffer = __commonJS({
|
|
"node_modules/buffer/index.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var base64 = require_base64_js();
|
|
var ieee754 = require_ieee754();
|
|
var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
|
|
exports.Buffer = Buffer3;
|
|
exports.SlowBuffer = SlowBuffer;
|
|
exports.INSPECT_MAX_BYTES = 50;
|
|
var K_MAX_LENGTH = 2147483647;
|
|
exports.kMaxLength = K_MAX_LENGTH;
|
|
Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
|
|
if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
|
|
console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
|
|
}
|
|
function typedArraySupport() {
|
|
try {
|
|
const arr = new Uint8Array(1);
|
|
const proto = { foo: function() {
|
|
return 42;
|
|
} };
|
|
Object.setPrototypeOf(proto, Uint8Array.prototype);
|
|
Object.setPrototypeOf(arr, proto);
|
|
return arr.foo() === 42;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
Object.defineProperty(Buffer3.prototype, "parent", {
|
|
enumerable: true,
|
|
get: function() {
|
|
if (!Buffer3.isBuffer(this))
|
|
return void 0;
|
|
return this.buffer;
|
|
}
|
|
});
|
|
Object.defineProperty(Buffer3.prototype, "offset", {
|
|
enumerable: true,
|
|
get: function() {
|
|
if (!Buffer3.isBuffer(this))
|
|
return void 0;
|
|
return this.byteOffset;
|
|
}
|
|
});
|
|
function createBuffer(length) {
|
|
if (length > K_MAX_LENGTH) {
|
|
throw new RangeError('The value "' + length + '" is invalid for option "size"');
|
|
}
|
|
const buf = new Uint8Array(length);
|
|
Object.setPrototypeOf(buf, Buffer3.prototype);
|
|
return buf;
|
|
}
|
|
function Buffer3(arg, encodingOrOffset, length) {
|
|
if (typeof arg === "number") {
|
|
if (typeof encodingOrOffset === "string") {
|
|
throw new TypeError('The "string" argument must be of type string. Received type number');
|
|
}
|
|
return allocUnsafe(arg);
|
|
}
|
|
return from(arg, encodingOrOffset, length);
|
|
}
|
|
Buffer3.poolSize = 8192;
|
|
function from(value, encodingOrOffset, length) {
|
|
if (typeof value === "string") {
|
|
return fromString(value, encodingOrOffset);
|
|
}
|
|
if (ArrayBuffer.isView(value)) {
|
|
return fromArrayView(value);
|
|
}
|
|
if (value == null) {
|
|
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
|
|
}
|
|
if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
|
|
return fromArrayBuffer(value, encodingOrOffset, length);
|
|
}
|
|
if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
|
|
return fromArrayBuffer(value, encodingOrOffset, length);
|
|
}
|
|
if (typeof value === "number") {
|
|
throw new TypeError('The "value" argument must not be of type number. Received type number');
|
|
}
|
|
const valueOf = value.valueOf && value.valueOf();
|
|
if (valueOf != null && valueOf !== value) {
|
|
return Buffer3.from(valueOf, encodingOrOffset, length);
|
|
}
|
|
const b = fromObject(value);
|
|
if (b)
|
|
return b;
|
|
if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
|
|
return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
|
|
}
|
|
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
|
|
}
|
|
Buffer3.from = function(value, encodingOrOffset, length) {
|
|
return from(value, encodingOrOffset, length);
|
|
};
|
|
Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
|
|
Object.setPrototypeOf(Buffer3, Uint8Array);
|
|
function assertSize(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError('"size" argument must be of type number');
|
|
} else if (size < 0) {
|
|
throw new RangeError('The value "' + size + '" is invalid for option "size"');
|
|
}
|
|
}
|
|
function alloc(size, fill, encoding) {
|
|
assertSize(size);
|
|
if (size <= 0) {
|
|
return createBuffer(size);
|
|
}
|
|
if (fill !== void 0) {
|
|
return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
|
|
}
|
|
return createBuffer(size);
|
|
}
|
|
Buffer3.alloc = function(size, fill, encoding) {
|
|
return alloc(size, fill, encoding);
|
|
};
|
|
function allocUnsafe(size) {
|
|
assertSize(size);
|
|
return createBuffer(size < 0 ? 0 : checked(size) | 0);
|
|
}
|
|
Buffer3.allocUnsafe = function(size) {
|
|
return allocUnsafe(size);
|
|
};
|
|
Buffer3.allocUnsafeSlow = function(size) {
|
|
return allocUnsafe(size);
|
|
};
|
|
function fromString(string, encoding) {
|
|
if (typeof encoding !== "string" || encoding === "") {
|
|
encoding = "utf8";
|
|
}
|
|
if (!Buffer3.isEncoding(encoding)) {
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
}
|
|
const length = byteLength(string, encoding) | 0;
|
|
let buf = createBuffer(length);
|
|
const actual = buf.write(string, encoding);
|
|
if (actual !== length) {
|
|
buf = buf.slice(0, actual);
|
|
}
|
|
return buf;
|
|
}
|
|
function fromArrayLike(array) {
|
|
const length = array.length < 0 ? 0 : checked(array.length) | 0;
|
|
const buf = createBuffer(length);
|
|
for (let i = 0; i < length; i += 1) {
|
|
buf[i] = array[i] & 255;
|
|
}
|
|
return buf;
|
|
}
|
|
function fromArrayView(arrayView) {
|
|
if (isInstance(arrayView, Uint8Array)) {
|
|
const copy2 = new Uint8Array(arrayView);
|
|
return fromArrayBuffer(copy2.buffer, copy2.byteOffset, copy2.byteLength);
|
|
}
|
|
return fromArrayLike(arrayView);
|
|
}
|
|
function fromArrayBuffer(array, byteOffset, length) {
|
|
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
|
throw new RangeError('"offset" is outside of buffer bounds');
|
|
}
|
|
if (array.byteLength < byteOffset + (length || 0)) {
|
|
throw new RangeError('"length" is outside of buffer bounds');
|
|
}
|
|
let buf;
|
|
if (byteOffset === void 0 && length === void 0) {
|
|
buf = new Uint8Array(array);
|
|
} else if (length === void 0) {
|
|
buf = new Uint8Array(array, byteOffset);
|
|
} else {
|
|
buf = new Uint8Array(array, byteOffset, length);
|
|
}
|
|
Object.setPrototypeOf(buf, Buffer3.prototype);
|
|
return buf;
|
|
}
|
|
function fromObject(obj) {
|
|
if (Buffer3.isBuffer(obj)) {
|
|
const len = checked(obj.length) | 0;
|
|
const buf = createBuffer(len);
|
|
if (buf.length === 0) {
|
|
return buf;
|
|
}
|
|
obj.copy(buf, 0, 0, len);
|
|
return buf;
|
|
}
|
|
if (obj.length !== void 0) {
|
|
if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
|
|
return createBuffer(0);
|
|
}
|
|
return fromArrayLike(obj);
|
|
}
|
|
if (obj.type === "Buffer" && Array.isArray(obj.data)) {
|
|
return fromArrayLike(obj.data);
|
|
}
|
|
}
|
|
function checked(length) {
|
|
if (length >= K_MAX_LENGTH) {
|
|
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
|
|
}
|
|
return length | 0;
|
|
}
|
|
function SlowBuffer(length) {
|
|
if (+length != length) {
|
|
length = 0;
|
|
}
|
|
return Buffer3.alloc(+length);
|
|
}
|
|
Buffer3.isBuffer = function isBuffer(b) {
|
|
return b != null && b._isBuffer === true && b !== Buffer3.prototype;
|
|
};
|
|
Buffer3.compare = function compare(a, b) {
|
|
if (isInstance(a, Uint8Array))
|
|
a = Buffer3.from(a, a.offset, a.byteLength);
|
|
if (isInstance(b, Uint8Array))
|
|
b = Buffer3.from(b, b.offset, b.byteLength);
|
|
if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
|
|
throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
|
|
}
|
|
if (a === b)
|
|
return 0;
|
|
let x = a.length;
|
|
let y = b.length;
|
|
for (let i = 0, len = Math.min(x, y); i < len; ++i) {
|
|
if (a[i] !== b[i]) {
|
|
x = a[i];
|
|
y = b[i];
|
|
break;
|
|
}
|
|
}
|
|
if (x < y)
|
|
return -1;
|
|
if (y < x)
|
|
return 1;
|
|
return 0;
|
|
};
|
|
Buffer3.isEncoding = function isEncoding(encoding) {
|
|
switch (String(encoding).toLowerCase()) {
|
|
case "hex":
|
|
case "utf8":
|
|
case "utf-8":
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
case "base64":
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
Buffer3.concat = function concat(list, length) {
|
|
if (!Array.isArray(list)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers');
|
|
}
|
|
if (list.length === 0) {
|
|
return Buffer3.alloc(0);
|
|
}
|
|
let i;
|
|
if (length === void 0) {
|
|
length = 0;
|
|
for (i = 0; i < list.length; ++i) {
|
|
length += list[i].length;
|
|
}
|
|
}
|
|
const buffer2 = Buffer3.allocUnsafe(length);
|
|
let pos = 0;
|
|
for (i = 0; i < list.length; ++i) {
|
|
let buf = list[i];
|
|
if (isInstance(buf, Uint8Array)) {
|
|
if (pos + buf.length > buffer2.length) {
|
|
if (!Buffer3.isBuffer(buf))
|
|
buf = Buffer3.from(buf);
|
|
buf.copy(buffer2, pos);
|
|
} else {
|
|
Uint8Array.prototype.set.call(buffer2, buf, pos);
|
|
}
|
|
} else if (!Buffer3.isBuffer(buf)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers');
|
|
} else {
|
|
buf.copy(buffer2, pos);
|
|
}
|
|
pos += buf.length;
|
|
}
|
|
return buffer2;
|
|
};
|
|
function byteLength(string, encoding) {
|
|
if (Buffer3.isBuffer(string)) {
|
|
return string.length;
|
|
}
|
|
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
|
|
return string.byteLength;
|
|
}
|
|
if (typeof string !== "string") {
|
|
throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
|
|
}
|
|
const len = string.length;
|
|
const mustMatch = arguments.length > 2 && arguments[2] === true;
|
|
if (!mustMatch && len === 0)
|
|
return 0;
|
|
let loweredCase = false;
|
|
for (; ; ) {
|
|
switch (encoding) {
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
return len;
|
|
case "utf8":
|
|
case "utf-8":
|
|
return utf8ToBytes(string).length;
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return len * 2;
|
|
case "hex":
|
|
return len >>> 1;
|
|
case "base64":
|
|
return base64ToBytes(string).length;
|
|
default:
|
|
if (loweredCase) {
|
|
return mustMatch ? -1 : utf8ToBytes(string).length;
|
|
}
|
|
encoding = ("" + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
}
|
|
Buffer3.byteLength = byteLength;
|
|
function slowToString(encoding, start, end) {
|
|
let loweredCase = false;
|
|
if (start === void 0 || start < 0) {
|
|
start = 0;
|
|
}
|
|
if (start > this.length) {
|
|
return "";
|
|
}
|
|
if (end === void 0 || end > this.length) {
|
|
end = this.length;
|
|
}
|
|
if (end <= 0) {
|
|
return "";
|
|
}
|
|
end >>>= 0;
|
|
start >>>= 0;
|
|
if (end <= start) {
|
|
return "";
|
|
}
|
|
if (!encoding)
|
|
encoding = "utf8";
|
|
while (true) {
|
|
switch (encoding) {
|
|
case "hex":
|
|
return hexSlice(this, start, end);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return utf8Slice(this, start, end);
|
|
case "ascii":
|
|
return asciiSlice(this, start, end);
|
|
case "latin1":
|
|
case "binary":
|
|
return latin1Slice(this, start, end);
|
|
case "base64":
|
|
return base64Slice(this, start, end);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return utf16leSlice(this, start, end);
|
|
default:
|
|
if (loweredCase)
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
encoding = (encoding + "").toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
}
|
|
Buffer3.prototype._isBuffer = true;
|
|
function swap(b, n, m) {
|
|
const i = b[n];
|
|
b[n] = b[m];
|
|
b[m] = i;
|
|
}
|
|
Buffer3.prototype.swap16 = function swap16() {
|
|
const len = this.length;
|
|
if (len % 2 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 16-bits");
|
|
}
|
|
for (let i = 0; i < len; i += 2) {
|
|
swap(this, i, i + 1);
|
|
}
|
|
return this;
|
|
};
|
|
Buffer3.prototype.swap32 = function swap32() {
|
|
const len = this.length;
|
|
if (len % 4 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 32-bits");
|
|
}
|
|
for (let i = 0; i < len; i += 4) {
|
|
swap(this, i, i + 3);
|
|
swap(this, i + 1, i + 2);
|
|
}
|
|
return this;
|
|
};
|
|
Buffer3.prototype.swap64 = function swap64() {
|
|
const len = this.length;
|
|
if (len % 8 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 64-bits");
|
|
}
|
|
for (let i = 0; i < len; i += 8) {
|
|
swap(this, i, i + 7);
|
|
swap(this, i + 1, i + 6);
|
|
swap(this, i + 2, i + 5);
|
|
swap(this, i + 3, i + 4);
|
|
}
|
|
return this;
|
|
};
|
|
Buffer3.prototype.toString = function toString() {
|
|
const length = this.length;
|
|
if (length === 0)
|
|
return "";
|
|
if (arguments.length === 0)
|
|
return utf8Slice(this, 0, length);
|
|
return slowToString.apply(this, arguments);
|
|
};
|
|
Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
|
|
Buffer3.prototype.equals = function equals2(b) {
|
|
if (!Buffer3.isBuffer(b))
|
|
throw new TypeError("Argument must be a Buffer");
|
|
if (this === b)
|
|
return true;
|
|
return Buffer3.compare(this, b) === 0;
|
|
};
|
|
Buffer3.prototype.inspect = function inspect() {
|
|
let str = "";
|
|
const max = exports.INSPECT_MAX_BYTES;
|
|
str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
|
|
if (this.length > max)
|
|
str += " ... ";
|
|
return "<Buffer " + str + ">";
|
|
};
|
|
if (customInspectSymbol) {
|
|
Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
|
|
}
|
|
Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
|
|
if (isInstance(target, Uint8Array)) {
|
|
target = Buffer3.from(target, target.offset, target.byteLength);
|
|
}
|
|
if (!Buffer3.isBuffer(target)) {
|
|
throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
|
|
}
|
|
if (start === void 0) {
|
|
start = 0;
|
|
}
|
|
if (end === void 0) {
|
|
end = target ? target.length : 0;
|
|
}
|
|
if (thisStart === void 0) {
|
|
thisStart = 0;
|
|
}
|
|
if (thisEnd === void 0) {
|
|
thisEnd = this.length;
|
|
}
|
|
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
|
|
throw new RangeError("out of range index");
|
|
}
|
|
if (thisStart >= thisEnd && start >= end) {
|
|
return 0;
|
|
}
|
|
if (thisStart >= thisEnd) {
|
|
return -1;
|
|
}
|
|
if (start >= end) {
|
|
return 1;
|
|
}
|
|
start >>>= 0;
|
|
end >>>= 0;
|
|
thisStart >>>= 0;
|
|
thisEnd >>>= 0;
|
|
if (this === target)
|
|
return 0;
|
|
let x = thisEnd - thisStart;
|
|
let y = end - start;
|
|
const len = Math.min(x, y);
|
|
const thisCopy = this.slice(thisStart, thisEnd);
|
|
const targetCopy = target.slice(start, end);
|
|
for (let i = 0; i < len; ++i) {
|
|
if (thisCopy[i] !== targetCopy[i]) {
|
|
x = thisCopy[i];
|
|
y = targetCopy[i];
|
|
break;
|
|
}
|
|
}
|
|
if (x < y)
|
|
return -1;
|
|
if (y < x)
|
|
return 1;
|
|
return 0;
|
|
};
|
|
function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
|
|
if (buffer2.length === 0)
|
|
return -1;
|
|
if (typeof byteOffset === "string") {
|
|
encoding = byteOffset;
|
|
byteOffset = 0;
|
|
} else if (byteOffset > 2147483647) {
|
|
byteOffset = 2147483647;
|
|
} else if (byteOffset < -2147483648) {
|
|
byteOffset = -2147483648;
|
|
}
|
|
byteOffset = +byteOffset;
|
|
if (numberIsNaN(byteOffset)) {
|
|
byteOffset = dir ? 0 : buffer2.length - 1;
|
|
}
|
|
if (byteOffset < 0)
|
|
byteOffset = buffer2.length + byteOffset;
|
|
if (byteOffset >= buffer2.length) {
|
|
if (dir)
|
|
return -1;
|
|
else
|
|
byteOffset = buffer2.length - 1;
|
|
} else if (byteOffset < 0) {
|
|
if (dir)
|
|
byteOffset = 0;
|
|
else
|
|
return -1;
|
|
}
|
|
if (typeof val === "string") {
|
|
val = Buffer3.from(val, encoding);
|
|
}
|
|
if (Buffer3.isBuffer(val)) {
|
|
if (val.length === 0) {
|
|
return -1;
|
|
}
|
|
return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
|
|
} else if (typeof val === "number") {
|
|
val = val & 255;
|
|
if (typeof Uint8Array.prototype.indexOf === "function") {
|
|
if (dir) {
|
|
return Uint8Array.prototype.indexOf.call(buffer2, val, byteOffset);
|
|
} else {
|
|
return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
|
|
}
|
|
}
|
|
return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
|
|
}
|
|
throw new TypeError("val must be string, number or Buffer");
|
|
}
|
|
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
|
|
let indexSize = 1;
|
|
let arrLength = arr.length;
|
|
let valLength = val.length;
|
|
if (encoding !== void 0) {
|
|
encoding = String(encoding).toLowerCase();
|
|
if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
|
|
if (arr.length < 2 || val.length < 2) {
|
|
return -1;
|
|
}
|
|
indexSize = 2;
|
|
arrLength /= 2;
|
|
valLength /= 2;
|
|
byteOffset /= 2;
|
|
}
|
|
}
|
|
function read(buf, i2) {
|
|
if (indexSize === 1) {
|
|
return buf[i2];
|
|
} else {
|
|
return buf.readUInt16BE(i2 * indexSize);
|
|
}
|
|
}
|
|
let i;
|
|
if (dir) {
|
|
let foundIndex = -1;
|
|
for (i = byteOffset; i < arrLength; i++) {
|
|
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
|
|
if (foundIndex === -1)
|
|
foundIndex = i;
|
|
if (i - foundIndex + 1 === valLength)
|
|
return foundIndex * indexSize;
|
|
} else {
|
|
if (foundIndex !== -1)
|
|
i -= i - foundIndex;
|
|
foundIndex = -1;
|
|
}
|
|
}
|
|
} else {
|
|
if (byteOffset + valLength > arrLength)
|
|
byteOffset = arrLength - valLength;
|
|
for (i = byteOffset; i >= 0; i--) {
|
|
let found = true;
|
|
for (let j = 0; j < valLength; j++) {
|
|
if (read(arr, i + j) !== read(val, j)) {
|
|
found = false;
|
|
break;
|
|
}
|
|
}
|
|
if (found)
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
|
|
return this.indexOf(val, byteOffset, encoding) !== -1;
|
|
};
|
|
Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
|
|
};
|
|
Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
|
|
};
|
|
function hexWrite(buf, string, offset, length) {
|
|
offset = Number(offset) || 0;
|
|
const remaining = buf.length - offset;
|
|
if (!length) {
|
|
length = remaining;
|
|
} else {
|
|
length = Number(length);
|
|
if (length > remaining) {
|
|
length = remaining;
|
|
}
|
|
}
|
|
const strLen = string.length;
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2;
|
|
}
|
|
let i;
|
|
for (i = 0; i < length; ++i) {
|
|
const parsed = parseInt(string.substr(i * 2, 2), 16);
|
|
if (numberIsNaN(parsed))
|
|
return i;
|
|
buf[offset + i] = parsed;
|
|
}
|
|
return i;
|
|
}
|
|
function utf8Write(buf, string, offset, length) {
|
|
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
|
|
}
|
|
function asciiWrite(buf, string, offset, length) {
|
|
return blitBuffer(asciiToBytes(string), buf, offset, length);
|
|
}
|
|
function base64Write(buf, string, offset, length) {
|
|
return blitBuffer(base64ToBytes(string), buf, offset, length);
|
|
}
|
|
function ucs2Write(buf, string, offset, length) {
|
|
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
|
|
}
|
|
Buffer3.prototype.write = function write(string, offset, length, encoding) {
|
|
if (offset === void 0) {
|
|
encoding = "utf8";
|
|
length = this.length;
|
|
offset = 0;
|
|
} else if (length === void 0 && typeof offset === "string") {
|
|
encoding = offset;
|
|
length = this.length;
|
|
offset = 0;
|
|
} else if (isFinite(offset)) {
|
|
offset = offset >>> 0;
|
|
if (isFinite(length)) {
|
|
length = length >>> 0;
|
|
if (encoding === void 0)
|
|
encoding = "utf8";
|
|
} else {
|
|
encoding = length;
|
|
length = void 0;
|
|
}
|
|
} else {
|
|
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
|
|
}
|
|
const remaining = this.length - offset;
|
|
if (length === void 0 || length > remaining)
|
|
length = remaining;
|
|
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
|
|
throw new RangeError("Attempt to write outside buffer bounds");
|
|
}
|
|
if (!encoding)
|
|
encoding = "utf8";
|
|
let loweredCase = false;
|
|
for (; ; ) {
|
|
switch (encoding) {
|
|
case "hex":
|
|
return hexWrite(this, string, offset, length);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return utf8Write(this, string, offset, length);
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
return asciiWrite(this, string, offset, length);
|
|
case "base64":
|
|
return base64Write(this, string, offset, length);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return ucs2Write(this, string, offset, length);
|
|
default:
|
|
if (loweredCase)
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
encoding = ("" + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
};
|
|
Buffer3.prototype.toJSON = function toJSON() {
|
|
return {
|
|
type: "Buffer",
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
};
|
|
};
|
|
function base64Slice(buf, start, end) {
|
|
if (start === 0 && end === buf.length) {
|
|
return base64.fromByteArray(buf);
|
|
} else {
|
|
return base64.fromByteArray(buf.slice(start, end));
|
|
}
|
|
}
|
|
function utf8Slice(buf, start, end) {
|
|
end = Math.min(buf.length, end);
|
|
const res = [];
|
|
let i = start;
|
|
while (i < end) {
|
|
const firstByte = buf[i];
|
|
let codePoint = null;
|
|
let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
|
|
if (i + bytesPerSequence <= end) {
|
|
let secondByte, thirdByte, fourthByte, tempCodePoint;
|
|
switch (bytesPerSequence) {
|
|
case 1:
|
|
if (firstByte < 128) {
|
|
codePoint = firstByte;
|
|
}
|
|
break;
|
|
case 2:
|
|
secondByte = buf[i + 1];
|
|
if ((secondByte & 192) === 128) {
|
|
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
|
|
if (tempCodePoint > 127) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
secondByte = buf[i + 1];
|
|
thirdByte = buf[i + 2];
|
|
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
|
|
tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
|
|
if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
secondByte = buf[i + 1];
|
|
thirdByte = buf[i + 2];
|
|
fourthByte = buf[i + 3];
|
|
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
|
|
tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
|
|
if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (codePoint === null) {
|
|
codePoint = 65533;
|
|
bytesPerSequence = 1;
|
|
} else if (codePoint > 65535) {
|
|
codePoint -= 65536;
|
|
res.push(codePoint >>> 10 & 1023 | 55296);
|
|
codePoint = 56320 | codePoint & 1023;
|
|
}
|
|
res.push(codePoint);
|
|
i += bytesPerSequence;
|
|
}
|
|
return decodeCodePointsArray(res);
|
|
}
|
|
var MAX_ARGUMENTS_LENGTH = 4096;
|
|
function decodeCodePointsArray(codePoints) {
|
|
const len = codePoints.length;
|
|
if (len <= MAX_ARGUMENTS_LENGTH) {
|
|
return String.fromCharCode.apply(String, codePoints);
|
|
}
|
|
let res = "";
|
|
let i = 0;
|
|
while (i < len) {
|
|
res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
|
|
}
|
|
return res;
|
|
}
|
|
function asciiSlice(buf, start, end) {
|
|
let ret = "";
|
|
end = Math.min(buf.length, end);
|
|
for (let i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf[i] & 127);
|
|
}
|
|
return ret;
|
|
}
|
|
function latin1Slice(buf, start, end) {
|
|
let ret = "";
|
|
end = Math.min(buf.length, end);
|
|
for (let i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf[i]);
|
|
}
|
|
return ret;
|
|
}
|
|
function hexSlice(buf, start, end) {
|
|
const len = buf.length;
|
|
if (!start || start < 0)
|
|
start = 0;
|
|
if (!end || end < 0 || end > len)
|
|
end = len;
|
|
let out = "";
|
|
for (let i = start; i < end; ++i) {
|
|
out += hexSliceLookupTable[buf[i]];
|
|
}
|
|
return out;
|
|
}
|
|
function utf16leSlice(buf, start, end) {
|
|
const bytes = buf.slice(start, end);
|
|
let res = "";
|
|
for (let i = 0; i < bytes.length - 1; i += 2) {
|
|
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
|
|
}
|
|
return res;
|
|
}
|
|
Buffer3.prototype.slice = function slice(start, end) {
|
|
const len = this.length;
|
|
start = ~~start;
|
|
end = end === void 0 ? len : ~~end;
|
|
if (start < 0) {
|
|
start += len;
|
|
if (start < 0)
|
|
start = 0;
|
|
} else if (start > len) {
|
|
start = len;
|
|
}
|
|
if (end < 0) {
|
|
end += len;
|
|
if (end < 0)
|
|
end = 0;
|
|
} else if (end > len) {
|
|
end = len;
|
|
}
|
|
if (end < start)
|
|
end = start;
|
|
const newBuf = this.subarray(start, end);
|
|
Object.setPrototypeOf(newBuf, Buffer3.prototype);
|
|
return newBuf;
|
|
};
|
|
function checkOffset(offset, ext, length) {
|
|
if (offset % 1 !== 0 || offset < 0)
|
|
throw new RangeError("offset is not uint");
|
|
if (offset + ext > length)
|
|
throw new RangeError("Trying to access beyond buffer length");
|
|
}
|
|
Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength2, this.length);
|
|
let val = this[offset];
|
|
let mul = 1;
|
|
let i = 0;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
val += this[offset + i] * mul;
|
|
}
|
|
return val;
|
|
};
|
|
Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert) {
|
|
checkOffset(offset, byteLength2, this.length);
|
|
}
|
|
let val = this[offset + --byteLength2];
|
|
let mul = 1;
|
|
while (byteLength2 > 0 && (mul *= 256)) {
|
|
val += this[offset + --byteLength2] * mul;
|
|
}
|
|
return val;
|
|
};
|
|
Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 1, this.length);
|
|
return this[offset];
|
|
};
|
|
Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
return this[offset] | this[offset + 1] << 8;
|
|
};
|
|
Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
return this[offset] << 8 | this[offset + 1];
|
|
};
|
|
Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
|
|
};
|
|
Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
|
|
};
|
|
Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first2 = this[offset];
|
|
const last2 = this[offset + 7];
|
|
if (first2 === void 0 || last2 === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const lo = first2 + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
|
|
const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last2 * 2 ** 24;
|
|
return BigInt(lo) + (BigInt(hi) << BigInt(32));
|
|
});
|
|
Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first2 = this[offset];
|
|
const last2 = this[offset + 7];
|
|
if (first2 === void 0 || last2 === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const hi = first2 * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
|
|
const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last2;
|
|
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
|
|
});
|
|
Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength2, this.length);
|
|
let val = this[offset];
|
|
let mul = 1;
|
|
let i = 0;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
val += this[offset + i] * mul;
|
|
}
|
|
mul *= 128;
|
|
if (val >= mul)
|
|
val -= Math.pow(2, 8 * byteLength2);
|
|
return val;
|
|
};
|
|
Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength2, this.length);
|
|
let i = byteLength2;
|
|
let mul = 1;
|
|
let val = this[offset + --i];
|
|
while (i > 0 && (mul *= 256)) {
|
|
val += this[offset + --i] * mul;
|
|
}
|
|
mul *= 128;
|
|
if (val >= mul)
|
|
val -= Math.pow(2, 8 * byteLength2);
|
|
return val;
|
|
};
|
|
Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 1, this.length);
|
|
if (!(this[offset] & 128))
|
|
return this[offset];
|
|
return (255 - this[offset] + 1) * -1;
|
|
};
|
|
Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
const val = this[offset] | this[offset + 1] << 8;
|
|
return val & 32768 ? val | 4294901760 : val;
|
|
};
|
|
Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
const val = this[offset + 1] | this[offset] << 8;
|
|
return val & 32768 ? val | 4294901760 : val;
|
|
};
|
|
Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
|
|
};
|
|
Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
|
|
};
|
|
Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first2 = this[offset];
|
|
const last2 = this[offset + 7];
|
|
if (first2 === void 0 || last2 === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last2 << 24);
|
|
return (BigInt(val) << BigInt(32)) + BigInt(first2 + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
|
|
});
|
|
Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first2 = this[offset];
|
|
const last2 = this[offset + 7];
|
|
if (first2 === void 0 || last2 === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const val = (first2 << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
|
|
return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last2);
|
|
});
|
|
Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return ieee754.read(this, offset, true, 23, 4);
|
|
};
|
|
Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return ieee754.read(this, offset, false, 23, 4);
|
|
};
|
|
Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 8, this.length);
|
|
return ieee754.read(this, offset, true, 52, 8);
|
|
};
|
|
Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 8, this.length);
|
|
return ieee754.read(this, offset, false, 52, 8);
|
|
};
|
|
function checkInt(buf, value, offset, ext, max, min) {
|
|
if (!Buffer3.isBuffer(buf))
|
|
throw new TypeError('"buffer" argument must be a Buffer instance');
|
|
if (value > max || value < min)
|
|
throw new RangeError('"value" argument is out of bounds');
|
|
if (offset + ext > buf.length)
|
|
throw new RangeError("Index out of range");
|
|
}
|
|
Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert) {
|
|
const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
|
|
checkInt(this, value, offset, byteLength2, maxBytes, 0);
|
|
}
|
|
let mul = 1;
|
|
let i = 0;
|
|
this[offset] = value & 255;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
this[offset + i] = value / mul & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert) {
|
|
const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
|
|
checkInt(this, value, offset, byteLength2, maxBytes, 0);
|
|
}
|
|
let i = byteLength2 - 1;
|
|
let mul = 1;
|
|
this[offset + i] = value & 255;
|
|
while (--i >= 0 && (mul *= 256)) {
|
|
this[offset + i] = value / mul & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 1, 255, 0);
|
|
this[offset] = value & 255;
|
|
return offset + 1;
|
|
};
|
|
Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 65535, 0);
|
|
this[offset] = value & 255;
|
|
this[offset + 1] = value >>> 8;
|
|
return offset + 2;
|
|
};
|
|
Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 65535, 0);
|
|
this[offset] = value >>> 8;
|
|
this[offset + 1] = value & 255;
|
|
return offset + 2;
|
|
};
|
|
Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 4294967295, 0);
|
|
this[offset + 3] = value >>> 24;
|
|
this[offset + 2] = value >>> 16;
|
|
this[offset + 1] = value >>> 8;
|
|
this[offset] = value & 255;
|
|
return offset + 4;
|
|
};
|
|
Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 4294967295, 0);
|
|
this[offset] = value >>> 24;
|
|
this[offset + 1] = value >>> 16;
|
|
this[offset + 2] = value >>> 8;
|
|
this[offset + 3] = value & 255;
|
|
return offset + 4;
|
|
};
|
|
function wrtBigUInt64LE(buf, value, offset, min, max) {
|
|
checkIntBI(value, min, max, buf, offset, 7);
|
|
let lo = Number(value & BigInt(4294967295));
|
|
buf[offset++] = lo;
|
|
lo = lo >> 8;
|
|
buf[offset++] = lo;
|
|
lo = lo >> 8;
|
|
buf[offset++] = lo;
|
|
lo = lo >> 8;
|
|
buf[offset++] = lo;
|
|
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
|
|
buf[offset++] = hi;
|
|
hi = hi >> 8;
|
|
buf[offset++] = hi;
|
|
hi = hi >> 8;
|
|
buf[offset++] = hi;
|
|
hi = hi >> 8;
|
|
buf[offset++] = hi;
|
|
return offset;
|
|
}
|
|
function wrtBigUInt64BE(buf, value, offset, min, max) {
|
|
checkIntBI(value, min, max, buf, offset, 7);
|
|
let lo = Number(value & BigInt(4294967295));
|
|
buf[offset + 7] = lo;
|
|
lo = lo >> 8;
|
|
buf[offset + 6] = lo;
|
|
lo = lo >> 8;
|
|
buf[offset + 5] = lo;
|
|
lo = lo >> 8;
|
|
buf[offset + 4] = lo;
|
|
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
|
|
buf[offset + 3] = hi;
|
|
hi = hi >> 8;
|
|
buf[offset + 2] = hi;
|
|
hi = hi >> 8;
|
|
buf[offset + 1] = hi;
|
|
hi = hi >> 8;
|
|
buf[offset] = hi;
|
|
return offset + 8;
|
|
}
|
|
Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
|
|
return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
|
|
});
|
|
Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
|
|
return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
|
|
});
|
|
Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
const limit = Math.pow(2, 8 * byteLength2 - 1);
|
|
checkInt(this, value, offset, byteLength2, limit - 1, -limit);
|
|
}
|
|
let i = 0;
|
|
let mul = 1;
|
|
let sub = 0;
|
|
this[offset] = value & 255;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
|
|
sub = 1;
|
|
}
|
|
this[offset + i] = (value / mul >> 0) - sub & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
const limit = Math.pow(2, 8 * byteLength2 - 1);
|
|
checkInt(this, value, offset, byteLength2, limit - 1, -limit);
|
|
}
|
|
let i = byteLength2 - 1;
|
|
let mul = 1;
|
|
let sub = 0;
|
|
this[offset + i] = value & 255;
|
|
while (--i >= 0 && (mul *= 256)) {
|
|
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
|
|
sub = 1;
|
|
}
|
|
this[offset + i] = (value / mul >> 0) - sub & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 1, 127, -128);
|
|
if (value < 0)
|
|
value = 255 + value + 1;
|
|
this[offset] = value & 255;
|
|
return offset + 1;
|
|
};
|
|
Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 32767, -32768);
|
|
this[offset] = value & 255;
|
|
this[offset + 1] = value >>> 8;
|
|
return offset + 2;
|
|
};
|
|
Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 32767, -32768);
|
|
this[offset] = value >>> 8;
|
|
this[offset + 1] = value & 255;
|
|
return offset + 2;
|
|
};
|
|
Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 2147483647, -2147483648);
|
|
this[offset] = value & 255;
|
|
this[offset + 1] = value >>> 8;
|
|
this[offset + 2] = value >>> 16;
|
|
this[offset + 3] = value >>> 24;
|
|
return offset + 4;
|
|
};
|
|
Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 2147483647, -2147483648);
|
|
if (value < 0)
|
|
value = 4294967295 + value + 1;
|
|
this[offset] = value >>> 24;
|
|
this[offset + 1] = value >>> 16;
|
|
this[offset + 2] = value >>> 8;
|
|
this[offset + 3] = value & 255;
|
|
return offset + 4;
|
|
};
|
|
Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
|
|
return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
|
});
|
|
Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
|
|
return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
|
});
|
|
function checkIEEE754(buf, value, offset, ext, max, min) {
|
|
if (offset + ext > buf.length)
|
|
throw new RangeError("Index out of range");
|
|
if (offset < 0)
|
|
throw new RangeError("Index out of range");
|
|
}
|
|
function writeFloat(buf, value, offset, littleEndian, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
|
|
}
|
|
ieee754.write(buf, value, offset, littleEndian, 23, 4);
|
|
return offset + 4;
|
|
}
|
|
Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, true, noAssert);
|
|
};
|
|
Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, false, noAssert);
|
|
};
|
|
function writeDouble(buf, value, offset, littleEndian, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
|
|
}
|
|
ieee754.write(buf, value, offset, littleEndian, 52, 8);
|
|
return offset + 8;
|
|
}
|
|
Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, true, noAssert);
|
|
};
|
|
Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, false, noAssert);
|
|
};
|
|
Buffer3.prototype.copy = function copy2(target, targetStart, start, end) {
|
|
if (!Buffer3.isBuffer(target))
|
|
throw new TypeError("argument should be a Buffer");
|
|
if (!start)
|
|
start = 0;
|
|
if (!end && end !== 0)
|
|
end = this.length;
|
|
if (targetStart >= target.length)
|
|
targetStart = target.length;
|
|
if (!targetStart)
|
|
targetStart = 0;
|
|
if (end > 0 && end < start)
|
|
end = start;
|
|
if (end === start)
|
|
return 0;
|
|
if (target.length === 0 || this.length === 0)
|
|
return 0;
|
|
if (targetStart < 0) {
|
|
throw new RangeError("targetStart out of bounds");
|
|
}
|
|
if (start < 0 || start >= this.length)
|
|
throw new RangeError("Index out of range");
|
|
if (end < 0)
|
|
throw new RangeError("sourceEnd out of bounds");
|
|
if (end > this.length)
|
|
end = this.length;
|
|
if (target.length - targetStart < end - start) {
|
|
end = target.length - targetStart + start;
|
|
}
|
|
const len = end - start;
|
|
if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
|
|
this.copyWithin(targetStart, start, end);
|
|
} else {
|
|
Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
|
|
}
|
|
return len;
|
|
};
|
|
Buffer3.prototype.fill = function fill(val, start, end, encoding) {
|
|
if (typeof val === "string") {
|
|
if (typeof start === "string") {
|
|
encoding = start;
|
|
start = 0;
|
|
end = this.length;
|
|
} else if (typeof end === "string") {
|
|
encoding = end;
|
|
end = this.length;
|
|
}
|
|
if (encoding !== void 0 && typeof encoding !== "string") {
|
|
throw new TypeError("encoding must be a string");
|
|
}
|
|
if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
}
|
|
if (val.length === 1) {
|
|
const code = val.charCodeAt(0);
|
|
if (encoding === "utf8" && code < 128 || encoding === "latin1") {
|
|
val = code;
|
|
}
|
|
}
|
|
} else if (typeof val === "number") {
|
|
val = val & 255;
|
|
} else if (typeof val === "boolean") {
|
|
val = Number(val);
|
|
}
|
|
if (start < 0 || this.length < start || this.length < end) {
|
|
throw new RangeError("Out of range index");
|
|
}
|
|
if (end <= start) {
|
|
return this;
|
|
}
|
|
start = start >>> 0;
|
|
end = end === void 0 ? this.length : end >>> 0;
|
|
if (!val)
|
|
val = 0;
|
|
let i;
|
|
if (typeof val === "number") {
|
|
for (i = start; i < end; ++i) {
|
|
this[i] = val;
|
|
}
|
|
} else {
|
|
const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
|
|
const len = bytes.length;
|
|
if (len === 0) {
|
|
throw new TypeError('The value "' + val + '" is invalid for argument "value"');
|
|
}
|
|
for (i = 0; i < end - start; ++i) {
|
|
this[i + start] = bytes[i % len];
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
var errors = {};
|
|
function E(sym, getMessage, Base) {
|
|
errors[sym] = class NodeError extends Base {
|
|
constructor() {
|
|
super();
|
|
Object.defineProperty(this, "message", {
|
|
value: getMessage.apply(this, arguments),
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
this.name = `${this.name} [${sym}]`;
|
|
this.stack;
|
|
delete this.name;
|
|
}
|
|
get code() {
|
|
return sym;
|
|
}
|
|
set code(value) {
|
|
Object.defineProperty(this, "code", {
|
|
configurable: true,
|
|
enumerable: true,
|
|
value,
|
|
writable: true
|
|
});
|
|
}
|
|
toString() {
|
|
return `${this.name} [${sym}]: ${this.message}`;
|
|
}
|
|
};
|
|
}
|
|
E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
|
|
if (name) {
|
|
return `${name} is outside of buffer bounds`;
|
|
}
|
|
return "Attempt to access memory outside buffer bounds";
|
|
}, RangeError);
|
|
E("ERR_INVALID_ARG_TYPE", function(name, actual) {
|
|
return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
|
|
}, TypeError);
|
|
E("ERR_OUT_OF_RANGE", function(str, range, input) {
|
|
let msg = `The value of "${str}" is out of range.`;
|
|
let received = input;
|
|
if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
|
|
received = addNumericalSeparator(String(input));
|
|
} else if (typeof input === "bigint") {
|
|
received = String(input);
|
|
if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
|
|
received = addNumericalSeparator(received);
|
|
}
|
|
received += "n";
|
|
}
|
|
msg += ` It must be ${range}. Received ${received}`;
|
|
return msg;
|
|
}, RangeError);
|
|
function addNumericalSeparator(val) {
|
|
let res = "";
|
|
let i = val.length;
|
|
const start = val[0] === "-" ? 1 : 0;
|
|
for (; i >= start + 4; i -= 3) {
|
|
res = `_${val.slice(i - 3, i)}${res}`;
|
|
}
|
|
return `${val.slice(0, i)}${res}`;
|
|
}
|
|
function checkBounds(buf, offset, byteLength2) {
|
|
validateNumber(offset, "offset");
|
|
if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
|
|
boundsError(offset, buf.length - (byteLength2 + 1));
|
|
}
|
|
}
|
|
function checkIntBI(value, min, max, buf, offset, byteLength2) {
|
|
if (value > max || value < min) {
|
|
const n = typeof min === "bigint" ? "n" : "";
|
|
let range;
|
|
if (byteLength2 > 3) {
|
|
if (min === 0 || min === BigInt(0)) {
|
|
range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
|
|
} else {
|
|
range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
|
|
}
|
|
} else {
|
|
range = `>= ${min}${n} and <= ${max}${n}`;
|
|
}
|
|
throw new errors.ERR_OUT_OF_RANGE("value", range, value);
|
|
}
|
|
checkBounds(buf, offset, byteLength2);
|
|
}
|
|
function validateNumber(value, name) {
|
|
if (typeof value !== "number") {
|
|
throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
|
|
}
|
|
}
|
|
function boundsError(value, length, type) {
|
|
if (Math.floor(value) !== value) {
|
|
validateNumber(value, type);
|
|
throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
|
|
}
|
|
if (length < 0) {
|
|
throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
|
|
}
|
|
throw new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
|
|
}
|
|
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
|
|
function base64clean(str) {
|
|
str = str.split("=")[0];
|
|
str = str.trim().replace(INVALID_BASE64_RE, "");
|
|
if (str.length < 2)
|
|
return "";
|
|
while (str.length % 4 !== 0) {
|
|
str = str + "=";
|
|
}
|
|
return str;
|
|
}
|
|
function utf8ToBytes(string, units) {
|
|
units = units || Infinity;
|
|
let codePoint;
|
|
const length = string.length;
|
|
let leadSurrogate = null;
|
|
const bytes = [];
|
|
for (let i = 0; i < length; ++i) {
|
|
codePoint = string.charCodeAt(i);
|
|
if (codePoint > 55295 && codePoint < 57344) {
|
|
if (!leadSurrogate) {
|
|
if (codePoint > 56319) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
continue;
|
|
} else if (i + 1 === length) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
continue;
|
|
}
|
|
leadSurrogate = codePoint;
|
|
continue;
|
|
}
|
|
if (codePoint < 56320) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
leadSurrogate = codePoint;
|
|
continue;
|
|
}
|
|
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
|
|
} else if (leadSurrogate) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
}
|
|
leadSurrogate = null;
|
|
if (codePoint < 128) {
|
|
if ((units -= 1) < 0)
|
|
break;
|
|
bytes.push(codePoint);
|
|
} else if (codePoint < 2048) {
|
|
if ((units -= 2) < 0)
|
|
break;
|
|
bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
|
|
} else if (codePoint < 65536) {
|
|
if ((units -= 3) < 0)
|
|
break;
|
|
bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
|
|
} else if (codePoint < 1114112) {
|
|
if ((units -= 4) < 0)
|
|
break;
|
|
bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
|
|
} else {
|
|
throw new Error("Invalid code point");
|
|
}
|
|
}
|
|
return bytes;
|
|
}
|
|
function asciiToBytes(str) {
|
|
const byteArray = [];
|
|
for (let i = 0; i < str.length; ++i) {
|
|
byteArray.push(str.charCodeAt(i) & 255);
|
|
}
|
|
return byteArray;
|
|
}
|
|
function utf16leToBytes(str, units) {
|
|
let c, hi, lo;
|
|
const byteArray = [];
|
|
for (let i = 0; i < str.length; ++i) {
|
|
if ((units -= 2) < 0)
|
|
break;
|
|
c = str.charCodeAt(i);
|
|
hi = c >> 8;
|
|
lo = c % 256;
|
|
byteArray.push(lo);
|
|
byteArray.push(hi);
|
|
}
|
|
return byteArray;
|
|
}
|
|
function base64ToBytes(str) {
|
|
return base64.toByteArray(base64clean(str));
|
|
}
|
|
function blitBuffer(src, dst, offset, length) {
|
|
let i;
|
|
for (i = 0; i < length; ++i) {
|
|
if (i + offset >= dst.length || i >= src.length)
|
|
break;
|
|
dst[i + offset] = src[i];
|
|
}
|
|
return i;
|
|
}
|
|
function isInstance(obj, type) {
|
|
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
|
|
}
|
|
function numberIsNaN(obj) {
|
|
return obj !== obj;
|
|
}
|
|
var hexSliceLookupTable = function() {
|
|
const alphabet = "0123456789abcdef";
|
|
const table = new Array(256);
|
|
for (let i = 0; i < 16; ++i) {
|
|
const i16 = i * 16;
|
|
for (let j = 0; j < 16; ++j) {
|
|
table[i16 + j] = alphabet[i] + alphabet[j];
|
|
}
|
|
}
|
|
return table;
|
|
}();
|
|
function defineBigIntMethod(fn) {
|
|
return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
|
|
}
|
|
function BufferBigIntNotDefined() {
|
|
throw new Error("BigInt not supported");
|
|
}
|
|
}
|
|
});
|
|
|
|
// polyfill_buffer.js
|
|
var import_obsidian, buffer, Buffer2;
|
|
var init_polyfill_buffer = __esm({
|
|
"polyfill_buffer.js"() {
|
|
import_obsidian = __toModule(require("obsidian"));
|
|
if (import_obsidian.Platform.isMobileApp) {
|
|
buffer = require_buffer().Buffer;
|
|
} else {
|
|
buffer = global.Buffer;
|
|
}
|
|
Buffer2 = buffer;
|
|
}
|
|
});
|
|
|
|
// node_modules/async-lock/lib/index.js
|
|
var require_lib = __commonJS({
|
|
"node_modules/async-lock/lib/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var AsyncLock2 = function(opts) {
|
|
opts = opts || {};
|
|
this.Promise = opts.Promise || Promise;
|
|
this.queues = Object.create(null);
|
|
this.domainReentrant = opts.domainReentrant || false;
|
|
if (this.domainReentrant) {
|
|
if (typeof process === "undefined" || typeof process.domain === "undefined") {
|
|
throw new Error("Domain-reentrant locks require `process.domain` to exist. Please flip `opts.domainReentrant = false`, use a NodeJS version that still implements Domain, or install a browser polyfill.");
|
|
}
|
|
this.domains = Object.create(null);
|
|
}
|
|
this.timeout = opts.timeout || AsyncLock2.DEFAULT_TIMEOUT;
|
|
this.maxOccupationTime = opts.maxOccupationTime || AsyncLock2.DEFAULT_MAX_OCCUPATION_TIME;
|
|
if (opts.maxPending === Infinity || Number.isInteger(opts.maxPending) && opts.maxPending >= 0) {
|
|
this.maxPending = opts.maxPending;
|
|
} else {
|
|
this.maxPending = AsyncLock2.DEFAULT_MAX_PENDING;
|
|
}
|
|
};
|
|
AsyncLock2.DEFAULT_TIMEOUT = 0;
|
|
AsyncLock2.DEFAULT_MAX_OCCUPATION_TIME = 0;
|
|
AsyncLock2.DEFAULT_MAX_PENDING = 1e3;
|
|
AsyncLock2.prototype.acquire = function(key2, fn, cb, opts) {
|
|
if (Array.isArray(key2)) {
|
|
return this._acquireBatch(key2, fn, cb, opts);
|
|
}
|
|
if (typeof fn !== "function") {
|
|
throw new Error("You must pass a function to execute");
|
|
}
|
|
var deferredResolve = null;
|
|
var deferredReject = null;
|
|
var deferred2 = null;
|
|
if (typeof cb !== "function") {
|
|
opts = cb;
|
|
cb = null;
|
|
deferred2 = new this.Promise(function(resolve, reject) {
|
|
deferredResolve = resolve;
|
|
deferredReject = reject;
|
|
});
|
|
}
|
|
opts = opts || {};
|
|
var resolved = false;
|
|
var timer = null;
|
|
var occupationTimer = null;
|
|
var self3 = this;
|
|
var done = function(locked, err, ret) {
|
|
if (occupationTimer) {
|
|
clearTimeout(occupationTimer);
|
|
occupationTimer = null;
|
|
}
|
|
if (locked) {
|
|
if (!!self3.queues[key2] && self3.queues[key2].length === 0) {
|
|
delete self3.queues[key2];
|
|
}
|
|
if (self3.domainReentrant) {
|
|
delete self3.domains[key2];
|
|
}
|
|
}
|
|
if (!resolved) {
|
|
if (!deferred2) {
|
|
if (typeof cb === "function") {
|
|
cb(err, ret);
|
|
}
|
|
} else {
|
|
if (err) {
|
|
deferredReject(err);
|
|
} else {
|
|
deferredResolve(ret);
|
|
}
|
|
}
|
|
resolved = true;
|
|
}
|
|
if (locked) {
|
|
if (!!self3.queues[key2] && self3.queues[key2].length > 0) {
|
|
self3.queues[key2].shift()();
|
|
}
|
|
}
|
|
};
|
|
var exec = function(locked) {
|
|
if (resolved) {
|
|
return done(locked);
|
|
}
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
timer = null;
|
|
}
|
|
if (self3.domainReentrant && locked) {
|
|
self3.domains[key2] = process.domain;
|
|
}
|
|
if (fn.length === 1) {
|
|
var called = false;
|
|
try {
|
|
fn(function(err, ret) {
|
|
if (!called) {
|
|
called = true;
|
|
done(locked, err, ret);
|
|
}
|
|
});
|
|
} catch (err) {
|
|
if (!called) {
|
|
called = true;
|
|
done(locked, err);
|
|
}
|
|
}
|
|
} else {
|
|
self3._promiseTry(function() {
|
|
return fn();
|
|
}).then(function(ret) {
|
|
done(locked, void 0, ret);
|
|
}, function(error) {
|
|
done(locked, error);
|
|
});
|
|
}
|
|
};
|
|
if (self3.domainReentrant && !!process.domain) {
|
|
exec = process.domain.bind(exec);
|
|
}
|
|
if (!self3.queues[key2]) {
|
|
self3.queues[key2] = [];
|
|
exec(true);
|
|
} else if (self3.domainReentrant && !!process.domain && process.domain === self3.domains[key2]) {
|
|
exec(false);
|
|
} else if (self3.queues[key2].length >= self3.maxPending) {
|
|
done(false, new Error("Too many pending tasks in queue " + key2));
|
|
} else {
|
|
var taskFn = function() {
|
|
exec(true);
|
|
};
|
|
if (opts.skipQueue) {
|
|
self3.queues[key2].unshift(taskFn);
|
|
} else {
|
|
self3.queues[key2].push(taskFn);
|
|
}
|
|
var timeout = opts.timeout || self3.timeout;
|
|
if (timeout) {
|
|
timer = setTimeout(function() {
|
|
timer = null;
|
|
done(false, new Error("async-lock timed out in queue " + key2));
|
|
}, timeout);
|
|
}
|
|
}
|
|
var maxOccupationTime = opts.maxOccupationTime || self3.maxOccupationTime;
|
|
if (maxOccupationTime) {
|
|
occupationTimer = setTimeout(function() {
|
|
if (!!self3.queues[key2]) {
|
|
done(false, new Error("Maximum occupation time is exceeded in queue " + key2));
|
|
}
|
|
}, maxOccupationTime);
|
|
}
|
|
if (deferred2) {
|
|
return deferred2;
|
|
}
|
|
};
|
|
AsyncLock2.prototype._acquireBatch = function(keys, fn, cb, opts) {
|
|
if (typeof cb !== "function") {
|
|
opts = cb;
|
|
cb = null;
|
|
}
|
|
var self3 = this;
|
|
var getFn = function(key2, fn2) {
|
|
return function(cb2) {
|
|
self3.acquire(key2, fn2, cb2, opts);
|
|
};
|
|
};
|
|
var fnx = keys.reduceRight(function(prev, key2) {
|
|
return getFn(key2, prev);
|
|
}, fn);
|
|
if (typeof cb === "function") {
|
|
fnx(cb);
|
|
} else {
|
|
return new this.Promise(function(resolve, reject) {
|
|
if (fnx.length === 1) {
|
|
fnx(function(err, ret) {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(ret);
|
|
}
|
|
});
|
|
} else {
|
|
resolve(fnx());
|
|
}
|
|
});
|
|
}
|
|
};
|
|
AsyncLock2.prototype.isBusy = function(key2) {
|
|
if (!key2) {
|
|
return Object.keys(this.queues).length > 0;
|
|
} else {
|
|
return !!this.queues[key2];
|
|
}
|
|
};
|
|
AsyncLock2.prototype._promiseTry = function(fn) {
|
|
try {
|
|
return this.Promise.resolve(fn());
|
|
} catch (e) {
|
|
return this.Promise.reject(e);
|
|
}
|
|
};
|
|
module2.exports = AsyncLock2;
|
|
}
|
|
});
|
|
|
|
// node_modules/async-lock/index.js
|
|
var require_async_lock = __commonJS({
|
|
"node_modules/async-lock/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
module2.exports = require_lib();
|
|
}
|
|
});
|
|
|
|
// node_modules/inherits/inherits_browser.js
|
|
var require_inherits_browser = __commonJS({
|
|
"node_modules/inherits/inherits_browser.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
if (typeof Object.create === "function") {
|
|
module2.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor;
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
}
|
|
};
|
|
} else {
|
|
module2.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor;
|
|
var TempCtor = function() {
|
|
};
|
|
TempCtor.prototype = superCtor.prototype;
|
|
ctor.prototype = new TempCtor();
|
|
ctor.prototype.constructor = ctor;
|
|
}
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/safe-buffer/index.js
|
|
var require_safe_buffer = __commonJS({
|
|
"node_modules/safe-buffer/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
var buffer2 = require_buffer();
|
|
var Buffer3 = buffer2.Buffer;
|
|
function copyProps(src, dst) {
|
|
for (var key2 in src) {
|
|
dst[key2] = src[key2];
|
|
}
|
|
}
|
|
if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
|
|
module2.exports = buffer2;
|
|
} else {
|
|
copyProps(buffer2, exports);
|
|
exports.Buffer = SafeBuffer;
|
|
}
|
|
function SafeBuffer(arg, encodingOrOffset, length) {
|
|
return Buffer3(arg, encodingOrOffset, length);
|
|
}
|
|
SafeBuffer.prototype = Object.create(Buffer3.prototype);
|
|
copyProps(Buffer3, SafeBuffer);
|
|
SafeBuffer.from = function(arg, encodingOrOffset, length) {
|
|
if (typeof arg === "number") {
|
|
throw new TypeError("Argument must not be a number");
|
|
}
|
|
return Buffer3(arg, encodingOrOffset, length);
|
|
};
|
|
SafeBuffer.alloc = function(size, fill, encoding) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
var buf = Buffer3(size);
|
|
if (fill !== void 0) {
|
|
if (typeof encoding === "string") {
|
|
buf.fill(fill, encoding);
|
|
} else {
|
|
buf.fill(fill);
|
|
}
|
|
} else {
|
|
buf.fill(0);
|
|
}
|
|
return buf;
|
|
};
|
|
SafeBuffer.allocUnsafe = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return Buffer3(size);
|
|
};
|
|
SafeBuffer.allocUnsafeSlow = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return buffer2.SlowBuffer(size);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/sha.js/hash.js
|
|
var require_hash = __commonJS({
|
|
"node_modules/sha.js/hash.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
var Buffer3 = require_safe_buffer().Buffer;
|
|
function Hash2(blockSize, finalSize) {
|
|
this._block = Buffer3.alloc(blockSize);
|
|
this._finalSize = finalSize;
|
|
this._blockSize = blockSize;
|
|
this._len = 0;
|
|
}
|
|
Hash2.prototype.update = function(data, enc) {
|
|
if (typeof data === "string") {
|
|
enc = enc || "utf8";
|
|
data = Buffer3.from(data, enc);
|
|
}
|
|
var block = this._block;
|
|
var blockSize = this._blockSize;
|
|
var length = data.length;
|
|
var accum = this._len;
|
|
for (var offset = 0; offset < length; ) {
|
|
var assigned = accum % blockSize;
|
|
var remainder = Math.min(length - offset, blockSize - assigned);
|
|
for (var i = 0; i < remainder; i++) {
|
|
block[assigned + i] = data[offset + i];
|
|
}
|
|
accum += remainder;
|
|
offset += remainder;
|
|
if (accum % blockSize === 0) {
|
|
this._update(block);
|
|
}
|
|
}
|
|
this._len += length;
|
|
return this;
|
|
};
|
|
Hash2.prototype.digest = function(enc) {
|
|
var rem = this._len % this._blockSize;
|
|
this._block[rem] = 128;
|
|
this._block.fill(0, rem + 1);
|
|
if (rem >= this._finalSize) {
|
|
this._update(this._block);
|
|
this._block.fill(0);
|
|
}
|
|
var bits = this._len * 8;
|
|
if (bits <= 4294967295) {
|
|
this._block.writeUInt32BE(bits, this._blockSize - 4);
|
|
} else {
|
|
var lowBits = (bits & 4294967295) >>> 0;
|
|
var highBits = (bits - lowBits) / 4294967296;
|
|
this._block.writeUInt32BE(highBits, this._blockSize - 8);
|
|
this._block.writeUInt32BE(lowBits, this._blockSize - 4);
|
|
}
|
|
this._update(this._block);
|
|
var hash2 = this._hash();
|
|
return enc ? hash2.toString(enc) : hash2;
|
|
};
|
|
Hash2.prototype._update = function() {
|
|
throw new Error("_update must be implemented by subclass");
|
|
};
|
|
module2.exports = Hash2;
|
|
}
|
|
});
|
|
|
|
// node_modules/sha.js/sha1.js
|
|
var require_sha1 = __commonJS({
|
|
"node_modules/sha.js/sha1.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
var inherits = require_inherits_browser();
|
|
var Hash2 = require_hash();
|
|
var Buffer3 = require_safe_buffer().Buffer;
|
|
var K = [
|
|
1518500249,
|
|
1859775393,
|
|
2400959708 | 0,
|
|
3395469782 | 0
|
|
];
|
|
var W = new Array(80);
|
|
function Sha1() {
|
|
this.init();
|
|
this._w = W;
|
|
Hash2.call(this, 64, 56);
|
|
}
|
|
inherits(Sha1, Hash2);
|
|
Sha1.prototype.init = function() {
|
|
this._a = 1732584193;
|
|
this._b = 4023233417;
|
|
this._c = 2562383102;
|
|
this._d = 271733878;
|
|
this._e = 3285377520;
|
|
return this;
|
|
};
|
|
function rotl1(num2) {
|
|
return num2 << 1 | num2 >>> 31;
|
|
}
|
|
function rotl5(num2) {
|
|
return num2 << 5 | num2 >>> 27;
|
|
}
|
|
function rotl30(num2) {
|
|
return num2 << 30 | num2 >>> 2;
|
|
}
|
|
function ft(s, b, c, d) {
|
|
if (s === 0)
|
|
return b & c | ~b & d;
|
|
if (s === 2)
|
|
return b & c | b & d | c & d;
|
|
return b ^ c ^ d;
|
|
}
|
|
Sha1.prototype._update = function(M) {
|
|
var W2 = this._w;
|
|
var a = this._a | 0;
|
|
var b = this._b | 0;
|
|
var c = this._c | 0;
|
|
var d = this._d | 0;
|
|
var e = this._e | 0;
|
|
for (var i = 0; i < 16; ++i)
|
|
W2[i] = M.readInt32BE(i * 4);
|
|
for (; i < 80; ++i)
|
|
W2[i] = rotl1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]);
|
|
for (var j = 0; j < 80; ++j) {
|
|
var s = ~~(j / 20);
|
|
var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0;
|
|
e = d;
|
|
d = c;
|
|
c = rotl30(b);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
this._a = a + this._a | 0;
|
|
this._b = b + this._b | 0;
|
|
this._c = c + this._c | 0;
|
|
this._d = d + this._d | 0;
|
|
this._e = e + this._e | 0;
|
|
};
|
|
Sha1.prototype._hash = function() {
|
|
var H = Buffer3.allocUnsafe(20);
|
|
H.writeInt32BE(this._a | 0, 0);
|
|
H.writeInt32BE(this._b | 0, 4);
|
|
H.writeInt32BE(this._c | 0, 8);
|
|
H.writeInt32BE(this._d | 0, 12);
|
|
H.writeInt32BE(this._e | 0, 16);
|
|
return H;
|
|
};
|
|
module2.exports = Sha1;
|
|
}
|
|
});
|
|
|
|
// node_modules/crc-32/crc32.js
|
|
var require_crc32 = __commonJS({
|
|
"node_modules/crc-32/crc32.js"(exports) {
|
|
init_polyfill_buffer();
|
|
var CRC32;
|
|
(function(factory) {
|
|
if (typeof DO_NOT_EXPORT_CRC === "undefined") {
|
|
if (typeof exports === "object") {
|
|
factory(exports);
|
|
} else if (typeof define === "function" && define.amd) {
|
|
define(function() {
|
|
var module3 = {};
|
|
factory(module3);
|
|
return module3;
|
|
});
|
|
} else {
|
|
factory(CRC32 = {});
|
|
}
|
|
} else {
|
|
factory(CRC32 = {});
|
|
}
|
|
})(function(CRC322) {
|
|
CRC322.version = "1.2.2";
|
|
function signed_crc_table() {
|
|
var c = 0, table = new Array(256);
|
|
for (var n = 0; n != 256; ++n) {
|
|
c = n;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
table[n] = c;
|
|
}
|
|
return typeof Int32Array !== "undefined" ? new Int32Array(table) : table;
|
|
}
|
|
var T0 = signed_crc_table();
|
|
function slice_by_16_tables(T) {
|
|
var c = 0, v = 0, n = 0, table = typeof Int32Array !== "undefined" ? new Int32Array(4096) : new Array(4096);
|
|
for (n = 0; n != 256; ++n)
|
|
table[n] = T[n];
|
|
for (n = 0; n != 256; ++n) {
|
|
v = T[n];
|
|
for (c = 256 + n; c < 4096; c += 256)
|
|
v = table[c] = v >>> 8 ^ T[v & 255];
|
|
}
|
|
var out = [];
|
|
for (n = 1; n != 16; ++n)
|
|
out[n - 1] = typeof Int32Array !== "undefined" ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256);
|
|
return out;
|
|
}
|
|
var TT = slice_by_16_tables(T0);
|
|
var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4];
|
|
var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9];
|
|
var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14];
|
|
function crc32_bstr(bstr, seed) {
|
|
var C = seed ^ -1;
|
|
for (var i = 0, L = bstr.length; i < L; )
|
|
C = C >>> 8 ^ T0[(C ^ bstr.charCodeAt(i++)) & 255];
|
|
return ~C;
|
|
}
|
|
function crc32_buf(B, seed) {
|
|
var C = seed ^ -1, L = B.length - 15, i = 0;
|
|
for (; i < L; )
|
|
C = Tf[B[i++] ^ C & 255] ^ Te[B[i++] ^ C >> 8 & 255] ^ Td[B[i++] ^ C >> 16 & 255] ^ Tc[B[i++] ^ C >>> 24] ^ Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^ T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^ T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]];
|
|
L += 15;
|
|
while (i < L)
|
|
C = C >>> 8 ^ T0[(C ^ B[i++]) & 255];
|
|
return ~C;
|
|
}
|
|
function crc32_str(str, seed) {
|
|
var C = seed ^ -1;
|
|
for (var i = 0, L = str.length, c = 0, d = 0; i < L; ) {
|
|
c = str.charCodeAt(i++);
|
|
if (c < 128) {
|
|
C = C >>> 8 ^ T0[(C ^ c) & 255];
|
|
} else if (c < 2048) {
|
|
C = C >>> 8 ^ T0[(C ^ (192 | c >> 6 & 31)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
|
|
} else if (c >= 55296 && c < 57344) {
|
|
c = (c & 1023) + 64;
|
|
d = str.charCodeAt(i++) & 1023;
|
|
C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | d & 63)) & 255];
|
|
} else {
|
|
C = C >>> 8 ^ T0[(C ^ (224 | c >> 12 & 15)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c >> 6 & 63)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
|
|
}
|
|
}
|
|
return ~C;
|
|
}
|
|
CRC322.table = T0;
|
|
CRC322.bstr = crc32_bstr;
|
|
CRC322.buf = crc32_buf;
|
|
CRC322.str = crc32_str;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/utils/common.js
|
|
var require_common = __commonJS({
|
|
"node_modules/pako/lib/utils/common.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined";
|
|
function _has(obj, key2) {
|
|
return Object.prototype.hasOwnProperty.call(obj, key2);
|
|
}
|
|
exports.assign = function(obj) {
|
|
var sources = Array.prototype.slice.call(arguments, 1);
|
|
while (sources.length) {
|
|
var source = sources.shift();
|
|
if (!source) {
|
|
continue;
|
|
}
|
|
if (typeof source !== "object") {
|
|
throw new TypeError(source + "must be non-object");
|
|
}
|
|
for (var p in source) {
|
|
if (_has(source, p)) {
|
|
obj[p] = source[p];
|
|
}
|
|
}
|
|
}
|
|
return obj;
|
|
};
|
|
exports.shrinkBuf = function(buf, size) {
|
|
if (buf.length === size) {
|
|
return buf;
|
|
}
|
|
if (buf.subarray) {
|
|
return buf.subarray(0, size);
|
|
}
|
|
buf.length = size;
|
|
return buf;
|
|
};
|
|
var fnTyped = {
|
|
arraySet: function(dest, src, src_offs, len, dest_offs) {
|
|
if (src.subarray && dest.subarray) {
|
|
dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
|
|
return;
|
|
}
|
|
for (var i = 0; i < len; i++) {
|
|
dest[dest_offs + i] = src[src_offs + i];
|
|
}
|
|
},
|
|
flattenChunks: function(chunks) {
|
|
var i, l, len, pos, chunk, result;
|
|
len = 0;
|
|
for (i = 0, l = chunks.length; i < l; i++) {
|
|
len += chunks[i].length;
|
|
}
|
|
result = new Uint8Array(len);
|
|
pos = 0;
|
|
for (i = 0, l = chunks.length; i < l; i++) {
|
|
chunk = chunks[i];
|
|
result.set(chunk, pos);
|
|
pos += chunk.length;
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
var fnUntyped = {
|
|
arraySet: function(dest, src, src_offs, len, dest_offs) {
|
|
for (var i = 0; i < len; i++) {
|
|
dest[dest_offs + i] = src[src_offs + i];
|
|
}
|
|
},
|
|
flattenChunks: function(chunks) {
|
|
return [].concat.apply([], chunks);
|
|
}
|
|
};
|
|
exports.setTyped = function(on) {
|
|
if (on) {
|
|
exports.Buf8 = Uint8Array;
|
|
exports.Buf16 = Uint16Array;
|
|
exports.Buf32 = Int32Array;
|
|
exports.assign(exports, fnTyped);
|
|
} else {
|
|
exports.Buf8 = Array;
|
|
exports.Buf16 = Array;
|
|
exports.Buf32 = Array;
|
|
exports.assign(exports, fnUntyped);
|
|
}
|
|
};
|
|
exports.setTyped(TYPED_OK);
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/trees.js
|
|
var require_trees = __commonJS({
|
|
"node_modules/pako/lib/zlib/trees.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var utils = require_common();
|
|
var Z_FIXED = 4;
|
|
var Z_BINARY = 0;
|
|
var Z_TEXT = 1;
|
|
var Z_UNKNOWN = 2;
|
|
function zero(buf) {
|
|
var len = buf.length;
|
|
while (--len >= 0) {
|
|
buf[len] = 0;
|
|
}
|
|
}
|
|
var STORED_BLOCK = 0;
|
|
var STATIC_TREES = 1;
|
|
var DYN_TREES = 2;
|
|
var MIN_MATCH = 3;
|
|
var MAX_MATCH = 258;
|
|
var LENGTH_CODES = 29;
|
|
var LITERALS = 256;
|
|
var L_CODES = LITERALS + 1 + LENGTH_CODES;
|
|
var D_CODES = 30;
|
|
var BL_CODES = 19;
|
|
var HEAP_SIZE = 2 * L_CODES + 1;
|
|
var MAX_BITS = 15;
|
|
var Buf_size = 16;
|
|
var MAX_BL_BITS = 7;
|
|
var END_BLOCK = 256;
|
|
var REP_3_6 = 16;
|
|
var REPZ_3_10 = 17;
|
|
var REPZ_11_138 = 18;
|
|
var extra_lbits = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
|
|
var extra_dbits = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
|
|
var extra_blbits = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7];
|
|
var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
|
var DIST_CODE_LEN = 512;
|
|
var static_ltree = new Array((L_CODES + 2) * 2);
|
|
zero(static_ltree);
|
|
var static_dtree = new Array(D_CODES * 2);
|
|
zero(static_dtree);
|
|
var _dist_code = new Array(DIST_CODE_LEN);
|
|
zero(_dist_code);
|
|
var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
|
|
zero(_length_code);
|
|
var base_length = new Array(LENGTH_CODES);
|
|
zero(base_length);
|
|
var base_dist = new Array(D_CODES);
|
|
zero(base_dist);
|
|
function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
|
|
this.static_tree = static_tree;
|
|
this.extra_bits = extra_bits;
|
|
this.extra_base = extra_base;
|
|
this.elems = elems;
|
|
this.max_length = max_length;
|
|
this.has_stree = static_tree && static_tree.length;
|
|
}
|
|
var static_l_desc;
|
|
var static_d_desc;
|
|
var static_bl_desc;
|
|
function TreeDesc(dyn_tree, stat_desc) {
|
|
this.dyn_tree = dyn_tree;
|
|
this.max_code = 0;
|
|
this.stat_desc = stat_desc;
|
|
}
|
|
function d_code(dist) {
|
|
return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
|
|
}
|
|
function put_short(s, w) {
|
|
s.pending_buf[s.pending++] = w & 255;
|
|
s.pending_buf[s.pending++] = w >>> 8 & 255;
|
|
}
|
|
function send_bits(s, value, length) {
|
|
if (s.bi_valid > Buf_size - length) {
|
|
s.bi_buf |= value << s.bi_valid & 65535;
|
|
put_short(s, s.bi_buf);
|
|
s.bi_buf = value >> Buf_size - s.bi_valid;
|
|
s.bi_valid += length - Buf_size;
|
|
} else {
|
|
s.bi_buf |= value << s.bi_valid & 65535;
|
|
s.bi_valid += length;
|
|
}
|
|
}
|
|
function send_code(s, c, tree) {
|
|
send_bits(s, tree[c * 2], tree[c * 2 + 1]);
|
|
}
|
|
function bi_reverse(code, len) {
|
|
var res = 0;
|
|
do {
|
|
res |= code & 1;
|
|
code >>>= 1;
|
|
res <<= 1;
|
|
} while (--len > 0);
|
|
return res >>> 1;
|
|
}
|
|
function bi_flush(s) {
|
|
if (s.bi_valid === 16) {
|
|
put_short(s, s.bi_buf);
|
|
s.bi_buf = 0;
|
|
s.bi_valid = 0;
|
|
} else if (s.bi_valid >= 8) {
|
|
s.pending_buf[s.pending++] = s.bi_buf & 255;
|
|
s.bi_buf >>= 8;
|
|
s.bi_valid -= 8;
|
|
}
|
|
}
|
|
function gen_bitlen(s, desc) {
|
|
var tree = desc.dyn_tree;
|
|
var max_code = desc.max_code;
|
|
var stree = desc.stat_desc.static_tree;
|
|
var has_stree = desc.stat_desc.has_stree;
|
|
var extra = desc.stat_desc.extra_bits;
|
|
var base = desc.stat_desc.extra_base;
|
|
var max_length = desc.stat_desc.max_length;
|
|
var h;
|
|
var n, m;
|
|
var bits;
|
|
var xbits;
|
|
var f;
|
|
var overflow = 0;
|
|
for (bits = 0; bits <= MAX_BITS; bits++) {
|
|
s.bl_count[bits] = 0;
|
|
}
|
|
tree[s.heap[s.heap_max] * 2 + 1] = 0;
|
|
for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
|
|
n = s.heap[h];
|
|
bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
|
|
if (bits > max_length) {
|
|
bits = max_length;
|
|
overflow++;
|
|
}
|
|
tree[n * 2 + 1] = bits;
|
|
if (n > max_code) {
|
|
continue;
|
|
}
|
|
s.bl_count[bits]++;
|
|
xbits = 0;
|
|
if (n >= base) {
|
|
xbits = extra[n - base];
|
|
}
|
|
f = tree[n * 2];
|
|
s.opt_len += f * (bits + xbits);
|
|
if (has_stree) {
|
|
s.static_len += f * (stree[n * 2 + 1] + xbits);
|
|
}
|
|
}
|
|
if (overflow === 0) {
|
|
return;
|
|
}
|
|
do {
|
|
bits = max_length - 1;
|
|
while (s.bl_count[bits] === 0) {
|
|
bits--;
|
|
}
|
|
s.bl_count[bits]--;
|
|
s.bl_count[bits + 1] += 2;
|
|
s.bl_count[max_length]--;
|
|
overflow -= 2;
|
|
} while (overflow > 0);
|
|
for (bits = max_length; bits !== 0; bits--) {
|
|
n = s.bl_count[bits];
|
|
while (n !== 0) {
|
|
m = s.heap[--h];
|
|
if (m > max_code) {
|
|
continue;
|
|
}
|
|
if (tree[m * 2 + 1] !== bits) {
|
|
s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
|
|
tree[m * 2 + 1] = bits;
|
|
}
|
|
n--;
|
|
}
|
|
}
|
|
}
|
|
function gen_codes(tree, max_code, bl_count) {
|
|
var next_code = new Array(MAX_BITS + 1);
|
|
var code = 0;
|
|
var bits;
|
|
var n;
|
|
for (bits = 1; bits <= MAX_BITS; bits++) {
|
|
next_code[bits] = code = code + bl_count[bits - 1] << 1;
|
|
}
|
|
for (n = 0; n <= max_code; n++) {
|
|
var len = tree[n * 2 + 1];
|
|
if (len === 0) {
|
|
continue;
|
|
}
|
|
tree[n * 2] = bi_reverse(next_code[len]++, len);
|
|
}
|
|
}
|
|
function tr_static_init() {
|
|
var n;
|
|
var bits;
|
|
var length;
|
|
var code;
|
|
var dist;
|
|
var bl_count = new Array(MAX_BITS + 1);
|
|
length = 0;
|
|
for (code = 0; code < LENGTH_CODES - 1; code++) {
|
|
base_length[code] = length;
|
|
for (n = 0; n < 1 << extra_lbits[code]; n++) {
|
|
_length_code[length++] = code;
|
|
}
|
|
}
|
|
_length_code[length - 1] = code;
|
|
dist = 0;
|
|
for (code = 0; code < 16; code++) {
|
|
base_dist[code] = dist;
|
|
for (n = 0; n < 1 << extra_dbits[code]; n++) {
|
|
_dist_code[dist++] = code;
|
|
}
|
|
}
|
|
dist >>= 7;
|
|
for (; code < D_CODES; code++) {
|
|
base_dist[code] = dist << 7;
|
|
for (n = 0; n < 1 << extra_dbits[code] - 7; n++) {
|
|
_dist_code[256 + dist++] = code;
|
|
}
|
|
}
|
|
for (bits = 0; bits <= MAX_BITS; bits++) {
|
|
bl_count[bits] = 0;
|
|
}
|
|
n = 0;
|
|
while (n <= 143) {
|
|
static_ltree[n * 2 + 1] = 8;
|
|
n++;
|
|
bl_count[8]++;
|
|
}
|
|
while (n <= 255) {
|
|
static_ltree[n * 2 + 1] = 9;
|
|
n++;
|
|
bl_count[9]++;
|
|
}
|
|
while (n <= 279) {
|
|
static_ltree[n * 2 + 1] = 7;
|
|
n++;
|
|
bl_count[7]++;
|
|
}
|
|
while (n <= 287) {
|
|
static_ltree[n * 2 + 1] = 8;
|
|
n++;
|
|
bl_count[8]++;
|
|
}
|
|
gen_codes(static_ltree, L_CODES + 1, bl_count);
|
|
for (n = 0; n < D_CODES; n++) {
|
|
static_dtree[n * 2 + 1] = 5;
|
|
static_dtree[n * 2] = bi_reverse(n, 5);
|
|
}
|
|
static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
|
|
static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
|
|
static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
|
|
}
|
|
function init_block(s) {
|
|
var n;
|
|
for (n = 0; n < L_CODES; n++) {
|
|
s.dyn_ltree[n * 2] = 0;
|
|
}
|
|
for (n = 0; n < D_CODES; n++) {
|
|
s.dyn_dtree[n * 2] = 0;
|
|
}
|
|
for (n = 0; n < BL_CODES; n++) {
|
|
s.bl_tree[n * 2] = 0;
|
|
}
|
|
s.dyn_ltree[END_BLOCK * 2] = 1;
|
|
s.opt_len = s.static_len = 0;
|
|
s.last_lit = s.matches = 0;
|
|
}
|
|
function bi_windup(s) {
|
|
if (s.bi_valid > 8) {
|
|
put_short(s, s.bi_buf);
|
|
} else if (s.bi_valid > 0) {
|
|
s.pending_buf[s.pending++] = s.bi_buf;
|
|
}
|
|
s.bi_buf = 0;
|
|
s.bi_valid = 0;
|
|
}
|
|
function copy_block(s, buf, len, header) {
|
|
bi_windup(s);
|
|
if (header) {
|
|
put_short(s, len);
|
|
put_short(s, ~len);
|
|
}
|
|
utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
|
|
s.pending += len;
|
|
}
|
|
function smaller(tree, n, m, depth) {
|
|
var _n2 = n * 2;
|
|
var _m2 = m * 2;
|
|
return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m];
|
|
}
|
|
function pqdownheap(s, tree, k) {
|
|
var v = s.heap[k];
|
|
var j = k << 1;
|
|
while (j <= s.heap_len) {
|
|
if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
|
|
j++;
|
|
}
|
|
if (smaller(tree, v, s.heap[j], s.depth)) {
|
|
break;
|
|
}
|
|
s.heap[k] = s.heap[j];
|
|
k = j;
|
|
j <<= 1;
|
|
}
|
|
s.heap[k] = v;
|
|
}
|
|
function compress_block(s, ltree, dtree) {
|
|
var dist;
|
|
var lc;
|
|
var lx = 0;
|
|
var code;
|
|
var extra;
|
|
if (s.last_lit !== 0) {
|
|
do {
|
|
dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1];
|
|
lc = s.pending_buf[s.l_buf + lx];
|
|
lx++;
|
|
if (dist === 0) {
|
|
send_code(s, lc, ltree);
|
|
} else {
|
|
code = _length_code[lc];
|
|
send_code(s, code + LITERALS + 1, ltree);
|
|
extra = extra_lbits[code];
|
|
if (extra !== 0) {
|
|
lc -= base_length[code];
|
|
send_bits(s, lc, extra);
|
|
}
|
|
dist--;
|
|
code = d_code(dist);
|
|
send_code(s, code, dtree);
|
|
extra = extra_dbits[code];
|
|
if (extra !== 0) {
|
|
dist -= base_dist[code];
|
|
send_bits(s, dist, extra);
|
|
}
|
|
}
|
|
} while (lx < s.last_lit);
|
|
}
|
|
send_code(s, END_BLOCK, ltree);
|
|
}
|
|
function build_tree(s, desc) {
|
|
var tree = desc.dyn_tree;
|
|
var stree = desc.stat_desc.static_tree;
|
|
var has_stree = desc.stat_desc.has_stree;
|
|
var elems = desc.stat_desc.elems;
|
|
var n, m;
|
|
var max_code = -1;
|
|
var node;
|
|
s.heap_len = 0;
|
|
s.heap_max = HEAP_SIZE;
|
|
for (n = 0; n < elems; n++) {
|
|
if (tree[n * 2] !== 0) {
|
|
s.heap[++s.heap_len] = max_code = n;
|
|
s.depth[n] = 0;
|
|
} else {
|
|
tree[n * 2 + 1] = 0;
|
|
}
|
|
}
|
|
while (s.heap_len < 2) {
|
|
node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
|
|
tree[node * 2] = 1;
|
|
s.depth[node] = 0;
|
|
s.opt_len--;
|
|
if (has_stree) {
|
|
s.static_len -= stree[node * 2 + 1];
|
|
}
|
|
}
|
|
desc.max_code = max_code;
|
|
for (n = s.heap_len >> 1; n >= 1; n--) {
|
|
pqdownheap(s, tree, n);
|
|
}
|
|
node = elems;
|
|
do {
|
|
n = s.heap[1];
|
|
s.heap[1] = s.heap[s.heap_len--];
|
|
pqdownheap(s, tree, 1);
|
|
m = s.heap[1];
|
|
s.heap[--s.heap_max] = n;
|
|
s.heap[--s.heap_max] = m;
|
|
tree[node * 2] = tree[n * 2] + tree[m * 2];
|
|
s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
|
|
tree[n * 2 + 1] = tree[m * 2 + 1] = node;
|
|
s.heap[1] = node++;
|
|
pqdownheap(s, tree, 1);
|
|
} while (s.heap_len >= 2);
|
|
s.heap[--s.heap_max] = s.heap[1];
|
|
gen_bitlen(s, desc);
|
|
gen_codes(tree, max_code, s.bl_count);
|
|
}
|
|
function scan_tree(s, tree, max_code) {
|
|
var n;
|
|
var prevlen = -1;
|
|
var curlen;
|
|
var nextlen = tree[0 * 2 + 1];
|
|
var count = 0;
|
|
var max_count = 7;
|
|
var min_count = 4;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
}
|
|
tree[(max_code + 1) * 2 + 1] = 65535;
|
|
for (n = 0; n <= max_code; n++) {
|
|
curlen = nextlen;
|
|
nextlen = tree[(n + 1) * 2 + 1];
|
|
if (++count < max_count && curlen === nextlen) {
|
|
continue;
|
|
} else if (count < min_count) {
|
|
s.bl_tree[curlen * 2] += count;
|
|
} else if (curlen !== 0) {
|
|
if (curlen !== prevlen) {
|
|
s.bl_tree[curlen * 2]++;
|
|
}
|
|
s.bl_tree[REP_3_6 * 2]++;
|
|
} else if (count <= 10) {
|
|
s.bl_tree[REPZ_3_10 * 2]++;
|
|
} else {
|
|
s.bl_tree[REPZ_11_138 * 2]++;
|
|
}
|
|
count = 0;
|
|
prevlen = curlen;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
} else if (curlen === nextlen) {
|
|
max_count = 6;
|
|
min_count = 3;
|
|
} else {
|
|
max_count = 7;
|
|
min_count = 4;
|
|
}
|
|
}
|
|
}
|
|
function send_tree(s, tree, max_code) {
|
|
var n;
|
|
var prevlen = -1;
|
|
var curlen;
|
|
var nextlen = tree[0 * 2 + 1];
|
|
var count = 0;
|
|
var max_count = 7;
|
|
var min_count = 4;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
}
|
|
for (n = 0; n <= max_code; n++) {
|
|
curlen = nextlen;
|
|
nextlen = tree[(n + 1) * 2 + 1];
|
|
if (++count < max_count && curlen === nextlen) {
|
|
continue;
|
|
} else if (count < min_count) {
|
|
do {
|
|
send_code(s, curlen, s.bl_tree);
|
|
} while (--count !== 0);
|
|
} else if (curlen !== 0) {
|
|
if (curlen !== prevlen) {
|
|
send_code(s, curlen, s.bl_tree);
|
|
count--;
|
|
}
|
|
send_code(s, REP_3_6, s.bl_tree);
|
|
send_bits(s, count - 3, 2);
|
|
} else if (count <= 10) {
|
|
send_code(s, REPZ_3_10, s.bl_tree);
|
|
send_bits(s, count - 3, 3);
|
|
} else {
|
|
send_code(s, REPZ_11_138, s.bl_tree);
|
|
send_bits(s, count - 11, 7);
|
|
}
|
|
count = 0;
|
|
prevlen = curlen;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
} else if (curlen === nextlen) {
|
|
max_count = 6;
|
|
min_count = 3;
|
|
} else {
|
|
max_count = 7;
|
|
min_count = 4;
|
|
}
|
|
}
|
|
}
|
|
function build_bl_tree(s) {
|
|
var max_blindex;
|
|
scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
|
|
scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
|
|
build_tree(s, s.bl_desc);
|
|
for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
|
|
if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) {
|
|
break;
|
|
}
|
|
}
|
|
s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
|
|
return max_blindex;
|
|
}
|
|
function send_all_trees(s, lcodes, dcodes, blcodes) {
|
|
var rank;
|
|
send_bits(s, lcodes - 257, 5);
|
|
send_bits(s, dcodes - 1, 5);
|
|
send_bits(s, blcodes - 4, 4);
|
|
for (rank = 0; rank < blcodes; rank++) {
|
|
send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3);
|
|
}
|
|
send_tree(s, s.dyn_ltree, lcodes - 1);
|
|
send_tree(s, s.dyn_dtree, dcodes - 1);
|
|
}
|
|
function detect_data_type(s) {
|
|
var black_mask = 4093624447;
|
|
var n;
|
|
for (n = 0; n <= 31; n++, black_mask >>>= 1) {
|
|
if (black_mask & 1 && s.dyn_ltree[n * 2] !== 0) {
|
|
return Z_BINARY;
|
|
}
|
|
}
|
|
if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) {
|
|
return Z_TEXT;
|
|
}
|
|
for (n = 32; n < LITERALS; n++) {
|
|
if (s.dyn_ltree[n * 2] !== 0) {
|
|
return Z_TEXT;
|
|
}
|
|
}
|
|
return Z_BINARY;
|
|
}
|
|
var static_init_done = false;
|
|
function _tr_init(s) {
|
|
if (!static_init_done) {
|
|
tr_static_init();
|
|
static_init_done = true;
|
|
}
|
|
s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
|
|
s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
|
|
s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
|
|
s.bi_buf = 0;
|
|
s.bi_valid = 0;
|
|
init_block(s);
|
|
}
|
|
function _tr_stored_block(s, buf, stored_len, last2) {
|
|
send_bits(s, (STORED_BLOCK << 1) + (last2 ? 1 : 0), 3);
|
|
copy_block(s, buf, stored_len, true);
|
|
}
|
|
function _tr_align(s) {
|
|
send_bits(s, STATIC_TREES << 1, 3);
|
|
send_code(s, END_BLOCK, static_ltree);
|
|
bi_flush(s);
|
|
}
|
|
function _tr_flush_block(s, buf, stored_len, last2) {
|
|
var opt_lenb, static_lenb;
|
|
var max_blindex = 0;
|
|
if (s.level > 0) {
|
|
if (s.strm.data_type === Z_UNKNOWN) {
|
|
s.strm.data_type = detect_data_type(s);
|
|
}
|
|
build_tree(s, s.l_desc);
|
|
build_tree(s, s.d_desc);
|
|
max_blindex = build_bl_tree(s);
|
|
opt_lenb = s.opt_len + 3 + 7 >>> 3;
|
|
static_lenb = s.static_len + 3 + 7 >>> 3;
|
|
if (static_lenb <= opt_lenb) {
|
|
opt_lenb = static_lenb;
|
|
}
|
|
} else {
|
|
opt_lenb = static_lenb = stored_len + 5;
|
|
}
|
|
if (stored_len + 4 <= opt_lenb && buf !== -1) {
|
|
_tr_stored_block(s, buf, stored_len, last2);
|
|
} else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
|
|
send_bits(s, (STATIC_TREES << 1) + (last2 ? 1 : 0), 3);
|
|
compress_block(s, static_ltree, static_dtree);
|
|
} else {
|
|
send_bits(s, (DYN_TREES << 1) + (last2 ? 1 : 0), 3);
|
|
send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
|
|
compress_block(s, s.dyn_ltree, s.dyn_dtree);
|
|
}
|
|
init_block(s);
|
|
if (last2) {
|
|
bi_windup(s);
|
|
}
|
|
}
|
|
function _tr_tally(s, dist, lc) {
|
|
s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 255;
|
|
s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 255;
|
|
s.pending_buf[s.l_buf + s.last_lit] = lc & 255;
|
|
s.last_lit++;
|
|
if (dist === 0) {
|
|
s.dyn_ltree[lc * 2]++;
|
|
} else {
|
|
s.matches++;
|
|
dist--;
|
|
s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++;
|
|
s.dyn_dtree[d_code(dist) * 2]++;
|
|
}
|
|
return s.last_lit === s.lit_bufsize - 1;
|
|
}
|
|
exports._tr_init = _tr_init;
|
|
exports._tr_stored_block = _tr_stored_block;
|
|
exports._tr_flush_block = _tr_flush_block;
|
|
exports._tr_tally = _tr_tally;
|
|
exports._tr_align = _tr_align;
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/adler32.js
|
|
var require_adler32 = __commonJS({
|
|
"node_modules/pako/lib/zlib/adler32.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
function adler32(adler, buf, len, pos) {
|
|
var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;
|
|
while (len !== 0) {
|
|
n = len > 2e3 ? 2e3 : len;
|
|
len -= n;
|
|
do {
|
|
s1 = s1 + buf[pos++] | 0;
|
|
s2 = s2 + s1 | 0;
|
|
} while (--n);
|
|
s1 %= 65521;
|
|
s2 %= 65521;
|
|
}
|
|
return s1 | s2 << 16 | 0;
|
|
}
|
|
module2.exports = adler32;
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/crc32.js
|
|
var require_crc322 = __commonJS({
|
|
"node_modules/pako/lib/zlib/crc32.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
function makeTable() {
|
|
var c, table = [];
|
|
for (var n = 0; n < 256; n++) {
|
|
c = n;
|
|
for (var k = 0; k < 8; k++) {
|
|
c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
|
|
}
|
|
table[n] = c;
|
|
}
|
|
return table;
|
|
}
|
|
var crcTable = makeTable();
|
|
function crc322(crc, buf, len, pos) {
|
|
var t = crcTable, end = pos + len;
|
|
crc ^= -1;
|
|
for (var i = pos; i < end; i++) {
|
|
crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255];
|
|
}
|
|
return crc ^ -1;
|
|
}
|
|
module2.exports = crc322;
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/messages.js
|
|
var require_messages = __commonJS({
|
|
"node_modules/pako/lib/zlib/messages.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
module2.exports = {
|
|
2: "need dictionary",
|
|
1: "stream end",
|
|
0: "",
|
|
"-1": "file error",
|
|
"-2": "stream error",
|
|
"-3": "data error",
|
|
"-4": "insufficient memory",
|
|
"-5": "buffer error",
|
|
"-6": "incompatible version"
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/deflate.js
|
|
var require_deflate = __commonJS({
|
|
"node_modules/pako/lib/zlib/deflate.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var utils = require_common();
|
|
var trees = require_trees();
|
|
var adler32 = require_adler32();
|
|
var crc322 = require_crc322();
|
|
var msg = require_messages();
|
|
var Z_NO_FLUSH = 0;
|
|
var Z_PARTIAL_FLUSH = 1;
|
|
var Z_FULL_FLUSH = 3;
|
|
var Z_FINISH = 4;
|
|
var Z_BLOCK = 5;
|
|
var Z_OK = 0;
|
|
var Z_STREAM_END = 1;
|
|
var Z_STREAM_ERROR = -2;
|
|
var Z_DATA_ERROR = -3;
|
|
var Z_BUF_ERROR = -5;
|
|
var Z_DEFAULT_COMPRESSION = -1;
|
|
var Z_FILTERED = 1;
|
|
var Z_HUFFMAN_ONLY = 2;
|
|
var Z_RLE = 3;
|
|
var Z_FIXED = 4;
|
|
var Z_DEFAULT_STRATEGY = 0;
|
|
var Z_UNKNOWN = 2;
|
|
var Z_DEFLATED = 8;
|
|
var MAX_MEM_LEVEL = 9;
|
|
var MAX_WBITS = 15;
|
|
var DEF_MEM_LEVEL = 8;
|
|
var LENGTH_CODES = 29;
|
|
var LITERALS = 256;
|
|
var L_CODES = LITERALS + 1 + LENGTH_CODES;
|
|
var D_CODES = 30;
|
|
var BL_CODES = 19;
|
|
var HEAP_SIZE = 2 * L_CODES + 1;
|
|
var MAX_BITS = 15;
|
|
var MIN_MATCH = 3;
|
|
var MAX_MATCH = 258;
|
|
var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
|
|
var PRESET_DICT = 32;
|
|
var INIT_STATE = 42;
|
|
var EXTRA_STATE = 69;
|
|
var NAME_STATE = 73;
|
|
var COMMENT_STATE = 91;
|
|
var HCRC_STATE = 103;
|
|
var BUSY_STATE = 113;
|
|
var FINISH_STATE = 666;
|
|
var BS_NEED_MORE = 1;
|
|
var BS_BLOCK_DONE = 2;
|
|
var BS_FINISH_STARTED = 3;
|
|
var BS_FINISH_DONE = 4;
|
|
var OS_CODE = 3;
|
|
function err(strm, errorCode) {
|
|
strm.msg = msg[errorCode];
|
|
return errorCode;
|
|
}
|
|
function rank(f) {
|
|
return (f << 1) - (f > 4 ? 9 : 0);
|
|
}
|
|
function zero(buf) {
|
|
var len = buf.length;
|
|
while (--len >= 0) {
|
|
buf[len] = 0;
|
|
}
|
|
}
|
|
function flush_pending(strm) {
|
|
var s = strm.state;
|
|
var len = s.pending;
|
|
if (len > strm.avail_out) {
|
|
len = strm.avail_out;
|
|
}
|
|
if (len === 0) {
|
|
return;
|
|
}
|
|
utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
|
|
strm.next_out += len;
|
|
s.pending_out += len;
|
|
strm.total_out += len;
|
|
strm.avail_out -= len;
|
|
s.pending -= len;
|
|
if (s.pending === 0) {
|
|
s.pending_out = 0;
|
|
}
|
|
}
|
|
function flush_block_only(s, last2) {
|
|
trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last2);
|
|
s.block_start = s.strstart;
|
|
flush_pending(s.strm);
|
|
}
|
|
function put_byte(s, b) {
|
|
s.pending_buf[s.pending++] = b;
|
|
}
|
|
function putShortMSB(s, b) {
|
|
s.pending_buf[s.pending++] = b >>> 8 & 255;
|
|
s.pending_buf[s.pending++] = b & 255;
|
|
}
|
|
function read_buf(strm, buf, start, size) {
|
|
var len = strm.avail_in;
|
|
if (len > size) {
|
|
len = size;
|
|
}
|
|
if (len === 0) {
|
|
return 0;
|
|
}
|
|
strm.avail_in -= len;
|
|
utils.arraySet(buf, strm.input, strm.next_in, len, start);
|
|
if (strm.state.wrap === 1) {
|
|
strm.adler = adler32(strm.adler, buf, len, start);
|
|
} else if (strm.state.wrap === 2) {
|
|
strm.adler = crc322(strm.adler, buf, len, start);
|
|
}
|
|
strm.next_in += len;
|
|
strm.total_in += len;
|
|
return len;
|
|
}
|
|
function longest_match(s, cur_match) {
|
|
var chain_length = s.max_chain_length;
|
|
var scan = s.strstart;
|
|
var match;
|
|
var len;
|
|
var best_len = s.prev_length;
|
|
var nice_match = s.nice_match;
|
|
var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;
|
|
var _win = s.window;
|
|
var wmask = s.w_mask;
|
|
var prev = s.prev;
|
|
var strend = s.strstart + MAX_MATCH;
|
|
var scan_end1 = _win[scan + best_len - 1];
|
|
var scan_end = _win[scan + best_len];
|
|
if (s.prev_length >= s.good_match) {
|
|
chain_length >>= 2;
|
|
}
|
|
if (nice_match > s.lookahead) {
|
|
nice_match = s.lookahead;
|
|
}
|
|
do {
|
|
match = cur_match;
|
|
if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) {
|
|
continue;
|
|
}
|
|
scan += 2;
|
|
match++;
|
|
do {
|
|
} while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend);
|
|
len = MAX_MATCH - (strend - scan);
|
|
scan = strend - MAX_MATCH;
|
|
if (len > best_len) {
|
|
s.match_start = cur_match;
|
|
best_len = len;
|
|
if (len >= nice_match) {
|
|
break;
|
|
}
|
|
scan_end1 = _win[scan + best_len - 1];
|
|
scan_end = _win[scan + best_len];
|
|
}
|
|
} while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);
|
|
if (best_len <= s.lookahead) {
|
|
return best_len;
|
|
}
|
|
return s.lookahead;
|
|
}
|
|
function fill_window(s) {
|
|
var _w_size = s.w_size;
|
|
var p, n, m, more, str;
|
|
do {
|
|
more = s.window_size - s.lookahead - s.strstart;
|
|
if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
|
|
utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
|
|
s.match_start -= _w_size;
|
|
s.strstart -= _w_size;
|
|
s.block_start -= _w_size;
|
|
n = s.hash_size;
|
|
p = n;
|
|
do {
|
|
m = s.head[--p];
|
|
s.head[p] = m >= _w_size ? m - _w_size : 0;
|
|
} while (--n);
|
|
n = _w_size;
|
|
p = n;
|
|
do {
|
|
m = s.prev[--p];
|
|
s.prev[p] = m >= _w_size ? m - _w_size : 0;
|
|
} while (--n);
|
|
more += _w_size;
|
|
}
|
|
if (s.strm.avail_in === 0) {
|
|
break;
|
|
}
|
|
n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
|
|
s.lookahead += n;
|
|
if (s.lookahead + s.insert >= MIN_MATCH) {
|
|
str = s.strstart - s.insert;
|
|
s.ins_h = s.window[str];
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask;
|
|
while (s.insert) {
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
|
|
s.prev[str & s.w_mask] = s.head[s.ins_h];
|
|
s.head[s.ins_h] = str;
|
|
str++;
|
|
s.insert--;
|
|
if (s.lookahead + s.insert < MIN_MATCH) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
|
|
}
|
|
function deflate_stored(s, flush2) {
|
|
var max_block_size = 65535;
|
|
if (max_block_size > s.pending_buf_size - 5) {
|
|
max_block_size = s.pending_buf_size - 5;
|
|
}
|
|
for (; ; ) {
|
|
if (s.lookahead <= 1) {
|
|
fill_window(s);
|
|
if (s.lookahead === 0 && flush2 === Z_NO_FLUSH) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
if (s.lookahead === 0) {
|
|
break;
|
|
}
|
|
}
|
|
s.strstart += s.lookahead;
|
|
s.lookahead = 0;
|
|
var max_start = s.block_start + max_block_size;
|
|
if (s.strstart === 0 || s.strstart >= max_start) {
|
|
s.lookahead = s.strstart - max_start;
|
|
s.strstart = max_start;
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
}
|
|
s.insert = 0;
|
|
if (flush2 === Z_FINISH) {
|
|
flush_block_only(s, true);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_FINISH_STARTED;
|
|
}
|
|
return BS_FINISH_DONE;
|
|
}
|
|
if (s.strstart > s.block_start) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
return BS_NEED_MORE;
|
|
}
|
|
function deflate_fast(s, flush2) {
|
|
var hash_head;
|
|
var bflush;
|
|
for (; ; ) {
|
|
if (s.lookahead < MIN_LOOKAHEAD) {
|
|
fill_window(s);
|
|
if (s.lookahead < MIN_LOOKAHEAD && flush2 === Z_NO_FLUSH) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
if (s.lookahead === 0) {
|
|
break;
|
|
}
|
|
}
|
|
hash_head = 0;
|
|
if (s.lookahead >= MIN_MATCH) {
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
|
|
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
|
|
s.head[s.ins_h] = s.strstart;
|
|
}
|
|
if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
|
|
s.match_length = longest_match(s, hash_head);
|
|
}
|
|
if (s.match_length >= MIN_MATCH) {
|
|
bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
|
|
s.lookahead -= s.match_length;
|
|
if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) {
|
|
s.match_length--;
|
|
do {
|
|
s.strstart++;
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
|
|
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
|
|
s.head[s.ins_h] = s.strstart;
|
|
} while (--s.match_length !== 0);
|
|
s.strstart++;
|
|
} else {
|
|
s.strstart += s.match_length;
|
|
s.match_length = 0;
|
|
s.ins_h = s.window[s.strstart];
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask;
|
|
}
|
|
} else {
|
|
bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
|
|
s.lookahead--;
|
|
s.strstart++;
|
|
}
|
|
if (bflush) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
}
|
|
s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
|
|
if (flush2 === Z_FINISH) {
|
|
flush_block_only(s, true);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_FINISH_STARTED;
|
|
}
|
|
return BS_FINISH_DONE;
|
|
}
|
|
if (s.last_lit) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
return BS_BLOCK_DONE;
|
|
}
|
|
function deflate_slow(s, flush2) {
|
|
var hash_head;
|
|
var bflush;
|
|
var max_insert;
|
|
for (; ; ) {
|
|
if (s.lookahead < MIN_LOOKAHEAD) {
|
|
fill_window(s);
|
|
if (s.lookahead < MIN_LOOKAHEAD && flush2 === Z_NO_FLUSH) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
if (s.lookahead === 0) {
|
|
break;
|
|
}
|
|
}
|
|
hash_head = 0;
|
|
if (s.lookahead >= MIN_MATCH) {
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
|
|
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
|
|
s.head[s.ins_h] = s.strstart;
|
|
}
|
|
s.prev_length = s.match_length;
|
|
s.prev_match = s.match_start;
|
|
s.match_length = MIN_MATCH - 1;
|
|
if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
|
|
s.match_length = longest_match(s, hash_head);
|
|
if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) {
|
|
s.match_length = MIN_MATCH - 1;
|
|
}
|
|
}
|
|
if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
|
|
max_insert = s.strstart + s.lookahead - MIN_MATCH;
|
|
bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
|
|
s.lookahead -= s.prev_length - 1;
|
|
s.prev_length -= 2;
|
|
do {
|
|
if (++s.strstart <= max_insert) {
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
|
|
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
|
|
s.head[s.ins_h] = s.strstart;
|
|
}
|
|
} while (--s.prev_length !== 0);
|
|
s.match_available = 0;
|
|
s.match_length = MIN_MATCH - 1;
|
|
s.strstart++;
|
|
if (bflush) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
} else if (s.match_available) {
|
|
bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
|
|
if (bflush) {
|
|
flush_block_only(s, false);
|
|
}
|
|
s.strstart++;
|
|
s.lookahead--;
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
} else {
|
|
s.match_available = 1;
|
|
s.strstart++;
|
|
s.lookahead--;
|
|
}
|
|
}
|
|
if (s.match_available) {
|
|
bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
|
|
s.match_available = 0;
|
|
}
|
|
s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
|
|
if (flush2 === Z_FINISH) {
|
|
flush_block_only(s, true);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_FINISH_STARTED;
|
|
}
|
|
return BS_FINISH_DONE;
|
|
}
|
|
if (s.last_lit) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
return BS_BLOCK_DONE;
|
|
}
|
|
function deflate_rle(s, flush2) {
|
|
var bflush;
|
|
var prev;
|
|
var scan, strend;
|
|
var _win = s.window;
|
|
for (; ; ) {
|
|
if (s.lookahead <= MAX_MATCH) {
|
|
fill_window(s);
|
|
if (s.lookahead <= MAX_MATCH && flush2 === Z_NO_FLUSH) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
if (s.lookahead === 0) {
|
|
break;
|
|
}
|
|
}
|
|
s.match_length = 0;
|
|
if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
|
|
scan = s.strstart - 1;
|
|
prev = _win[scan];
|
|
if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
|
|
strend = s.strstart + MAX_MATCH;
|
|
do {
|
|
} while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend);
|
|
s.match_length = MAX_MATCH - (strend - scan);
|
|
if (s.match_length > s.lookahead) {
|
|
s.match_length = s.lookahead;
|
|
}
|
|
}
|
|
}
|
|
if (s.match_length >= MIN_MATCH) {
|
|
bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
|
|
s.lookahead -= s.match_length;
|
|
s.strstart += s.match_length;
|
|
s.match_length = 0;
|
|
} else {
|
|
bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
|
|
s.lookahead--;
|
|
s.strstart++;
|
|
}
|
|
if (bflush) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
}
|
|
s.insert = 0;
|
|
if (flush2 === Z_FINISH) {
|
|
flush_block_only(s, true);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_FINISH_STARTED;
|
|
}
|
|
return BS_FINISH_DONE;
|
|
}
|
|
if (s.last_lit) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
return BS_BLOCK_DONE;
|
|
}
|
|
function deflate_huff(s, flush2) {
|
|
var bflush;
|
|
for (; ; ) {
|
|
if (s.lookahead === 0) {
|
|
fill_window(s);
|
|
if (s.lookahead === 0) {
|
|
if (flush2 === Z_NO_FLUSH) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
s.match_length = 0;
|
|
bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
|
|
s.lookahead--;
|
|
s.strstart++;
|
|
if (bflush) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
}
|
|
s.insert = 0;
|
|
if (flush2 === Z_FINISH) {
|
|
flush_block_only(s, true);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_FINISH_STARTED;
|
|
}
|
|
return BS_FINISH_DONE;
|
|
}
|
|
if (s.last_lit) {
|
|
flush_block_only(s, false);
|
|
if (s.strm.avail_out === 0) {
|
|
return BS_NEED_MORE;
|
|
}
|
|
}
|
|
return BS_BLOCK_DONE;
|
|
}
|
|
function Config(good_length, max_lazy, nice_length, max_chain, func) {
|
|
this.good_length = good_length;
|
|
this.max_lazy = max_lazy;
|
|
this.nice_length = nice_length;
|
|
this.max_chain = max_chain;
|
|
this.func = func;
|
|
}
|
|
var configuration_table;
|
|
configuration_table = [
|
|
new Config(0, 0, 0, 0, deflate_stored),
|
|
new Config(4, 4, 8, 4, deflate_fast),
|
|
new Config(4, 5, 16, 8, deflate_fast),
|
|
new Config(4, 6, 32, 32, deflate_fast),
|
|
new Config(4, 4, 16, 16, deflate_slow),
|
|
new Config(8, 16, 32, 32, deflate_slow),
|
|
new Config(8, 16, 128, 128, deflate_slow),
|
|
new Config(8, 32, 128, 256, deflate_slow),
|
|
new Config(32, 128, 258, 1024, deflate_slow),
|
|
new Config(32, 258, 258, 4096, deflate_slow)
|
|
];
|
|
function lm_init(s) {
|
|
s.window_size = 2 * s.w_size;
|
|
zero(s.head);
|
|
s.max_lazy_match = configuration_table[s.level].max_lazy;
|
|
s.good_match = configuration_table[s.level].good_length;
|
|
s.nice_match = configuration_table[s.level].nice_length;
|
|
s.max_chain_length = configuration_table[s.level].max_chain;
|
|
s.strstart = 0;
|
|
s.block_start = 0;
|
|
s.lookahead = 0;
|
|
s.insert = 0;
|
|
s.match_length = s.prev_length = MIN_MATCH - 1;
|
|
s.match_available = 0;
|
|
s.ins_h = 0;
|
|
}
|
|
function DeflateState() {
|
|
this.strm = null;
|
|
this.status = 0;
|
|
this.pending_buf = null;
|
|
this.pending_buf_size = 0;
|
|
this.pending_out = 0;
|
|
this.pending = 0;
|
|
this.wrap = 0;
|
|
this.gzhead = null;
|
|
this.gzindex = 0;
|
|
this.method = Z_DEFLATED;
|
|
this.last_flush = -1;
|
|
this.w_size = 0;
|
|
this.w_bits = 0;
|
|
this.w_mask = 0;
|
|
this.window = null;
|
|
this.window_size = 0;
|
|
this.prev = null;
|
|
this.head = null;
|
|
this.ins_h = 0;
|
|
this.hash_size = 0;
|
|
this.hash_bits = 0;
|
|
this.hash_mask = 0;
|
|
this.hash_shift = 0;
|
|
this.block_start = 0;
|
|
this.match_length = 0;
|
|
this.prev_match = 0;
|
|
this.match_available = 0;
|
|
this.strstart = 0;
|
|
this.match_start = 0;
|
|
this.lookahead = 0;
|
|
this.prev_length = 0;
|
|
this.max_chain_length = 0;
|
|
this.max_lazy_match = 0;
|
|
this.level = 0;
|
|
this.strategy = 0;
|
|
this.good_match = 0;
|
|
this.nice_match = 0;
|
|
this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2);
|
|
this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2);
|
|
this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2);
|
|
zero(this.dyn_ltree);
|
|
zero(this.dyn_dtree);
|
|
zero(this.bl_tree);
|
|
this.l_desc = null;
|
|
this.d_desc = null;
|
|
this.bl_desc = null;
|
|
this.bl_count = new utils.Buf16(MAX_BITS + 1);
|
|
this.heap = new utils.Buf16(2 * L_CODES + 1);
|
|
zero(this.heap);
|
|
this.heap_len = 0;
|
|
this.heap_max = 0;
|
|
this.depth = new utils.Buf16(2 * L_CODES + 1);
|
|
zero(this.depth);
|
|
this.l_buf = 0;
|
|
this.lit_bufsize = 0;
|
|
this.last_lit = 0;
|
|
this.d_buf = 0;
|
|
this.opt_len = 0;
|
|
this.static_len = 0;
|
|
this.matches = 0;
|
|
this.insert = 0;
|
|
this.bi_buf = 0;
|
|
this.bi_valid = 0;
|
|
}
|
|
function deflateResetKeep(strm) {
|
|
var s;
|
|
if (!strm || !strm.state) {
|
|
return err(strm, Z_STREAM_ERROR);
|
|
}
|
|
strm.total_in = strm.total_out = 0;
|
|
strm.data_type = Z_UNKNOWN;
|
|
s = strm.state;
|
|
s.pending = 0;
|
|
s.pending_out = 0;
|
|
if (s.wrap < 0) {
|
|
s.wrap = -s.wrap;
|
|
}
|
|
s.status = s.wrap ? INIT_STATE : BUSY_STATE;
|
|
strm.adler = s.wrap === 2 ? 0 : 1;
|
|
s.last_flush = Z_NO_FLUSH;
|
|
trees._tr_init(s);
|
|
return Z_OK;
|
|
}
|
|
function deflateReset(strm) {
|
|
var ret = deflateResetKeep(strm);
|
|
if (ret === Z_OK) {
|
|
lm_init(strm.state);
|
|
}
|
|
return ret;
|
|
}
|
|
function deflateSetHeader(strm, head) {
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (strm.state.wrap !== 2) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
strm.state.gzhead = head;
|
|
return Z_OK;
|
|
}
|
|
function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
|
|
if (!strm) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
var wrap = 1;
|
|
if (level === Z_DEFAULT_COMPRESSION) {
|
|
level = 6;
|
|
}
|
|
if (windowBits < 0) {
|
|
wrap = 0;
|
|
windowBits = -windowBits;
|
|
} else if (windowBits > 15) {
|
|
wrap = 2;
|
|
windowBits -= 16;
|
|
}
|
|
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
|
|
return err(strm, Z_STREAM_ERROR);
|
|
}
|
|
if (windowBits === 8) {
|
|
windowBits = 9;
|
|
}
|
|
var s = new DeflateState();
|
|
strm.state = s;
|
|
s.strm = strm;
|
|
s.wrap = wrap;
|
|
s.gzhead = null;
|
|
s.w_bits = windowBits;
|
|
s.w_size = 1 << s.w_bits;
|
|
s.w_mask = s.w_size - 1;
|
|
s.hash_bits = memLevel + 7;
|
|
s.hash_size = 1 << s.hash_bits;
|
|
s.hash_mask = s.hash_size - 1;
|
|
s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
|
|
s.window = new utils.Buf8(s.w_size * 2);
|
|
s.head = new utils.Buf16(s.hash_size);
|
|
s.prev = new utils.Buf16(s.w_size);
|
|
s.lit_bufsize = 1 << memLevel + 6;
|
|
s.pending_buf_size = s.lit_bufsize * 4;
|
|
s.pending_buf = new utils.Buf8(s.pending_buf_size);
|
|
s.d_buf = 1 * s.lit_bufsize;
|
|
s.l_buf = (1 + 2) * s.lit_bufsize;
|
|
s.level = level;
|
|
s.strategy = strategy;
|
|
s.method = method;
|
|
return deflateReset(strm);
|
|
}
|
|
function deflateInit(strm, level) {
|
|
return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
|
|
}
|
|
function deflate2(strm, flush2) {
|
|
var old_flush, s;
|
|
var beg, val;
|
|
if (!strm || !strm.state || flush2 > Z_BLOCK || flush2 < 0) {
|
|
return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
|
|
}
|
|
s = strm.state;
|
|
if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush2 !== Z_FINISH) {
|
|
return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR);
|
|
}
|
|
s.strm = strm;
|
|
old_flush = s.last_flush;
|
|
s.last_flush = flush2;
|
|
if (s.status === INIT_STATE) {
|
|
if (s.wrap === 2) {
|
|
strm.adler = 0;
|
|
put_byte(s, 31);
|
|
put_byte(s, 139);
|
|
put_byte(s, 8);
|
|
if (!s.gzhead) {
|
|
put_byte(s, 0);
|
|
put_byte(s, 0);
|
|
put_byte(s, 0);
|
|
put_byte(s, 0);
|
|
put_byte(s, 0);
|
|
put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
|
|
put_byte(s, OS_CODE);
|
|
s.status = BUSY_STATE;
|
|
} else {
|
|
put_byte(s, (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16));
|
|
put_byte(s, s.gzhead.time & 255);
|
|
put_byte(s, s.gzhead.time >> 8 & 255);
|
|
put_byte(s, s.gzhead.time >> 16 & 255);
|
|
put_byte(s, s.gzhead.time >> 24 & 255);
|
|
put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
|
|
put_byte(s, s.gzhead.os & 255);
|
|
if (s.gzhead.extra && s.gzhead.extra.length) {
|
|
put_byte(s, s.gzhead.extra.length & 255);
|
|
put_byte(s, s.gzhead.extra.length >> 8 & 255);
|
|
}
|
|
if (s.gzhead.hcrc) {
|
|
strm.adler = crc322(strm.adler, s.pending_buf, s.pending, 0);
|
|
}
|
|
s.gzindex = 0;
|
|
s.status = EXTRA_STATE;
|
|
}
|
|
} else {
|
|
var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8;
|
|
var level_flags = -1;
|
|
if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
|
|
level_flags = 0;
|
|
} else if (s.level < 6) {
|
|
level_flags = 1;
|
|
} else if (s.level === 6) {
|
|
level_flags = 2;
|
|
} else {
|
|
level_flags = 3;
|
|
}
|
|
header |= level_flags << 6;
|
|
if (s.strstart !== 0) {
|
|
header |= PRESET_DICT;
|
|
}
|
|
header += 31 - header % 31;
|
|
s.status = BUSY_STATE;
|
|
putShortMSB(s, header);
|
|
if (s.strstart !== 0) {
|
|
putShortMSB(s, strm.adler >>> 16);
|
|
putShortMSB(s, strm.adler & 65535);
|
|
}
|
|
strm.adler = 1;
|
|
}
|
|
}
|
|
if (s.status === EXTRA_STATE) {
|
|
if (s.gzhead.extra) {
|
|
beg = s.pending;
|
|
while (s.gzindex < (s.gzhead.extra.length & 65535)) {
|
|
if (s.pending === s.pending_buf_size) {
|
|
if (s.gzhead.hcrc && s.pending > beg) {
|
|
strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg);
|
|
}
|
|
flush_pending(strm);
|
|
beg = s.pending;
|
|
if (s.pending === s.pending_buf_size) {
|
|
break;
|
|
}
|
|
}
|
|
put_byte(s, s.gzhead.extra[s.gzindex] & 255);
|
|
s.gzindex++;
|
|
}
|
|
if (s.gzhead.hcrc && s.pending > beg) {
|
|
strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg);
|
|
}
|
|
if (s.gzindex === s.gzhead.extra.length) {
|
|
s.gzindex = 0;
|
|
s.status = NAME_STATE;
|
|
}
|
|
} else {
|
|
s.status = NAME_STATE;
|
|
}
|
|
}
|
|
if (s.status === NAME_STATE) {
|
|
if (s.gzhead.name) {
|
|
beg = s.pending;
|
|
do {
|
|
if (s.pending === s.pending_buf_size) {
|
|
if (s.gzhead.hcrc && s.pending > beg) {
|
|
strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg);
|
|
}
|
|
flush_pending(strm);
|
|
beg = s.pending;
|
|
if (s.pending === s.pending_buf_size) {
|
|
val = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (s.gzindex < s.gzhead.name.length) {
|
|
val = s.gzhead.name.charCodeAt(s.gzindex++) & 255;
|
|
} else {
|
|
val = 0;
|
|
}
|
|
put_byte(s, val);
|
|
} while (val !== 0);
|
|
if (s.gzhead.hcrc && s.pending > beg) {
|
|
strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg);
|
|
}
|
|
if (val === 0) {
|
|
s.gzindex = 0;
|
|
s.status = COMMENT_STATE;
|
|
}
|
|
} else {
|
|
s.status = COMMENT_STATE;
|
|
}
|
|
}
|
|
if (s.status === COMMENT_STATE) {
|
|
if (s.gzhead.comment) {
|
|
beg = s.pending;
|
|
do {
|
|
if (s.pending === s.pending_buf_size) {
|
|
if (s.gzhead.hcrc && s.pending > beg) {
|
|
strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg);
|
|
}
|
|
flush_pending(strm);
|
|
beg = s.pending;
|
|
if (s.pending === s.pending_buf_size) {
|
|
val = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (s.gzindex < s.gzhead.comment.length) {
|
|
val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255;
|
|
} else {
|
|
val = 0;
|
|
}
|
|
put_byte(s, val);
|
|
} while (val !== 0);
|
|
if (s.gzhead.hcrc && s.pending > beg) {
|
|
strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg);
|
|
}
|
|
if (val === 0) {
|
|
s.status = HCRC_STATE;
|
|
}
|
|
} else {
|
|
s.status = HCRC_STATE;
|
|
}
|
|
}
|
|
if (s.status === HCRC_STATE) {
|
|
if (s.gzhead.hcrc) {
|
|
if (s.pending + 2 > s.pending_buf_size) {
|
|
flush_pending(strm);
|
|
}
|
|
if (s.pending + 2 <= s.pending_buf_size) {
|
|
put_byte(s, strm.adler & 255);
|
|
put_byte(s, strm.adler >> 8 & 255);
|
|
strm.adler = 0;
|
|
s.status = BUSY_STATE;
|
|
}
|
|
} else {
|
|
s.status = BUSY_STATE;
|
|
}
|
|
}
|
|
if (s.pending !== 0) {
|
|
flush_pending(strm);
|
|
if (strm.avail_out === 0) {
|
|
s.last_flush = -1;
|
|
return Z_OK;
|
|
}
|
|
} else if (strm.avail_in === 0 && rank(flush2) <= rank(old_flush) && flush2 !== Z_FINISH) {
|
|
return err(strm, Z_BUF_ERROR);
|
|
}
|
|
if (s.status === FINISH_STATE && strm.avail_in !== 0) {
|
|
return err(strm, Z_BUF_ERROR);
|
|
}
|
|
if (strm.avail_in !== 0 || s.lookahead !== 0 || flush2 !== Z_NO_FLUSH && s.status !== FINISH_STATE) {
|
|
var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush2) : s.strategy === Z_RLE ? deflate_rle(s, flush2) : configuration_table[s.level].func(s, flush2);
|
|
if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
|
|
s.status = FINISH_STATE;
|
|
}
|
|
if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
|
|
if (strm.avail_out === 0) {
|
|
s.last_flush = -1;
|
|
}
|
|
return Z_OK;
|
|
}
|
|
if (bstate === BS_BLOCK_DONE) {
|
|
if (flush2 === Z_PARTIAL_FLUSH) {
|
|
trees._tr_align(s);
|
|
} else if (flush2 !== Z_BLOCK) {
|
|
trees._tr_stored_block(s, 0, 0, false);
|
|
if (flush2 === Z_FULL_FLUSH) {
|
|
zero(s.head);
|
|
if (s.lookahead === 0) {
|
|
s.strstart = 0;
|
|
s.block_start = 0;
|
|
s.insert = 0;
|
|
}
|
|
}
|
|
}
|
|
flush_pending(strm);
|
|
if (strm.avail_out === 0) {
|
|
s.last_flush = -1;
|
|
return Z_OK;
|
|
}
|
|
}
|
|
}
|
|
if (flush2 !== Z_FINISH) {
|
|
return Z_OK;
|
|
}
|
|
if (s.wrap <= 0) {
|
|
return Z_STREAM_END;
|
|
}
|
|
if (s.wrap === 2) {
|
|
put_byte(s, strm.adler & 255);
|
|
put_byte(s, strm.adler >> 8 & 255);
|
|
put_byte(s, strm.adler >> 16 & 255);
|
|
put_byte(s, strm.adler >> 24 & 255);
|
|
put_byte(s, strm.total_in & 255);
|
|
put_byte(s, strm.total_in >> 8 & 255);
|
|
put_byte(s, strm.total_in >> 16 & 255);
|
|
put_byte(s, strm.total_in >> 24 & 255);
|
|
} else {
|
|
putShortMSB(s, strm.adler >>> 16);
|
|
putShortMSB(s, strm.adler & 65535);
|
|
}
|
|
flush_pending(strm);
|
|
if (s.wrap > 0) {
|
|
s.wrap = -s.wrap;
|
|
}
|
|
return s.pending !== 0 ? Z_OK : Z_STREAM_END;
|
|
}
|
|
function deflateEnd(strm) {
|
|
var status2;
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
status2 = strm.state.status;
|
|
if (status2 !== INIT_STATE && status2 !== EXTRA_STATE && status2 !== NAME_STATE && status2 !== COMMENT_STATE && status2 !== HCRC_STATE && status2 !== BUSY_STATE && status2 !== FINISH_STATE) {
|
|
return err(strm, Z_STREAM_ERROR);
|
|
}
|
|
strm.state = null;
|
|
return status2 === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
|
|
}
|
|
function deflateSetDictionary(strm, dictionary) {
|
|
var dictLength = dictionary.length;
|
|
var s;
|
|
var str, n;
|
|
var wrap;
|
|
var avail;
|
|
var next;
|
|
var input;
|
|
var tmpDict;
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
s = strm.state;
|
|
wrap = s.wrap;
|
|
if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (wrap === 1) {
|
|
strm.adler = adler32(strm.adler, dictionary, dictLength, 0);
|
|
}
|
|
s.wrap = 0;
|
|
if (dictLength >= s.w_size) {
|
|
if (wrap === 0) {
|
|
zero(s.head);
|
|
s.strstart = 0;
|
|
s.block_start = 0;
|
|
s.insert = 0;
|
|
}
|
|
tmpDict = new utils.Buf8(s.w_size);
|
|
utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);
|
|
dictionary = tmpDict;
|
|
dictLength = s.w_size;
|
|
}
|
|
avail = strm.avail_in;
|
|
next = strm.next_in;
|
|
input = strm.input;
|
|
strm.avail_in = dictLength;
|
|
strm.next_in = 0;
|
|
strm.input = dictionary;
|
|
fill_window(s);
|
|
while (s.lookahead >= MIN_MATCH) {
|
|
str = s.strstart;
|
|
n = s.lookahead - (MIN_MATCH - 1);
|
|
do {
|
|
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
|
|
s.prev[str & s.w_mask] = s.head[s.ins_h];
|
|
s.head[s.ins_h] = str;
|
|
str++;
|
|
} while (--n);
|
|
s.strstart = str;
|
|
s.lookahead = MIN_MATCH - 1;
|
|
fill_window(s);
|
|
}
|
|
s.strstart += s.lookahead;
|
|
s.block_start = s.strstart;
|
|
s.insert = s.lookahead;
|
|
s.lookahead = 0;
|
|
s.match_length = s.prev_length = MIN_MATCH - 1;
|
|
s.match_available = 0;
|
|
strm.next_in = next;
|
|
strm.input = input;
|
|
strm.avail_in = avail;
|
|
s.wrap = wrap;
|
|
return Z_OK;
|
|
}
|
|
exports.deflateInit = deflateInit;
|
|
exports.deflateInit2 = deflateInit2;
|
|
exports.deflateReset = deflateReset;
|
|
exports.deflateResetKeep = deflateResetKeep;
|
|
exports.deflateSetHeader = deflateSetHeader;
|
|
exports.deflate = deflate2;
|
|
exports.deflateEnd = deflateEnd;
|
|
exports.deflateSetDictionary = deflateSetDictionary;
|
|
exports.deflateInfo = "pako deflate (from Nodeca project)";
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/utils/strings.js
|
|
var require_strings = __commonJS({
|
|
"node_modules/pako/lib/utils/strings.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var utils = require_common();
|
|
var STR_APPLY_OK = true;
|
|
var STR_APPLY_UIA_OK = true;
|
|
try {
|
|
String.fromCharCode.apply(null, [0]);
|
|
} catch (__) {
|
|
STR_APPLY_OK = false;
|
|
}
|
|
try {
|
|
String.fromCharCode.apply(null, new Uint8Array(1));
|
|
} catch (__) {
|
|
STR_APPLY_UIA_OK = false;
|
|
}
|
|
var _utf8len = new utils.Buf8(256);
|
|
for (q = 0; q < 256; q++) {
|
|
_utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;
|
|
}
|
|
var q;
|
|
_utf8len[254] = _utf8len[254] = 1;
|
|
exports.string2buf = function(str) {
|
|
var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
|
|
for (m_pos = 0; m_pos < str_len; m_pos++) {
|
|
c = str.charCodeAt(m_pos);
|
|
if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
|
|
c2 = str.charCodeAt(m_pos + 1);
|
|
if ((c2 & 64512) === 56320) {
|
|
c = 65536 + (c - 55296 << 10) + (c2 - 56320);
|
|
m_pos++;
|
|
}
|
|
}
|
|
buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
|
|
}
|
|
buf = new utils.Buf8(buf_len);
|
|
for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
|
|
c = str.charCodeAt(m_pos);
|
|
if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
|
|
c2 = str.charCodeAt(m_pos + 1);
|
|
if ((c2 & 64512) === 56320) {
|
|
c = 65536 + (c - 55296 << 10) + (c2 - 56320);
|
|
m_pos++;
|
|
}
|
|
}
|
|
if (c < 128) {
|
|
buf[i++] = c;
|
|
} else if (c < 2048) {
|
|
buf[i++] = 192 | c >>> 6;
|
|
buf[i++] = 128 | c & 63;
|
|
} else if (c < 65536) {
|
|
buf[i++] = 224 | c >>> 12;
|
|
buf[i++] = 128 | c >>> 6 & 63;
|
|
buf[i++] = 128 | c & 63;
|
|
} else {
|
|
buf[i++] = 240 | c >>> 18;
|
|
buf[i++] = 128 | c >>> 12 & 63;
|
|
buf[i++] = 128 | c >>> 6 & 63;
|
|
buf[i++] = 128 | c & 63;
|
|
}
|
|
}
|
|
return buf;
|
|
};
|
|
function buf2binstring(buf, len) {
|
|
if (len < 65534) {
|
|
if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) {
|
|
return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
|
|
}
|
|
}
|
|
var result = "";
|
|
for (var i = 0; i < len; i++) {
|
|
result += String.fromCharCode(buf[i]);
|
|
}
|
|
return result;
|
|
}
|
|
exports.buf2binstring = function(buf) {
|
|
return buf2binstring(buf, buf.length);
|
|
};
|
|
exports.binstring2buf = function(str) {
|
|
var buf = new utils.Buf8(str.length);
|
|
for (var i = 0, len = buf.length; i < len; i++) {
|
|
buf[i] = str.charCodeAt(i);
|
|
}
|
|
return buf;
|
|
};
|
|
exports.buf2string = function(buf, max) {
|
|
var i, out, c, c_len;
|
|
var len = max || buf.length;
|
|
var utf16buf = new Array(len * 2);
|
|
for (out = 0, i = 0; i < len; ) {
|
|
c = buf[i++];
|
|
if (c < 128) {
|
|
utf16buf[out++] = c;
|
|
continue;
|
|
}
|
|
c_len = _utf8len[c];
|
|
if (c_len > 4) {
|
|
utf16buf[out++] = 65533;
|
|
i += c_len - 1;
|
|
continue;
|
|
}
|
|
c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
|
|
while (c_len > 1 && i < len) {
|
|
c = c << 6 | buf[i++] & 63;
|
|
c_len--;
|
|
}
|
|
if (c_len > 1) {
|
|
utf16buf[out++] = 65533;
|
|
continue;
|
|
}
|
|
if (c < 65536) {
|
|
utf16buf[out++] = c;
|
|
} else {
|
|
c -= 65536;
|
|
utf16buf[out++] = 55296 | c >> 10 & 1023;
|
|
utf16buf[out++] = 56320 | c & 1023;
|
|
}
|
|
}
|
|
return buf2binstring(utf16buf, out);
|
|
};
|
|
exports.utf8border = function(buf, max) {
|
|
var pos;
|
|
max = max || buf.length;
|
|
if (max > buf.length) {
|
|
max = buf.length;
|
|
}
|
|
pos = max - 1;
|
|
while (pos >= 0 && (buf[pos] & 192) === 128) {
|
|
pos--;
|
|
}
|
|
if (pos < 0) {
|
|
return max;
|
|
}
|
|
if (pos === 0) {
|
|
return max;
|
|
}
|
|
return pos + _utf8len[buf[pos]] > max ? pos : max;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/zstream.js
|
|
var require_zstream = __commonJS({
|
|
"node_modules/pako/lib/zlib/zstream.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
function ZStream() {
|
|
this.input = null;
|
|
this.next_in = 0;
|
|
this.avail_in = 0;
|
|
this.total_in = 0;
|
|
this.output = null;
|
|
this.next_out = 0;
|
|
this.avail_out = 0;
|
|
this.total_out = 0;
|
|
this.msg = "";
|
|
this.state = null;
|
|
this.data_type = 2;
|
|
this.adler = 0;
|
|
}
|
|
module2.exports = ZStream;
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/deflate.js
|
|
var require_deflate2 = __commonJS({
|
|
"node_modules/pako/lib/deflate.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var zlib_deflate = require_deflate();
|
|
var utils = require_common();
|
|
var strings = require_strings();
|
|
var msg = require_messages();
|
|
var ZStream = require_zstream();
|
|
var toString = Object.prototype.toString;
|
|
var Z_NO_FLUSH = 0;
|
|
var Z_FINISH = 4;
|
|
var Z_OK = 0;
|
|
var Z_STREAM_END = 1;
|
|
var Z_SYNC_FLUSH = 2;
|
|
var Z_DEFAULT_COMPRESSION = -1;
|
|
var Z_DEFAULT_STRATEGY = 0;
|
|
var Z_DEFLATED = 8;
|
|
function Deflate(options) {
|
|
if (!(this instanceof Deflate))
|
|
return new Deflate(options);
|
|
this.options = utils.assign({
|
|
level: Z_DEFAULT_COMPRESSION,
|
|
method: Z_DEFLATED,
|
|
chunkSize: 16384,
|
|
windowBits: 15,
|
|
memLevel: 8,
|
|
strategy: Z_DEFAULT_STRATEGY,
|
|
to: ""
|
|
}, options || {});
|
|
var opt = this.options;
|
|
if (opt.raw && opt.windowBits > 0) {
|
|
opt.windowBits = -opt.windowBits;
|
|
} else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) {
|
|
opt.windowBits += 16;
|
|
}
|
|
this.err = 0;
|
|
this.msg = "";
|
|
this.ended = false;
|
|
this.chunks = [];
|
|
this.strm = new ZStream();
|
|
this.strm.avail_out = 0;
|
|
var status2 = zlib_deflate.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);
|
|
if (status2 !== Z_OK) {
|
|
throw new Error(msg[status2]);
|
|
}
|
|
if (opt.header) {
|
|
zlib_deflate.deflateSetHeader(this.strm, opt.header);
|
|
}
|
|
if (opt.dictionary) {
|
|
var dict;
|
|
if (typeof opt.dictionary === "string") {
|
|
dict = strings.string2buf(opt.dictionary);
|
|
} else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") {
|
|
dict = new Uint8Array(opt.dictionary);
|
|
} else {
|
|
dict = opt.dictionary;
|
|
}
|
|
status2 = zlib_deflate.deflateSetDictionary(this.strm, dict);
|
|
if (status2 !== Z_OK) {
|
|
throw new Error(msg[status2]);
|
|
}
|
|
this._dict_set = true;
|
|
}
|
|
}
|
|
Deflate.prototype.push = function(data, mode) {
|
|
var strm = this.strm;
|
|
var chunkSize = this.options.chunkSize;
|
|
var status2, _mode;
|
|
if (this.ended) {
|
|
return false;
|
|
}
|
|
_mode = mode === ~~mode ? mode : mode === true ? Z_FINISH : Z_NO_FLUSH;
|
|
if (typeof data === "string") {
|
|
strm.input = strings.string2buf(data);
|
|
} else if (toString.call(data) === "[object ArrayBuffer]") {
|
|
strm.input = new Uint8Array(data);
|
|
} else {
|
|
strm.input = data;
|
|
}
|
|
strm.next_in = 0;
|
|
strm.avail_in = strm.input.length;
|
|
do {
|
|
if (strm.avail_out === 0) {
|
|
strm.output = new utils.Buf8(chunkSize);
|
|
strm.next_out = 0;
|
|
strm.avail_out = chunkSize;
|
|
}
|
|
status2 = zlib_deflate.deflate(strm, _mode);
|
|
if (status2 !== Z_STREAM_END && status2 !== Z_OK) {
|
|
this.onEnd(status2);
|
|
this.ended = true;
|
|
return false;
|
|
}
|
|
if (strm.avail_out === 0 || strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH)) {
|
|
if (this.options.to === "string") {
|
|
this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));
|
|
} else {
|
|
this.onData(utils.shrinkBuf(strm.output, strm.next_out));
|
|
}
|
|
}
|
|
} while ((strm.avail_in > 0 || strm.avail_out === 0) && status2 !== Z_STREAM_END);
|
|
if (_mode === Z_FINISH) {
|
|
status2 = zlib_deflate.deflateEnd(this.strm);
|
|
this.onEnd(status2);
|
|
this.ended = true;
|
|
return status2 === Z_OK;
|
|
}
|
|
if (_mode === Z_SYNC_FLUSH) {
|
|
this.onEnd(Z_OK);
|
|
strm.avail_out = 0;
|
|
return true;
|
|
}
|
|
return true;
|
|
};
|
|
Deflate.prototype.onData = function(chunk) {
|
|
this.chunks.push(chunk);
|
|
};
|
|
Deflate.prototype.onEnd = function(status2) {
|
|
if (status2 === Z_OK) {
|
|
if (this.options.to === "string") {
|
|
this.result = this.chunks.join("");
|
|
} else {
|
|
this.result = utils.flattenChunks(this.chunks);
|
|
}
|
|
}
|
|
this.chunks = [];
|
|
this.err = status2;
|
|
this.msg = this.strm.msg;
|
|
};
|
|
function deflate2(input, options) {
|
|
var deflator = new Deflate(options);
|
|
deflator.push(input, true);
|
|
if (deflator.err) {
|
|
throw deflator.msg || msg[deflator.err];
|
|
}
|
|
return deflator.result;
|
|
}
|
|
function deflateRaw(input, options) {
|
|
options = options || {};
|
|
options.raw = true;
|
|
return deflate2(input, options);
|
|
}
|
|
function gzip(input, options) {
|
|
options = options || {};
|
|
options.gzip = true;
|
|
return deflate2(input, options);
|
|
}
|
|
exports.Deflate = Deflate;
|
|
exports.deflate = deflate2;
|
|
exports.deflateRaw = deflateRaw;
|
|
exports.gzip = gzip;
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/inffast.js
|
|
var require_inffast = __commonJS({
|
|
"node_modules/pako/lib/zlib/inffast.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var BAD = 30;
|
|
var TYPE = 12;
|
|
module2.exports = function inflate_fast(strm, start) {
|
|
var state;
|
|
var _in;
|
|
var last2;
|
|
var _out;
|
|
var beg;
|
|
var end;
|
|
var dmax;
|
|
var wsize;
|
|
var whave;
|
|
var wnext;
|
|
var s_window;
|
|
var hold;
|
|
var bits;
|
|
var lcode;
|
|
var dcode;
|
|
var lmask;
|
|
var dmask;
|
|
var here;
|
|
var op;
|
|
var len;
|
|
var dist;
|
|
var from;
|
|
var from_source;
|
|
var input, output;
|
|
state = strm.state;
|
|
_in = strm.next_in;
|
|
input = strm.input;
|
|
last2 = _in + (strm.avail_in - 5);
|
|
_out = strm.next_out;
|
|
output = strm.output;
|
|
beg = _out - (start - strm.avail_out);
|
|
end = _out + (strm.avail_out - 257);
|
|
dmax = state.dmax;
|
|
wsize = state.wsize;
|
|
whave = state.whave;
|
|
wnext = state.wnext;
|
|
s_window = state.window;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
lcode = state.lencode;
|
|
dcode = state.distcode;
|
|
lmask = (1 << state.lenbits) - 1;
|
|
dmask = (1 << state.distbits) - 1;
|
|
top:
|
|
do {
|
|
if (bits < 15) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
here = lcode[hold & lmask];
|
|
dolen:
|
|
for (; ; ) {
|
|
op = here >>> 24;
|
|
hold >>>= op;
|
|
bits -= op;
|
|
op = here >>> 16 & 255;
|
|
if (op === 0) {
|
|
output[_out++] = here & 65535;
|
|
} else if (op & 16) {
|
|
len = here & 65535;
|
|
op &= 15;
|
|
if (op) {
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
len += hold & (1 << op) - 1;
|
|
hold >>>= op;
|
|
bits -= op;
|
|
}
|
|
if (bits < 15) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
here = dcode[hold & dmask];
|
|
dodist:
|
|
for (; ; ) {
|
|
op = here >>> 24;
|
|
hold >>>= op;
|
|
bits -= op;
|
|
op = here >>> 16 & 255;
|
|
if (op & 16) {
|
|
dist = here & 65535;
|
|
op &= 15;
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
}
|
|
dist += hold & (1 << op) - 1;
|
|
if (dist > dmax) {
|
|
strm.msg = "invalid distance too far back";
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
hold >>>= op;
|
|
bits -= op;
|
|
op = _out - beg;
|
|
if (dist > op) {
|
|
op = dist - op;
|
|
if (op > whave) {
|
|
if (state.sane) {
|
|
strm.msg = "invalid distance too far back";
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
}
|
|
from = 0;
|
|
from_source = s_window;
|
|
if (wnext === 0) {
|
|
from += wsize - op;
|
|
if (op < len) {
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist;
|
|
from_source = output;
|
|
}
|
|
} else if (wnext < op) {
|
|
from += wsize + wnext - op;
|
|
op -= wnext;
|
|
if (op < len) {
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = 0;
|
|
if (wnext < len) {
|
|
op = wnext;
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist;
|
|
from_source = output;
|
|
}
|
|
}
|
|
} else {
|
|
from += wnext - op;
|
|
if (op < len) {
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist;
|
|
from_source = output;
|
|
}
|
|
}
|
|
while (len > 2) {
|
|
output[_out++] = from_source[from++];
|
|
output[_out++] = from_source[from++];
|
|
output[_out++] = from_source[from++];
|
|
len -= 3;
|
|
}
|
|
if (len) {
|
|
output[_out++] = from_source[from++];
|
|
if (len > 1) {
|
|
output[_out++] = from_source[from++];
|
|
}
|
|
}
|
|
} else {
|
|
from = _out - dist;
|
|
do {
|
|
output[_out++] = output[from++];
|
|
output[_out++] = output[from++];
|
|
output[_out++] = output[from++];
|
|
len -= 3;
|
|
} while (len > 2);
|
|
if (len) {
|
|
output[_out++] = output[from++];
|
|
if (len > 1) {
|
|
output[_out++] = output[from++];
|
|
}
|
|
}
|
|
}
|
|
} else if ((op & 64) === 0) {
|
|
here = dcode[(here & 65535) + (hold & (1 << op) - 1)];
|
|
continue dodist;
|
|
} else {
|
|
strm.msg = "invalid distance code";
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
break;
|
|
}
|
|
} else if ((op & 64) === 0) {
|
|
here = lcode[(here & 65535) + (hold & (1 << op) - 1)];
|
|
continue dolen;
|
|
} else if (op & 32) {
|
|
state.mode = TYPE;
|
|
break top;
|
|
} else {
|
|
strm.msg = "invalid literal/length code";
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
break;
|
|
}
|
|
} while (_in < last2 && _out < end);
|
|
len = bits >> 3;
|
|
_in -= len;
|
|
bits -= len << 3;
|
|
hold &= (1 << bits) - 1;
|
|
strm.next_in = _in;
|
|
strm.next_out = _out;
|
|
strm.avail_in = _in < last2 ? 5 + (last2 - _in) : 5 - (_in - last2);
|
|
strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
return;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/inftrees.js
|
|
var require_inftrees = __commonJS({
|
|
"node_modules/pako/lib/zlib/inftrees.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var utils = require_common();
|
|
var MAXBITS = 15;
|
|
var ENOUGH_LENS = 852;
|
|
var ENOUGH_DISTS = 592;
|
|
var CODES = 0;
|
|
var LENS = 1;
|
|
var DISTS = 2;
|
|
var lbase = [
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
8,
|
|
9,
|
|
10,
|
|
11,
|
|
13,
|
|
15,
|
|
17,
|
|
19,
|
|
23,
|
|
27,
|
|
31,
|
|
35,
|
|
43,
|
|
51,
|
|
59,
|
|
67,
|
|
83,
|
|
99,
|
|
115,
|
|
131,
|
|
163,
|
|
195,
|
|
227,
|
|
258,
|
|
0,
|
|
0
|
|
];
|
|
var lext = [
|
|
16,
|
|
16,
|
|
16,
|
|
16,
|
|
16,
|
|
16,
|
|
16,
|
|
16,
|
|
17,
|
|
17,
|
|
17,
|
|
17,
|
|
18,
|
|
18,
|
|
18,
|
|
18,
|
|
19,
|
|
19,
|
|
19,
|
|
19,
|
|
20,
|
|
20,
|
|
20,
|
|
20,
|
|
21,
|
|
21,
|
|
21,
|
|
21,
|
|
16,
|
|
72,
|
|
78
|
|
];
|
|
var dbase = [
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
7,
|
|
9,
|
|
13,
|
|
17,
|
|
25,
|
|
33,
|
|
49,
|
|
65,
|
|
97,
|
|
129,
|
|
193,
|
|
257,
|
|
385,
|
|
513,
|
|
769,
|
|
1025,
|
|
1537,
|
|
2049,
|
|
3073,
|
|
4097,
|
|
6145,
|
|
8193,
|
|
12289,
|
|
16385,
|
|
24577,
|
|
0,
|
|
0
|
|
];
|
|
var dext = [
|
|
16,
|
|
16,
|
|
16,
|
|
16,
|
|
17,
|
|
17,
|
|
18,
|
|
18,
|
|
19,
|
|
19,
|
|
20,
|
|
20,
|
|
21,
|
|
21,
|
|
22,
|
|
22,
|
|
23,
|
|
23,
|
|
24,
|
|
24,
|
|
25,
|
|
25,
|
|
26,
|
|
26,
|
|
27,
|
|
27,
|
|
28,
|
|
28,
|
|
29,
|
|
29,
|
|
64,
|
|
64
|
|
];
|
|
module2.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) {
|
|
var bits = opts.bits;
|
|
var len = 0;
|
|
var sym = 0;
|
|
var min = 0, max = 0;
|
|
var root = 0;
|
|
var curr = 0;
|
|
var drop = 0;
|
|
var left = 0;
|
|
var used = 0;
|
|
var huff = 0;
|
|
var incr;
|
|
var fill;
|
|
var low;
|
|
var mask;
|
|
var next;
|
|
var base = null;
|
|
var base_index = 0;
|
|
var end;
|
|
var count = new utils.Buf16(MAXBITS + 1);
|
|
var offs = new utils.Buf16(MAXBITS + 1);
|
|
var extra = null;
|
|
var extra_index = 0;
|
|
var here_bits, here_op, here_val;
|
|
for (len = 0; len <= MAXBITS; len++) {
|
|
count[len] = 0;
|
|
}
|
|
for (sym = 0; sym < codes; sym++) {
|
|
count[lens[lens_index + sym]]++;
|
|
}
|
|
root = bits;
|
|
for (max = MAXBITS; max >= 1; max--) {
|
|
if (count[max] !== 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (root > max) {
|
|
root = max;
|
|
}
|
|
if (max === 0) {
|
|
table[table_index++] = 1 << 24 | 64 << 16 | 0;
|
|
table[table_index++] = 1 << 24 | 64 << 16 | 0;
|
|
opts.bits = 1;
|
|
return 0;
|
|
}
|
|
for (min = 1; min < max; min++) {
|
|
if (count[min] !== 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (root < min) {
|
|
root = min;
|
|
}
|
|
left = 1;
|
|
for (len = 1; len <= MAXBITS; len++) {
|
|
left <<= 1;
|
|
left -= count[len];
|
|
if (left < 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
if (left > 0 && (type === CODES || max !== 1)) {
|
|
return -1;
|
|
}
|
|
offs[1] = 0;
|
|
for (len = 1; len < MAXBITS; len++) {
|
|
offs[len + 1] = offs[len] + count[len];
|
|
}
|
|
for (sym = 0; sym < codes; sym++) {
|
|
if (lens[lens_index + sym] !== 0) {
|
|
work[offs[lens[lens_index + sym]]++] = sym;
|
|
}
|
|
}
|
|
if (type === CODES) {
|
|
base = extra = work;
|
|
end = 19;
|
|
} else if (type === LENS) {
|
|
base = lbase;
|
|
base_index -= 257;
|
|
extra = lext;
|
|
extra_index -= 257;
|
|
end = 256;
|
|
} else {
|
|
base = dbase;
|
|
extra = dext;
|
|
end = -1;
|
|
}
|
|
huff = 0;
|
|
sym = 0;
|
|
len = min;
|
|
next = table_index;
|
|
curr = root;
|
|
drop = 0;
|
|
low = -1;
|
|
used = 1 << root;
|
|
mask = used - 1;
|
|
if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
|
|
return 1;
|
|
}
|
|
for (; ; ) {
|
|
here_bits = len - drop;
|
|
if (work[sym] < end) {
|
|
here_op = 0;
|
|
here_val = work[sym];
|
|
} else if (work[sym] > end) {
|
|
here_op = extra[extra_index + work[sym]];
|
|
here_val = base[base_index + work[sym]];
|
|
} else {
|
|
here_op = 32 + 64;
|
|
here_val = 0;
|
|
}
|
|
incr = 1 << len - drop;
|
|
fill = 1 << curr;
|
|
min = fill;
|
|
do {
|
|
fill -= incr;
|
|
table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
|
|
} while (fill !== 0);
|
|
incr = 1 << len - 1;
|
|
while (huff & incr) {
|
|
incr >>= 1;
|
|
}
|
|
if (incr !== 0) {
|
|
huff &= incr - 1;
|
|
huff += incr;
|
|
} else {
|
|
huff = 0;
|
|
}
|
|
sym++;
|
|
if (--count[len] === 0) {
|
|
if (len === max) {
|
|
break;
|
|
}
|
|
len = lens[lens_index + work[sym]];
|
|
}
|
|
if (len > root && (huff & mask) !== low) {
|
|
if (drop === 0) {
|
|
drop = root;
|
|
}
|
|
next += min;
|
|
curr = len - drop;
|
|
left = 1 << curr;
|
|
while (curr + drop < max) {
|
|
left -= count[curr + drop];
|
|
if (left <= 0) {
|
|
break;
|
|
}
|
|
curr++;
|
|
left <<= 1;
|
|
}
|
|
used += 1 << curr;
|
|
if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
|
|
return 1;
|
|
}
|
|
low = huff & mask;
|
|
table[low] = root << 24 | curr << 16 | next - table_index | 0;
|
|
}
|
|
}
|
|
if (huff !== 0) {
|
|
table[next + huff] = len - drop << 24 | 64 << 16 | 0;
|
|
}
|
|
opts.bits = root;
|
|
return 0;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/inflate.js
|
|
var require_inflate = __commonJS({
|
|
"node_modules/pako/lib/zlib/inflate.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var utils = require_common();
|
|
var adler32 = require_adler32();
|
|
var crc322 = require_crc322();
|
|
var inflate_fast = require_inffast();
|
|
var inflate_table = require_inftrees();
|
|
var CODES = 0;
|
|
var LENS = 1;
|
|
var DISTS = 2;
|
|
var Z_FINISH = 4;
|
|
var Z_BLOCK = 5;
|
|
var Z_TREES = 6;
|
|
var Z_OK = 0;
|
|
var Z_STREAM_END = 1;
|
|
var Z_NEED_DICT = 2;
|
|
var Z_STREAM_ERROR = -2;
|
|
var Z_DATA_ERROR = -3;
|
|
var Z_MEM_ERROR = -4;
|
|
var Z_BUF_ERROR = -5;
|
|
var Z_DEFLATED = 8;
|
|
var HEAD = 1;
|
|
var FLAGS = 2;
|
|
var TIME = 3;
|
|
var OS = 4;
|
|
var EXLEN = 5;
|
|
var EXTRA = 6;
|
|
var NAME = 7;
|
|
var COMMENT = 8;
|
|
var HCRC = 9;
|
|
var DICTID = 10;
|
|
var DICT = 11;
|
|
var TYPE = 12;
|
|
var TYPEDO = 13;
|
|
var STORED = 14;
|
|
var COPY_ = 15;
|
|
var COPY = 16;
|
|
var TABLE = 17;
|
|
var LENLENS = 18;
|
|
var CODELENS = 19;
|
|
var LEN_ = 20;
|
|
var LEN = 21;
|
|
var LENEXT = 22;
|
|
var DIST = 23;
|
|
var DISTEXT = 24;
|
|
var MATCH = 25;
|
|
var LIT = 26;
|
|
var CHECK = 27;
|
|
var LENGTH = 28;
|
|
var DONE = 29;
|
|
var BAD = 30;
|
|
var MEM = 31;
|
|
var SYNC = 32;
|
|
var ENOUGH_LENS = 852;
|
|
var ENOUGH_DISTS = 592;
|
|
var MAX_WBITS = 15;
|
|
var DEF_WBITS = MAX_WBITS;
|
|
function zswap32(q) {
|
|
return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);
|
|
}
|
|
function InflateState() {
|
|
this.mode = 0;
|
|
this.last = false;
|
|
this.wrap = 0;
|
|
this.havedict = false;
|
|
this.flags = 0;
|
|
this.dmax = 0;
|
|
this.check = 0;
|
|
this.total = 0;
|
|
this.head = null;
|
|
this.wbits = 0;
|
|
this.wsize = 0;
|
|
this.whave = 0;
|
|
this.wnext = 0;
|
|
this.window = null;
|
|
this.hold = 0;
|
|
this.bits = 0;
|
|
this.length = 0;
|
|
this.offset = 0;
|
|
this.extra = 0;
|
|
this.lencode = null;
|
|
this.distcode = null;
|
|
this.lenbits = 0;
|
|
this.distbits = 0;
|
|
this.ncode = 0;
|
|
this.nlen = 0;
|
|
this.ndist = 0;
|
|
this.have = 0;
|
|
this.next = null;
|
|
this.lens = new utils.Buf16(320);
|
|
this.work = new utils.Buf16(288);
|
|
this.lendyn = null;
|
|
this.distdyn = null;
|
|
this.sane = 0;
|
|
this.back = 0;
|
|
this.was = 0;
|
|
}
|
|
function inflateResetKeep(strm) {
|
|
var state;
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state = strm.state;
|
|
strm.total_in = strm.total_out = state.total = 0;
|
|
strm.msg = "";
|
|
if (state.wrap) {
|
|
strm.adler = state.wrap & 1;
|
|
}
|
|
state.mode = HEAD;
|
|
state.last = 0;
|
|
state.havedict = 0;
|
|
state.dmax = 32768;
|
|
state.head = null;
|
|
state.hold = 0;
|
|
state.bits = 0;
|
|
state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
|
|
state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
|
|
state.sane = 1;
|
|
state.back = -1;
|
|
return Z_OK;
|
|
}
|
|
function inflateReset(strm) {
|
|
var state;
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state = strm.state;
|
|
state.wsize = 0;
|
|
state.whave = 0;
|
|
state.wnext = 0;
|
|
return inflateResetKeep(strm);
|
|
}
|
|
function inflateReset2(strm, windowBits) {
|
|
var wrap;
|
|
var state;
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state = strm.state;
|
|
if (windowBits < 0) {
|
|
wrap = 0;
|
|
windowBits = -windowBits;
|
|
} else {
|
|
wrap = (windowBits >> 4) + 1;
|
|
if (windowBits < 48) {
|
|
windowBits &= 15;
|
|
}
|
|
}
|
|
if (windowBits && (windowBits < 8 || windowBits > 15)) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (state.window !== null && state.wbits !== windowBits) {
|
|
state.window = null;
|
|
}
|
|
state.wrap = wrap;
|
|
state.wbits = windowBits;
|
|
return inflateReset(strm);
|
|
}
|
|
function inflateInit2(strm, windowBits) {
|
|
var ret;
|
|
var state;
|
|
if (!strm) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state = new InflateState();
|
|
strm.state = state;
|
|
state.window = null;
|
|
ret = inflateReset2(strm, windowBits);
|
|
if (ret !== Z_OK) {
|
|
strm.state = null;
|
|
}
|
|
return ret;
|
|
}
|
|
function inflateInit(strm) {
|
|
return inflateInit2(strm, DEF_WBITS);
|
|
}
|
|
var virgin = true;
|
|
var lenfix;
|
|
var distfix;
|
|
function fixedtables(state) {
|
|
if (virgin) {
|
|
var sym;
|
|
lenfix = new utils.Buf32(512);
|
|
distfix = new utils.Buf32(32);
|
|
sym = 0;
|
|
while (sym < 144) {
|
|
state.lens[sym++] = 8;
|
|
}
|
|
while (sym < 256) {
|
|
state.lens[sym++] = 9;
|
|
}
|
|
while (sym < 280) {
|
|
state.lens[sym++] = 7;
|
|
}
|
|
while (sym < 288) {
|
|
state.lens[sym++] = 8;
|
|
}
|
|
inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
|
|
sym = 0;
|
|
while (sym < 32) {
|
|
state.lens[sym++] = 5;
|
|
}
|
|
inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
|
|
virgin = false;
|
|
}
|
|
state.lencode = lenfix;
|
|
state.lenbits = 9;
|
|
state.distcode = distfix;
|
|
state.distbits = 5;
|
|
}
|
|
function updatewindow(strm, src, end, copy2) {
|
|
var dist;
|
|
var state = strm.state;
|
|
if (state.window === null) {
|
|
state.wsize = 1 << state.wbits;
|
|
state.wnext = 0;
|
|
state.whave = 0;
|
|
state.window = new utils.Buf8(state.wsize);
|
|
}
|
|
if (copy2 >= state.wsize) {
|
|
utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
|
|
state.wnext = 0;
|
|
state.whave = state.wsize;
|
|
} else {
|
|
dist = state.wsize - state.wnext;
|
|
if (dist > copy2) {
|
|
dist = copy2;
|
|
}
|
|
utils.arraySet(state.window, src, end - copy2, dist, state.wnext);
|
|
copy2 -= dist;
|
|
if (copy2) {
|
|
utils.arraySet(state.window, src, end - copy2, copy2, 0);
|
|
state.wnext = copy2;
|
|
state.whave = state.wsize;
|
|
} else {
|
|
state.wnext += dist;
|
|
if (state.wnext === state.wsize) {
|
|
state.wnext = 0;
|
|
}
|
|
if (state.whave < state.wsize) {
|
|
state.whave += dist;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function inflate2(strm, flush2) {
|
|
var state;
|
|
var input, output;
|
|
var next;
|
|
var put;
|
|
var have, left;
|
|
var hold;
|
|
var bits;
|
|
var _in, _out;
|
|
var copy2;
|
|
var from;
|
|
var from_source;
|
|
var here = 0;
|
|
var here_bits, here_op, here_val;
|
|
var last_bits, last_op, last_val;
|
|
var len;
|
|
var ret;
|
|
var hbuf = new utils.Buf8(4);
|
|
var opts;
|
|
var n;
|
|
var order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
|
if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state = strm.state;
|
|
if (state.mode === TYPE) {
|
|
state.mode = TYPEDO;
|
|
}
|
|
put = strm.next_out;
|
|
output = strm.output;
|
|
left = strm.avail_out;
|
|
next = strm.next_in;
|
|
input = strm.input;
|
|
have = strm.avail_in;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
_in = have;
|
|
_out = left;
|
|
ret = Z_OK;
|
|
inf_leave:
|
|
for (; ; ) {
|
|
switch (state.mode) {
|
|
case HEAD:
|
|
if (state.wrap === 0) {
|
|
state.mode = TYPEDO;
|
|
break;
|
|
}
|
|
while (bits < 16) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if (state.wrap & 2 && hold === 35615) {
|
|
state.check = 0;
|
|
hbuf[0] = hold & 255;
|
|
hbuf[1] = hold >>> 8 & 255;
|
|
state.check = crc322(state.check, hbuf, 2, 0);
|
|
hold = 0;
|
|
bits = 0;
|
|
state.mode = FLAGS;
|
|
break;
|
|
}
|
|
state.flags = 0;
|
|
if (state.head) {
|
|
state.head.done = false;
|
|
}
|
|
if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {
|
|
strm.msg = "incorrect header check";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if ((hold & 15) !== Z_DEFLATED) {
|
|
strm.msg = "unknown compression method";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
hold >>>= 4;
|
|
bits -= 4;
|
|
len = (hold & 15) + 8;
|
|
if (state.wbits === 0) {
|
|
state.wbits = len;
|
|
} else if (len > state.wbits) {
|
|
strm.msg = "invalid window size";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.dmax = 1 << len;
|
|
strm.adler = state.check = 1;
|
|
state.mode = hold & 512 ? DICTID : TYPE;
|
|
hold = 0;
|
|
bits = 0;
|
|
break;
|
|
case FLAGS:
|
|
while (bits < 16) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
state.flags = hold;
|
|
if ((state.flags & 255) !== Z_DEFLATED) {
|
|
strm.msg = "unknown compression method";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if (state.flags & 57344) {
|
|
strm.msg = "unknown header flags set";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if (state.head) {
|
|
state.head.text = hold >> 8 & 1;
|
|
}
|
|
if (state.flags & 512) {
|
|
hbuf[0] = hold & 255;
|
|
hbuf[1] = hold >>> 8 & 255;
|
|
state.check = crc322(state.check, hbuf, 2, 0);
|
|
}
|
|
hold = 0;
|
|
bits = 0;
|
|
state.mode = TIME;
|
|
case TIME:
|
|
while (bits < 32) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if (state.head) {
|
|
state.head.time = hold;
|
|
}
|
|
if (state.flags & 512) {
|
|
hbuf[0] = hold & 255;
|
|
hbuf[1] = hold >>> 8 & 255;
|
|
hbuf[2] = hold >>> 16 & 255;
|
|
hbuf[3] = hold >>> 24 & 255;
|
|
state.check = crc322(state.check, hbuf, 4, 0);
|
|
}
|
|
hold = 0;
|
|
bits = 0;
|
|
state.mode = OS;
|
|
case OS:
|
|
while (bits < 16) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if (state.head) {
|
|
state.head.xflags = hold & 255;
|
|
state.head.os = hold >> 8;
|
|
}
|
|
if (state.flags & 512) {
|
|
hbuf[0] = hold & 255;
|
|
hbuf[1] = hold >>> 8 & 255;
|
|
state.check = crc322(state.check, hbuf, 2, 0);
|
|
}
|
|
hold = 0;
|
|
bits = 0;
|
|
state.mode = EXLEN;
|
|
case EXLEN:
|
|
if (state.flags & 1024) {
|
|
while (bits < 16) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
state.length = hold;
|
|
if (state.head) {
|
|
state.head.extra_len = hold;
|
|
}
|
|
if (state.flags & 512) {
|
|
hbuf[0] = hold & 255;
|
|
hbuf[1] = hold >>> 8 & 255;
|
|
state.check = crc322(state.check, hbuf, 2, 0);
|
|
}
|
|
hold = 0;
|
|
bits = 0;
|
|
} else if (state.head) {
|
|
state.head.extra = null;
|
|
}
|
|
state.mode = EXTRA;
|
|
case EXTRA:
|
|
if (state.flags & 1024) {
|
|
copy2 = state.length;
|
|
if (copy2 > have) {
|
|
copy2 = have;
|
|
}
|
|
if (copy2) {
|
|
if (state.head) {
|
|
len = state.head.extra_len - state.length;
|
|
if (!state.head.extra) {
|
|
state.head.extra = new Array(state.head.extra_len);
|
|
}
|
|
utils.arraySet(state.head.extra, input, next, copy2, len);
|
|
}
|
|
if (state.flags & 512) {
|
|
state.check = crc322(state.check, input, copy2, next);
|
|
}
|
|
have -= copy2;
|
|
next += copy2;
|
|
state.length -= copy2;
|
|
}
|
|
if (state.length) {
|
|
break inf_leave;
|
|
}
|
|
}
|
|
state.length = 0;
|
|
state.mode = NAME;
|
|
case NAME:
|
|
if (state.flags & 2048) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
copy2 = 0;
|
|
do {
|
|
len = input[next + copy2++];
|
|
if (state.head && len && state.length < 65536) {
|
|
state.head.name += String.fromCharCode(len);
|
|
}
|
|
} while (len && copy2 < have);
|
|
if (state.flags & 512) {
|
|
state.check = crc322(state.check, input, copy2, next);
|
|
}
|
|
have -= copy2;
|
|
next += copy2;
|
|
if (len) {
|
|
break inf_leave;
|
|
}
|
|
} else if (state.head) {
|
|
state.head.name = null;
|
|
}
|
|
state.length = 0;
|
|
state.mode = COMMENT;
|
|
case COMMENT:
|
|
if (state.flags & 4096) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
copy2 = 0;
|
|
do {
|
|
len = input[next + copy2++];
|
|
if (state.head && len && state.length < 65536) {
|
|
state.head.comment += String.fromCharCode(len);
|
|
}
|
|
} while (len && copy2 < have);
|
|
if (state.flags & 512) {
|
|
state.check = crc322(state.check, input, copy2, next);
|
|
}
|
|
have -= copy2;
|
|
next += copy2;
|
|
if (len) {
|
|
break inf_leave;
|
|
}
|
|
} else if (state.head) {
|
|
state.head.comment = null;
|
|
}
|
|
state.mode = HCRC;
|
|
case HCRC:
|
|
if (state.flags & 512) {
|
|
while (bits < 16) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if (hold !== (state.check & 65535)) {
|
|
strm.msg = "header crc mismatch";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
hold = 0;
|
|
bits = 0;
|
|
}
|
|
if (state.head) {
|
|
state.head.hcrc = state.flags >> 9 & 1;
|
|
state.head.done = true;
|
|
}
|
|
strm.adler = state.check = 0;
|
|
state.mode = TYPE;
|
|
break;
|
|
case DICTID:
|
|
while (bits < 32) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
strm.adler = state.check = zswap32(hold);
|
|
hold = 0;
|
|
bits = 0;
|
|
state.mode = DICT;
|
|
case DICT:
|
|
if (state.havedict === 0) {
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
return Z_NEED_DICT;
|
|
}
|
|
strm.adler = state.check = 1;
|
|
state.mode = TYPE;
|
|
case TYPE:
|
|
if (flush2 === Z_BLOCK || flush2 === Z_TREES) {
|
|
break inf_leave;
|
|
}
|
|
case TYPEDO:
|
|
if (state.last) {
|
|
hold >>>= bits & 7;
|
|
bits -= bits & 7;
|
|
state.mode = CHECK;
|
|
break;
|
|
}
|
|
while (bits < 3) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
state.last = hold & 1;
|
|
hold >>>= 1;
|
|
bits -= 1;
|
|
switch (hold & 3) {
|
|
case 0:
|
|
state.mode = STORED;
|
|
break;
|
|
case 1:
|
|
fixedtables(state);
|
|
state.mode = LEN_;
|
|
if (flush2 === Z_TREES) {
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
break inf_leave;
|
|
}
|
|
break;
|
|
case 2:
|
|
state.mode = TABLE;
|
|
break;
|
|
case 3:
|
|
strm.msg = "invalid block type";
|
|
state.mode = BAD;
|
|
}
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
break;
|
|
case STORED:
|
|
hold >>>= bits & 7;
|
|
bits -= bits & 7;
|
|
while (bits < 32) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if ((hold & 65535) !== (hold >>> 16 ^ 65535)) {
|
|
strm.msg = "invalid stored block lengths";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.length = hold & 65535;
|
|
hold = 0;
|
|
bits = 0;
|
|
state.mode = COPY_;
|
|
if (flush2 === Z_TREES) {
|
|
break inf_leave;
|
|
}
|
|
case COPY_:
|
|
state.mode = COPY;
|
|
case COPY:
|
|
copy2 = state.length;
|
|
if (copy2) {
|
|
if (copy2 > have) {
|
|
copy2 = have;
|
|
}
|
|
if (copy2 > left) {
|
|
copy2 = left;
|
|
}
|
|
if (copy2 === 0) {
|
|
break inf_leave;
|
|
}
|
|
utils.arraySet(output, input, next, copy2, put);
|
|
have -= copy2;
|
|
next += copy2;
|
|
left -= copy2;
|
|
put += copy2;
|
|
state.length -= copy2;
|
|
break;
|
|
}
|
|
state.mode = TYPE;
|
|
break;
|
|
case TABLE:
|
|
while (bits < 14) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
state.nlen = (hold & 31) + 257;
|
|
hold >>>= 5;
|
|
bits -= 5;
|
|
state.ndist = (hold & 31) + 1;
|
|
hold >>>= 5;
|
|
bits -= 5;
|
|
state.ncode = (hold & 15) + 4;
|
|
hold >>>= 4;
|
|
bits -= 4;
|
|
if (state.nlen > 286 || state.ndist > 30) {
|
|
strm.msg = "too many length or distance symbols";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.have = 0;
|
|
state.mode = LENLENS;
|
|
case LENLENS:
|
|
while (state.have < state.ncode) {
|
|
while (bits < 3) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
state.lens[order[state.have++]] = hold & 7;
|
|
hold >>>= 3;
|
|
bits -= 3;
|
|
}
|
|
while (state.have < 19) {
|
|
state.lens[order[state.have++]] = 0;
|
|
}
|
|
state.lencode = state.lendyn;
|
|
state.lenbits = 7;
|
|
opts = { bits: state.lenbits };
|
|
ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
|
|
state.lenbits = opts.bits;
|
|
if (ret) {
|
|
strm.msg = "invalid code lengths set";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.have = 0;
|
|
state.mode = CODELENS;
|
|
case CODELENS:
|
|
while (state.have < state.nlen + state.ndist) {
|
|
for (; ; ) {
|
|
here = state.lencode[hold & (1 << state.lenbits) - 1];
|
|
here_bits = here >>> 24;
|
|
here_op = here >>> 16 & 255;
|
|
here_val = here & 65535;
|
|
if (here_bits <= bits) {
|
|
break;
|
|
}
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if (here_val < 16) {
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
state.lens[state.have++] = here_val;
|
|
} else {
|
|
if (here_val === 16) {
|
|
n = here_bits + 2;
|
|
while (bits < n) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
if (state.have === 0) {
|
|
strm.msg = "invalid bit length repeat";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
len = state.lens[state.have - 1];
|
|
copy2 = 3 + (hold & 3);
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
} else if (here_val === 17) {
|
|
n = here_bits + 3;
|
|
while (bits < n) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
len = 0;
|
|
copy2 = 3 + (hold & 7);
|
|
hold >>>= 3;
|
|
bits -= 3;
|
|
} else {
|
|
n = here_bits + 7;
|
|
while (bits < n) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
len = 0;
|
|
copy2 = 11 + (hold & 127);
|
|
hold >>>= 7;
|
|
bits -= 7;
|
|
}
|
|
if (state.have + copy2 > state.nlen + state.ndist) {
|
|
strm.msg = "invalid bit length repeat";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
while (copy2--) {
|
|
state.lens[state.have++] = len;
|
|
}
|
|
}
|
|
}
|
|
if (state.mode === BAD) {
|
|
break;
|
|
}
|
|
if (state.lens[256] === 0) {
|
|
strm.msg = "invalid code -- missing end-of-block";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.lenbits = 9;
|
|
opts = { bits: state.lenbits };
|
|
ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
|
|
state.lenbits = opts.bits;
|
|
if (ret) {
|
|
strm.msg = "invalid literal/lengths set";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.distbits = 6;
|
|
state.distcode = state.distdyn;
|
|
opts = { bits: state.distbits };
|
|
ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
|
|
state.distbits = opts.bits;
|
|
if (ret) {
|
|
strm.msg = "invalid distances set";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.mode = LEN_;
|
|
if (flush2 === Z_TREES) {
|
|
break inf_leave;
|
|
}
|
|
case LEN_:
|
|
state.mode = LEN;
|
|
case LEN:
|
|
if (have >= 6 && left >= 258) {
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
inflate_fast(strm, _out);
|
|
put = strm.next_out;
|
|
output = strm.output;
|
|
left = strm.avail_out;
|
|
next = strm.next_in;
|
|
input = strm.input;
|
|
have = strm.avail_in;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
if (state.mode === TYPE) {
|
|
state.back = -1;
|
|
}
|
|
break;
|
|
}
|
|
state.back = 0;
|
|
for (; ; ) {
|
|
here = state.lencode[hold & (1 << state.lenbits) - 1];
|
|
here_bits = here >>> 24;
|
|
here_op = here >>> 16 & 255;
|
|
here_val = here & 65535;
|
|
if (here_bits <= bits) {
|
|
break;
|
|
}
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if (here_op && (here_op & 240) === 0) {
|
|
last_bits = here_bits;
|
|
last_op = here_op;
|
|
last_val = here_val;
|
|
for (; ; ) {
|
|
here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
|
|
here_bits = here >>> 24;
|
|
here_op = here >>> 16 & 255;
|
|
here_val = here & 65535;
|
|
if (last_bits + here_bits <= bits) {
|
|
break;
|
|
}
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
hold >>>= last_bits;
|
|
bits -= last_bits;
|
|
state.back += last_bits;
|
|
}
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
state.back += here_bits;
|
|
state.length = here_val;
|
|
if (here_op === 0) {
|
|
state.mode = LIT;
|
|
break;
|
|
}
|
|
if (here_op & 32) {
|
|
state.back = -1;
|
|
state.mode = TYPE;
|
|
break;
|
|
}
|
|
if (here_op & 64) {
|
|
strm.msg = "invalid literal/length code";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.extra = here_op & 15;
|
|
state.mode = LENEXT;
|
|
case LENEXT:
|
|
if (state.extra) {
|
|
n = state.extra;
|
|
while (bits < n) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
state.length += hold & (1 << state.extra) - 1;
|
|
hold >>>= state.extra;
|
|
bits -= state.extra;
|
|
state.back += state.extra;
|
|
}
|
|
state.was = state.length;
|
|
state.mode = DIST;
|
|
case DIST:
|
|
for (; ; ) {
|
|
here = state.distcode[hold & (1 << state.distbits) - 1];
|
|
here_bits = here >>> 24;
|
|
here_op = here >>> 16 & 255;
|
|
here_val = here & 65535;
|
|
if (here_bits <= bits) {
|
|
break;
|
|
}
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if ((here_op & 240) === 0) {
|
|
last_bits = here_bits;
|
|
last_op = here_op;
|
|
last_val = here_val;
|
|
for (; ; ) {
|
|
here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
|
|
here_bits = here >>> 24;
|
|
here_op = here >>> 16 & 255;
|
|
here_val = here & 65535;
|
|
if (last_bits + here_bits <= bits) {
|
|
break;
|
|
}
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
hold >>>= last_bits;
|
|
bits -= last_bits;
|
|
state.back += last_bits;
|
|
}
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
state.back += here_bits;
|
|
if (here_op & 64) {
|
|
strm.msg = "invalid distance code";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.offset = here_val;
|
|
state.extra = here_op & 15;
|
|
state.mode = DISTEXT;
|
|
case DISTEXT:
|
|
if (state.extra) {
|
|
n = state.extra;
|
|
while (bits < n) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
state.offset += hold & (1 << state.extra) - 1;
|
|
hold >>>= state.extra;
|
|
bits -= state.extra;
|
|
state.back += state.extra;
|
|
}
|
|
if (state.offset > state.dmax) {
|
|
strm.msg = "invalid distance too far back";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.mode = MATCH;
|
|
case MATCH:
|
|
if (left === 0) {
|
|
break inf_leave;
|
|
}
|
|
copy2 = _out - left;
|
|
if (state.offset > copy2) {
|
|
copy2 = state.offset - copy2;
|
|
if (copy2 > state.whave) {
|
|
if (state.sane) {
|
|
strm.msg = "invalid distance too far back";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
}
|
|
if (copy2 > state.wnext) {
|
|
copy2 -= state.wnext;
|
|
from = state.wsize - copy2;
|
|
} else {
|
|
from = state.wnext - copy2;
|
|
}
|
|
if (copy2 > state.length) {
|
|
copy2 = state.length;
|
|
}
|
|
from_source = state.window;
|
|
} else {
|
|
from_source = output;
|
|
from = put - state.offset;
|
|
copy2 = state.length;
|
|
}
|
|
if (copy2 > left) {
|
|
copy2 = left;
|
|
}
|
|
left -= copy2;
|
|
state.length -= copy2;
|
|
do {
|
|
output[put++] = from_source[from++];
|
|
} while (--copy2);
|
|
if (state.length === 0) {
|
|
state.mode = LEN;
|
|
}
|
|
break;
|
|
case LIT:
|
|
if (left === 0) {
|
|
break inf_leave;
|
|
}
|
|
output[put++] = state.length;
|
|
left--;
|
|
state.mode = LEN;
|
|
break;
|
|
case CHECK:
|
|
if (state.wrap) {
|
|
while (bits < 32) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold |= input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
_out -= left;
|
|
strm.total_out += _out;
|
|
state.total += _out;
|
|
if (_out) {
|
|
strm.adler = state.check = state.flags ? crc322(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out);
|
|
}
|
|
_out = left;
|
|
if ((state.flags ? hold : zswap32(hold)) !== state.check) {
|
|
strm.msg = "incorrect data check";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
hold = 0;
|
|
bits = 0;
|
|
}
|
|
state.mode = LENGTH;
|
|
case LENGTH:
|
|
if (state.wrap && state.flags) {
|
|
while (bits < 32) {
|
|
if (have === 0) {
|
|
break inf_leave;
|
|
}
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
if (hold !== (state.total & 4294967295)) {
|
|
strm.msg = "incorrect length check";
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
hold = 0;
|
|
bits = 0;
|
|
}
|
|
state.mode = DONE;
|
|
case DONE:
|
|
ret = Z_STREAM_END;
|
|
break inf_leave;
|
|
case BAD:
|
|
ret = Z_DATA_ERROR;
|
|
break inf_leave;
|
|
case MEM:
|
|
return Z_MEM_ERROR;
|
|
case SYNC:
|
|
default:
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
}
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
if (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush2 !== Z_FINISH)) {
|
|
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
|
|
state.mode = MEM;
|
|
return Z_MEM_ERROR;
|
|
}
|
|
}
|
|
_in -= strm.avail_in;
|
|
_out -= strm.avail_out;
|
|
strm.total_in += _in;
|
|
strm.total_out += _out;
|
|
state.total += _out;
|
|
if (state.wrap && _out) {
|
|
strm.adler = state.check = state.flags ? crc322(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out);
|
|
}
|
|
strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
|
|
if ((_in === 0 && _out === 0 || flush2 === Z_FINISH) && ret === Z_OK) {
|
|
ret = Z_BUF_ERROR;
|
|
}
|
|
return ret;
|
|
}
|
|
function inflateEnd(strm) {
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
var state = strm.state;
|
|
if (state.window) {
|
|
state.window = null;
|
|
}
|
|
strm.state = null;
|
|
return Z_OK;
|
|
}
|
|
function inflateGetHeader(strm, head) {
|
|
var state;
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state = strm.state;
|
|
if ((state.wrap & 2) === 0) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state.head = head;
|
|
head.done = false;
|
|
return Z_OK;
|
|
}
|
|
function inflateSetDictionary(strm, dictionary) {
|
|
var dictLength = dictionary.length;
|
|
var state;
|
|
var dictid;
|
|
var ret;
|
|
if (!strm || !strm.state) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
state = strm.state;
|
|
if (state.wrap !== 0 && state.mode !== DICT) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (state.mode === DICT) {
|
|
dictid = 1;
|
|
dictid = adler32(dictid, dictionary, dictLength, 0);
|
|
if (dictid !== state.check) {
|
|
return Z_DATA_ERROR;
|
|
}
|
|
}
|
|
ret = updatewindow(strm, dictionary, dictLength, dictLength);
|
|
if (ret) {
|
|
state.mode = MEM;
|
|
return Z_MEM_ERROR;
|
|
}
|
|
state.havedict = 1;
|
|
return Z_OK;
|
|
}
|
|
exports.inflateReset = inflateReset;
|
|
exports.inflateReset2 = inflateReset2;
|
|
exports.inflateResetKeep = inflateResetKeep;
|
|
exports.inflateInit = inflateInit;
|
|
exports.inflateInit2 = inflateInit2;
|
|
exports.inflate = inflate2;
|
|
exports.inflateEnd = inflateEnd;
|
|
exports.inflateGetHeader = inflateGetHeader;
|
|
exports.inflateSetDictionary = inflateSetDictionary;
|
|
exports.inflateInfo = "pako inflate (from Nodeca project)";
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/constants.js
|
|
var require_constants = __commonJS({
|
|
"node_modules/pako/lib/zlib/constants.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
module2.exports = {
|
|
Z_NO_FLUSH: 0,
|
|
Z_PARTIAL_FLUSH: 1,
|
|
Z_SYNC_FLUSH: 2,
|
|
Z_FULL_FLUSH: 3,
|
|
Z_FINISH: 4,
|
|
Z_BLOCK: 5,
|
|
Z_TREES: 6,
|
|
Z_OK: 0,
|
|
Z_STREAM_END: 1,
|
|
Z_NEED_DICT: 2,
|
|
Z_ERRNO: -1,
|
|
Z_STREAM_ERROR: -2,
|
|
Z_DATA_ERROR: -3,
|
|
Z_BUF_ERROR: -5,
|
|
Z_NO_COMPRESSION: 0,
|
|
Z_BEST_SPEED: 1,
|
|
Z_BEST_COMPRESSION: 9,
|
|
Z_DEFAULT_COMPRESSION: -1,
|
|
Z_FILTERED: 1,
|
|
Z_HUFFMAN_ONLY: 2,
|
|
Z_RLE: 3,
|
|
Z_FIXED: 4,
|
|
Z_DEFAULT_STRATEGY: 0,
|
|
Z_BINARY: 0,
|
|
Z_TEXT: 1,
|
|
Z_UNKNOWN: 2,
|
|
Z_DEFLATED: 8
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/zlib/gzheader.js
|
|
var require_gzheader = __commonJS({
|
|
"node_modules/pako/lib/zlib/gzheader.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
function GZheader() {
|
|
this.text = 0;
|
|
this.time = 0;
|
|
this.xflags = 0;
|
|
this.os = 0;
|
|
this.extra = null;
|
|
this.extra_len = 0;
|
|
this.name = "";
|
|
this.comment = "";
|
|
this.hcrc = 0;
|
|
this.done = false;
|
|
}
|
|
module2.exports = GZheader;
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/lib/inflate.js
|
|
var require_inflate2 = __commonJS({
|
|
"node_modules/pako/lib/inflate.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var zlib_inflate = require_inflate();
|
|
var utils = require_common();
|
|
var strings = require_strings();
|
|
var c = require_constants();
|
|
var msg = require_messages();
|
|
var ZStream = require_zstream();
|
|
var GZheader = require_gzheader();
|
|
var toString = Object.prototype.toString;
|
|
function Inflate(options) {
|
|
if (!(this instanceof Inflate))
|
|
return new Inflate(options);
|
|
this.options = utils.assign({
|
|
chunkSize: 16384,
|
|
windowBits: 0,
|
|
to: ""
|
|
}, options || {});
|
|
var opt = this.options;
|
|
if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
|
|
opt.windowBits = -opt.windowBits;
|
|
if (opt.windowBits === 0) {
|
|
opt.windowBits = -15;
|
|
}
|
|
}
|
|
if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) {
|
|
opt.windowBits += 32;
|
|
}
|
|
if (opt.windowBits > 15 && opt.windowBits < 48) {
|
|
if ((opt.windowBits & 15) === 0) {
|
|
opt.windowBits |= 15;
|
|
}
|
|
}
|
|
this.err = 0;
|
|
this.msg = "";
|
|
this.ended = false;
|
|
this.chunks = [];
|
|
this.strm = new ZStream();
|
|
this.strm.avail_out = 0;
|
|
var status2 = zlib_inflate.inflateInit2(this.strm, opt.windowBits);
|
|
if (status2 !== c.Z_OK) {
|
|
throw new Error(msg[status2]);
|
|
}
|
|
this.header = new GZheader();
|
|
zlib_inflate.inflateGetHeader(this.strm, this.header);
|
|
if (opt.dictionary) {
|
|
if (typeof opt.dictionary === "string") {
|
|
opt.dictionary = strings.string2buf(opt.dictionary);
|
|
} else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") {
|
|
opt.dictionary = new Uint8Array(opt.dictionary);
|
|
}
|
|
if (opt.raw) {
|
|
status2 = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary);
|
|
if (status2 !== c.Z_OK) {
|
|
throw new Error(msg[status2]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Inflate.prototype.push = function(data, mode) {
|
|
var strm = this.strm;
|
|
var chunkSize = this.options.chunkSize;
|
|
var dictionary = this.options.dictionary;
|
|
var status2, _mode;
|
|
var next_out_utf8, tail, utf8str;
|
|
var allowBufError = false;
|
|
if (this.ended) {
|
|
return false;
|
|
}
|
|
_mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH;
|
|
if (typeof data === "string") {
|
|
strm.input = strings.binstring2buf(data);
|
|
} else if (toString.call(data) === "[object ArrayBuffer]") {
|
|
strm.input = new Uint8Array(data);
|
|
} else {
|
|
strm.input = data;
|
|
}
|
|
strm.next_in = 0;
|
|
strm.avail_in = strm.input.length;
|
|
do {
|
|
if (strm.avail_out === 0) {
|
|
strm.output = new utils.Buf8(chunkSize);
|
|
strm.next_out = 0;
|
|
strm.avail_out = chunkSize;
|
|
}
|
|
status2 = zlib_inflate.inflate(strm, c.Z_NO_FLUSH);
|
|
if (status2 === c.Z_NEED_DICT && dictionary) {
|
|
status2 = zlib_inflate.inflateSetDictionary(this.strm, dictionary);
|
|
}
|
|
if (status2 === c.Z_BUF_ERROR && allowBufError === true) {
|
|
status2 = c.Z_OK;
|
|
allowBufError = false;
|
|
}
|
|
if (status2 !== c.Z_STREAM_END && status2 !== c.Z_OK) {
|
|
this.onEnd(status2);
|
|
this.ended = true;
|
|
return false;
|
|
}
|
|
if (strm.next_out) {
|
|
if (strm.avail_out === 0 || status2 === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) {
|
|
if (this.options.to === "string") {
|
|
next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
|
|
tail = strm.next_out - next_out_utf8;
|
|
utf8str = strings.buf2string(strm.output, next_out_utf8);
|
|
strm.next_out = tail;
|
|
strm.avail_out = chunkSize - tail;
|
|
if (tail) {
|
|
utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0);
|
|
}
|
|
this.onData(utf8str);
|
|
} else {
|
|
this.onData(utils.shrinkBuf(strm.output, strm.next_out));
|
|
}
|
|
}
|
|
}
|
|
if (strm.avail_in === 0 && strm.avail_out === 0) {
|
|
allowBufError = true;
|
|
}
|
|
} while ((strm.avail_in > 0 || strm.avail_out === 0) && status2 !== c.Z_STREAM_END);
|
|
if (status2 === c.Z_STREAM_END) {
|
|
_mode = c.Z_FINISH;
|
|
}
|
|
if (_mode === c.Z_FINISH) {
|
|
status2 = zlib_inflate.inflateEnd(this.strm);
|
|
this.onEnd(status2);
|
|
this.ended = true;
|
|
return status2 === c.Z_OK;
|
|
}
|
|
if (_mode === c.Z_SYNC_FLUSH) {
|
|
this.onEnd(c.Z_OK);
|
|
strm.avail_out = 0;
|
|
return true;
|
|
}
|
|
return true;
|
|
};
|
|
Inflate.prototype.onData = function(chunk) {
|
|
this.chunks.push(chunk);
|
|
};
|
|
Inflate.prototype.onEnd = function(status2) {
|
|
if (status2 === c.Z_OK) {
|
|
if (this.options.to === "string") {
|
|
this.result = this.chunks.join("");
|
|
} else {
|
|
this.result = utils.flattenChunks(this.chunks);
|
|
}
|
|
}
|
|
this.chunks = [];
|
|
this.err = status2;
|
|
this.msg = this.strm.msg;
|
|
};
|
|
function inflate2(input, options) {
|
|
var inflator = new Inflate(options);
|
|
inflator.push(input, true);
|
|
if (inflator.err) {
|
|
throw inflator.msg || msg[inflator.err];
|
|
}
|
|
return inflator.result;
|
|
}
|
|
function inflateRaw(input, options) {
|
|
options = options || {};
|
|
options.raw = true;
|
|
return inflate2(input, options);
|
|
}
|
|
exports.Inflate = Inflate;
|
|
exports.inflate = inflate2;
|
|
exports.inflateRaw = inflateRaw;
|
|
exports.ungzip = inflate2;
|
|
}
|
|
});
|
|
|
|
// node_modules/pako/index.js
|
|
var require_pako = __commonJS({
|
|
"node_modules/pako/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var assign2 = require_common().assign;
|
|
var deflate2 = require_deflate2();
|
|
var inflate2 = require_inflate2();
|
|
var constants = require_constants();
|
|
var pako2 = {};
|
|
assign2(pako2, deflate2, inflate2, constants);
|
|
module2.exports = pako2;
|
|
}
|
|
});
|
|
|
|
// node_modules/ignore/index.js
|
|
var require_ignore = __commonJS({
|
|
"node_modules/ignore/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
function makeArray(subject) {
|
|
return Array.isArray(subject) ? subject : [subject];
|
|
}
|
|
var EMPTY = "";
|
|
var SPACE = " ";
|
|
var ESCAPE = "\\";
|
|
var REGEX_TEST_BLANK_LINE = /^\s+$/;
|
|
var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
|
|
var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
|
|
var REGEX_SPLITALL_CRLF = /\r?\n/g;
|
|
var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
|
|
var SLASH = "/";
|
|
var KEY_IGNORE = typeof Symbol !== "undefined" ? Symbol.for("node-ignore") : "node-ignore";
|
|
var define2 = (object, key2, value) => Object.defineProperty(object, key2, { value });
|
|
var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
|
|
var RETURN_FALSE = () => false;
|
|
var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
|
|
var cleanRangeBackSlash = (slashes) => {
|
|
const { length } = slashes;
|
|
return slashes.slice(0, length - length % 2);
|
|
};
|
|
var REPLACERS = [
|
|
[
|
|
/\\?\s+$/,
|
|
(match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
|
|
],
|
|
[
|
|
/\\\s/g,
|
|
() => SPACE
|
|
],
|
|
[
|
|
/[\\$.|*+(){^]/g,
|
|
(match) => `\\${match}`
|
|
],
|
|
[
|
|
/(?!\\)\?/g,
|
|
() => "[^/]"
|
|
],
|
|
[
|
|
/^\//,
|
|
() => "^"
|
|
],
|
|
[
|
|
/\//g,
|
|
() => "\\/"
|
|
],
|
|
[
|
|
/^\^*\\\*\\\*\\\//,
|
|
() => "^(?:.*\\/)?"
|
|
],
|
|
[
|
|
/^(?=[^^])/,
|
|
function startingReplacer() {
|
|
return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
|
|
}
|
|
],
|
|
[
|
|
/\\\/\\\*\\\*(?=\\\/|$)/g,
|
|
(_, index2, str) => index2 + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
|
|
],
|
|
[
|
|
/(^|[^\\]+)\\\*(?=.+)/g,
|
|
(_, p1) => `${p1}[^\\/]*`
|
|
],
|
|
[
|
|
/\\\\\\(?=[$.|*+(){^])/g,
|
|
() => ESCAPE
|
|
],
|
|
[
|
|
/\\\\/g,
|
|
() => ESCAPE
|
|
],
|
|
[
|
|
/(\\)?\[([^\]/]*?)(\\*)($|\])/g,
|
|
(match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
|
|
],
|
|
[
|
|
/(?:[^*])$/,
|
|
(match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
|
|
],
|
|
[
|
|
/(\^|\\\/)?\\\*$/,
|
|
(_, p1) => {
|
|
const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
|
|
return `${prefix}(?=$|\\/$)`;
|
|
}
|
|
]
|
|
];
|
|
var regexCache = Object.create(null);
|
|
var makeRegex = (pattern, ignoreCase) => {
|
|
let source = regexCache[pattern];
|
|
if (!source) {
|
|
source = REPLACERS.reduce((prev, current) => prev.replace(current[0], current[1].bind(pattern)), pattern);
|
|
regexCache[pattern] = source;
|
|
}
|
|
return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
|
|
};
|
|
var isString = (subject) => typeof subject === "string";
|
|
var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && pattern.indexOf("#") !== 0;
|
|
var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
|
|
var IgnoreRule = class {
|
|
constructor(origin, pattern, negative, regex2) {
|
|
this.origin = origin;
|
|
this.pattern = pattern;
|
|
this.negative = negative;
|
|
this.regex = regex2;
|
|
}
|
|
};
|
|
var createRule = (pattern, ignoreCase) => {
|
|
const origin = pattern;
|
|
let negative = false;
|
|
if (pattern.indexOf("!") === 0) {
|
|
negative = true;
|
|
pattern = pattern.substr(1);
|
|
}
|
|
pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
|
|
const regex2 = makeRegex(pattern, ignoreCase);
|
|
return new IgnoreRule(origin, pattern, negative, regex2);
|
|
};
|
|
var throwError = (message, Ctor) => {
|
|
throw new Ctor(message);
|
|
};
|
|
var checkPath = (path2, originalPath, doThrow) => {
|
|
if (!isString(path2)) {
|
|
return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
|
|
}
|
|
if (!path2) {
|
|
return doThrow(`path must not be empty`, TypeError);
|
|
}
|
|
if (checkPath.isNotRelative(path2)) {
|
|
const r = "`path.relative()`d";
|
|
return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
|
|
}
|
|
return true;
|
|
};
|
|
var isNotRelative = (path2) => REGEX_TEST_INVALID_PATH.test(path2);
|
|
checkPath.isNotRelative = isNotRelative;
|
|
checkPath.convert = (p) => p;
|
|
var Ignore = class {
|
|
constructor({
|
|
ignorecase = true,
|
|
ignoreCase = ignorecase,
|
|
allowRelativePaths = false
|
|
} = {}) {
|
|
define2(this, KEY_IGNORE, true);
|
|
this._rules = [];
|
|
this._ignoreCase = ignoreCase;
|
|
this._allowRelativePaths = allowRelativePaths;
|
|
this._initCache();
|
|
}
|
|
_initCache() {
|
|
this._ignoreCache = Object.create(null);
|
|
this._testCache = Object.create(null);
|
|
}
|
|
_addPattern(pattern) {
|
|
if (pattern && pattern[KEY_IGNORE]) {
|
|
this._rules = this._rules.concat(pattern._rules);
|
|
this._added = true;
|
|
return;
|
|
}
|
|
if (checkPattern(pattern)) {
|
|
const rule = createRule(pattern, this._ignoreCase);
|
|
this._added = true;
|
|
this._rules.push(rule);
|
|
}
|
|
}
|
|
add(pattern) {
|
|
this._added = false;
|
|
makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this);
|
|
if (this._added) {
|
|
this._initCache();
|
|
}
|
|
return this;
|
|
}
|
|
addPattern(pattern) {
|
|
return this.add(pattern);
|
|
}
|
|
_testOne(path2, checkUnignored) {
|
|
let ignored = false;
|
|
let unignored = false;
|
|
this._rules.forEach((rule) => {
|
|
const { negative } = rule;
|
|
if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
|
|
return;
|
|
}
|
|
const matched = rule.regex.test(path2);
|
|
if (matched) {
|
|
ignored = !negative;
|
|
unignored = negative;
|
|
}
|
|
});
|
|
return {
|
|
ignored,
|
|
unignored
|
|
};
|
|
}
|
|
_test(originalPath, cache, checkUnignored, slices) {
|
|
const path2 = originalPath && checkPath.convert(originalPath);
|
|
checkPath(path2, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
|
|
return this._t(path2, cache, checkUnignored, slices);
|
|
}
|
|
_t(path2, cache, checkUnignored, slices) {
|
|
if (path2 in cache) {
|
|
return cache[path2];
|
|
}
|
|
if (!slices) {
|
|
slices = path2.split(SLASH);
|
|
}
|
|
slices.pop();
|
|
if (!slices.length) {
|
|
return cache[path2] = this._testOne(path2, checkUnignored);
|
|
}
|
|
const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
|
|
return cache[path2] = parent.ignored ? parent : this._testOne(path2, checkUnignored);
|
|
}
|
|
ignores(path2) {
|
|
return this._test(path2, this._ignoreCache, false).ignored;
|
|
}
|
|
createFilter() {
|
|
return (path2) => !this.ignores(path2);
|
|
}
|
|
filter(paths) {
|
|
return makeArray(paths).filter(this.createFilter());
|
|
}
|
|
test(path2) {
|
|
return this._test(path2, this._testCache, true);
|
|
}
|
|
};
|
|
var factory = (options) => new Ignore(options);
|
|
var isPathValid = (path2) => checkPath(path2 && checkPath.convert(path2), path2, RETURN_FALSE);
|
|
factory.isPathValid = isPathValid;
|
|
factory.default = factory;
|
|
module2.exports = factory;
|
|
if (typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
|
|
const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
|
|
checkPath.convert = makePosix;
|
|
const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
|
|
checkPath.isNotRelative = (path2) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path2) || isNotRelative(path2);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/pify/index.js
|
|
var require_pify = __commonJS({
|
|
"node_modules/pify/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var processFn = (fn, options) => function(...args) {
|
|
const P = options.promiseModule;
|
|
return new P((resolve, reject) => {
|
|
if (options.multiArgs) {
|
|
args.push((...result) => {
|
|
if (options.errorFirst) {
|
|
if (result[0]) {
|
|
reject(result);
|
|
} else {
|
|
result.shift();
|
|
resolve(result);
|
|
}
|
|
} else {
|
|
resolve(result);
|
|
}
|
|
});
|
|
} else if (options.errorFirst) {
|
|
args.push((error, result) => {
|
|
if (error) {
|
|
reject(error);
|
|
} else {
|
|
resolve(result);
|
|
}
|
|
});
|
|
} else {
|
|
args.push(resolve);
|
|
}
|
|
fn.apply(this, args);
|
|
});
|
|
};
|
|
module2.exports = (input, options) => {
|
|
options = Object.assign({
|
|
exclude: [/.+(Sync|Stream)$/],
|
|
errorFirst: true,
|
|
promiseModule: Promise
|
|
}, options);
|
|
const objType = typeof input;
|
|
if (!(input !== null && (objType === "object" || objType === "function"))) {
|
|
throw new TypeError(`Expected \`input\` to be a \`Function\` or \`Object\`, got \`${input === null ? "null" : objType}\``);
|
|
}
|
|
const filter = (key2) => {
|
|
const match = (pattern) => typeof pattern === "string" ? key2 === pattern : pattern.test(key2);
|
|
return options.include ? options.include.some(match) : !options.exclude.some(match);
|
|
};
|
|
let ret;
|
|
if (objType === "function") {
|
|
ret = function(...args) {
|
|
return options.excludeMain ? input(...args) : processFn(input, options).apply(this, args);
|
|
};
|
|
} else {
|
|
ret = Object.create(Object.getPrototypeOf(input));
|
|
}
|
|
for (const key2 in input) {
|
|
const property = input[key2];
|
|
ret[key2] = typeof property === "function" && filter(key2) ? processFn(property, options) : property;
|
|
}
|
|
return ret;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/clean-git-ref/lib/index.js
|
|
var require_lib2 = __commonJS({
|
|
"node_modules/clean-git-ref/lib/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
function escapeRegExp(string) {
|
|
return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
}
|
|
function replaceAll(str, search, replacement) {
|
|
search = search instanceof RegExp ? search : new RegExp(escapeRegExp(search), "g");
|
|
return str.replace(search, replacement);
|
|
}
|
|
var CleanGitRef = {
|
|
clean: function clean(value) {
|
|
if (typeof value !== "string") {
|
|
throw new Error("Expected a string, received: " + value);
|
|
}
|
|
value = replaceAll(value, "./", "/");
|
|
value = replaceAll(value, "..", ".");
|
|
value = replaceAll(value, " ", "-");
|
|
value = replaceAll(value, /^[~^:?*\\\-]/g, "");
|
|
value = replaceAll(value, /[~^:?*\\]/g, "-");
|
|
value = replaceAll(value, /[~^:?*\\\-]$/g, "");
|
|
value = replaceAll(value, "@{", "-");
|
|
value = replaceAll(value, /\.$/g, "");
|
|
value = replaceAll(value, /\/$/g, "");
|
|
value = replaceAll(value, /\.lock$/g, "");
|
|
return value;
|
|
}
|
|
};
|
|
module2.exports = CleanGitRef;
|
|
}
|
|
});
|
|
|
|
// node_modules/diff3/onp.js
|
|
var require_onp = __commonJS({
|
|
"node_modules/diff3/onp.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
module2.exports = function(a_, b_) {
|
|
var a = a_, b = b_, m = a.length, n = b.length, reverse = false, ed = null, offset = m + 1, path2 = [], pathposi = [], ses = [], lcs = "", SES_DELETE = -1, SES_COMMON = 0, SES_ADD = 1;
|
|
var tmp1, tmp2;
|
|
var init3 = function() {
|
|
if (m >= n) {
|
|
tmp1 = a;
|
|
tmp2 = m;
|
|
a = b;
|
|
b = tmp1;
|
|
m = n;
|
|
n = tmp2;
|
|
reverse = true;
|
|
offset = m + 1;
|
|
}
|
|
};
|
|
var P = function(x, y, k) {
|
|
return {
|
|
"x": x,
|
|
"y": y,
|
|
"k": k
|
|
};
|
|
};
|
|
var seselem = function(elem, t) {
|
|
return {
|
|
"elem": elem,
|
|
"t": t
|
|
};
|
|
};
|
|
var snake = function(k, p, pp) {
|
|
var r, x, y;
|
|
if (p > pp) {
|
|
r = path2[k - 1 + offset];
|
|
} else {
|
|
r = path2[k + 1 + offset];
|
|
}
|
|
y = Math.max(p, pp);
|
|
x = y - k;
|
|
while (x < m && y < n && a[x] === b[y]) {
|
|
++x;
|
|
++y;
|
|
}
|
|
path2[k + offset] = pathposi.length;
|
|
pathposi[pathposi.length] = new P(x, y, r);
|
|
return y;
|
|
};
|
|
var recordseq = function(epc) {
|
|
var x_idx, y_idx, px_idx, py_idx, i;
|
|
x_idx = y_idx = 1;
|
|
px_idx = py_idx = 0;
|
|
for (i = epc.length - 1; i >= 0; --i) {
|
|
while (px_idx < epc[i].x || py_idx < epc[i].y) {
|
|
if (epc[i].y - epc[i].x > py_idx - px_idx) {
|
|
if (reverse) {
|
|
ses[ses.length] = new seselem(b[py_idx], SES_DELETE);
|
|
} else {
|
|
ses[ses.length] = new seselem(b[py_idx], SES_ADD);
|
|
}
|
|
++y_idx;
|
|
++py_idx;
|
|
} else if (epc[i].y - epc[i].x < py_idx - px_idx) {
|
|
if (reverse) {
|
|
ses[ses.length] = new seselem(a[px_idx], SES_ADD);
|
|
} else {
|
|
ses[ses.length] = new seselem(a[px_idx], SES_DELETE);
|
|
}
|
|
++x_idx;
|
|
++px_idx;
|
|
} else {
|
|
ses[ses.length] = new seselem(a[px_idx], SES_COMMON);
|
|
lcs += a[px_idx];
|
|
++x_idx;
|
|
++y_idx;
|
|
++px_idx;
|
|
++py_idx;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
init3();
|
|
return {
|
|
SES_DELETE: -1,
|
|
SES_COMMON: 0,
|
|
SES_ADD: 1,
|
|
editdistance: function() {
|
|
return ed;
|
|
},
|
|
getlcs: function() {
|
|
return lcs;
|
|
},
|
|
getses: function() {
|
|
return ses;
|
|
},
|
|
compose: function() {
|
|
var delta, size, fp, p, r, epc, i, k;
|
|
delta = n - m;
|
|
size = m + n + 3;
|
|
fp = {};
|
|
for (i = 0; i < size; ++i) {
|
|
fp[i] = -1;
|
|
path2[i] = -1;
|
|
}
|
|
p = -1;
|
|
do {
|
|
++p;
|
|
for (k = -p; k <= delta - 1; ++k) {
|
|
fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]);
|
|
}
|
|
for (k = delta + p; k >= delta + 1; --k) {
|
|
fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]);
|
|
}
|
|
fp[delta + offset] = snake(delta, fp[delta - 1 + offset] + 1, fp[delta + 1 + offset]);
|
|
} while (fp[delta + offset] !== n);
|
|
ed = delta + 2 * p;
|
|
r = path2[delta + offset];
|
|
epc = [];
|
|
while (r !== -1) {
|
|
epc[epc.length] = new P(pathposi[r].x, pathposi[r].y, null);
|
|
r = pathposi[r].k;
|
|
}
|
|
recordseq(epc);
|
|
}
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/diff3/diff3.js
|
|
var require_diff3 = __commonJS({
|
|
"node_modules/diff3/diff3.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
var onp = require_onp();
|
|
function longestCommonSubsequence(file1, file2) {
|
|
var diff2 = new onp(file1, file2);
|
|
diff2.compose();
|
|
var ses = diff2.getses();
|
|
var root;
|
|
var prev;
|
|
var file1RevIdx = file1.length - 1, file2RevIdx = file2.length - 1;
|
|
for (var i = ses.length - 1; i >= 0; --i) {
|
|
if (ses[i].t === diff2.SES_COMMON) {
|
|
if (prev) {
|
|
prev.chain = {
|
|
file1index: file1RevIdx,
|
|
file2index: file2RevIdx,
|
|
chain: null
|
|
};
|
|
prev = prev.chain;
|
|
} else {
|
|
root = {
|
|
file1index: file1RevIdx,
|
|
file2index: file2RevIdx,
|
|
chain: null
|
|
};
|
|
prev = root;
|
|
}
|
|
file1RevIdx--;
|
|
file2RevIdx--;
|
|
} else if (ses[i].t === diff2.SES_DELETE) {
|
|
file1RevIdx--;
|
|
} else if (ses[i].t === diff2.SES_ADD) {
|
|
file2RevIdx--;
|
|
}
|
|
}
|
|
var tail = {
|
|
file1index: -1,
|
|
file2index: -1,
|
|
chain: null
|
|
};
|
|
if (!prev) {
|
|
return tail;
|
|
}
|
|
prev.chain = tail;
|
|
return root;
|
|
}
|
|
function diffIndices(file1, file2) {
|
|
var result = [];
|
|
var tail1 = file1.length;
|
|
var tail2 = file2.length;
|
|
for (var candidate = longestCommonSubsequence(file1, file2); candidate !== null; candidate = candidate.chain) {
|
|
var mismatchLength1 = tail1 - candidate.file1index - 1;
|
|
var mismatchLength2 = tail2 - candidate.file2index - 1;
|
|
tail1 = candidate.file1index;
|
|
tail2 = candidate.file2index;
|
|
if (mismatchLength1 || mismatchLength2) {
|
|
result.push({
|
|
file1: [tail1 + 1, mismatchLength1],
|
|
file2: [tail2 + 1, mismatchLength2]
|
|
});
|
|
}
|
|
}
|
|
result.reverse();
|
|
return result;
|
|
}
|
|
function diff3MergeIndices(a, o, b) {
|
|
var i;
|
|
var m1 = diffIndices(o, a);
|
|
var m2 = diffIndices(o, b);
|
|
var hunks = [];
|
|
function addHunk(h, side2) {
|
|
hunks.push([h.file1[0], side2, h.file1[1], h.file2[0], h.file2[1]]);
|
|
}
|
|
for (i = 0; i < m1.length; i++) {
|
|
addHunk(m1[i], 0);
|
|
}
|
|
for (i = 0; i < m2.length; i++) {
|
|
addHunk(m2[i], 2);
|
|
}
|
|
hunks.sort(function(x, y) {
|
|
return x[0] - y[0];
|
|
});
|
|
var result = [];
|
|
var commonOffset = 0;
|
|
function copyCommon(targetOffset) {
|
|
if (targetOffset > commonOffset) {
|
|
result.push([1, commonOffset, targetOffset - commonOffset]);
|
|
commonOffset = targetOffset;
|
|
}
|
|
}
|
|
for (var hunkIndex = 0; hunkIndex < hunks.length; hunkIndex++) {
|
|
var firstHunkIndex = hunkIndex;
|
|
var hunk = hunks[hunkIndex];
|
|
var regionLhs = hunk[0];
|
|
var regionRhs = regionLhs + hunk[2];
|
|
while (hunkIndex < hunks.length - 1) {
|
|
var maybeOverlapping = hunks[hunkIndex + 1];
|
|
var maybeLhs = maybeOverlapping[0];
|
|
if (maybeLhs > regionRhs)
|
|
break;
|
|
regionRhs = Math.max(regionRhs, maybeLhs + maybeOverlapping[2]);
|
|
hunkIndex++;
|
|
}
|
|
copyCommon(regionLhs);
|
|
if (firstHunkIndex == hunkIndex) {
|
|
if (hunk[4] > 0) {
|
|
result.push([hunk[1], hunk[3], hunk[4]]);
|
|
}
|
|
} else {
|
|
var regions = {
|
|
0: [a.length, -1, o.length, -1],
|
|
2: [b.length, -1, o.length, -1]
|
|
};
|
|
for (i = firstHunkIndex; i <= hunkIndex; i++) {
|
|
hunk = hunks[i];
|
|
var side = hunk[1];
|
|
var r = regions[side];
|
|
var oLhs = hunk[0];
|
|
var oRhs = oLhs + hunk[2];
|
|
var abLhs = hunk[3];
|
|
var abRhs = abLhs + hunk[4];
|
|
r[0] = Math.min(abLhs, r[0]);
|
|
r[1] = Math.max(abRhs, r[1]);
|
|
r[2] = Math.min(oLhs, r[2]);
|
|
r[3] = Math.max(oRhs, r[3]);
|
|
}
|
|
var aLhs = regions[0][0] + (regionLhs - regions[0][2]);
|
|
var aRhs = regions[0][1] + (regionRhs - regions[0][3]);
|
|
var bLhs = regions[2][0] + (regionLhs - regions[2][2]);
|
|
var bRhs = regions[2][1] + (regionRhs - regions[2][3]);
|
|
result.push([
|
|
-1,
|
|
aLhs,
|
|
aRhs - aLhs,
|
|
regionLhs,
|
|
regionRhs - regionLhs,
|
|
bLhs,
|
|
bRhs - bLhs
|
|
]);
|
|
}
|
|
commonOffset = regionRhs;
|
|
}
|
|
copyCommon(o.length);
|
|
return result;
|
|
}
|
|
function diff3Merge2(a, o, b) {
|
|
var result = [];
|
|
var files = [a, o, b];
|
|
var indices = diff3MergeIndices(a, o, b);
|
|
var okLines = [];
|
|
function flushOk() {
|
|
if (okLines.length) {
|
|
result.push({
|
|
ok: okLines
|
|
});
|
|
}
|
|
okLines = [];
|
|
}
|
|
function pushOk(xs) {
|
|
for (var j = 0; j < xs.length; j++) {
|
|
okLines.push(xs[j]);
|
|
}
|
|
}
|
|
function isTrueConflict(rec) {
|
|
if (rec[2] != rec[6])
|
|
return true;
|
|
var aoff = rec[1];
|
|
var boff = rec[5];
|
|
for (var j = 0; j < rec[2]; j++) {
|
|
if (a[j + aoff] != b[j + boff])
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
for (var i = 0; i < indices.length; i++) {
|
|
var x = indices[i];
|
|
var side = x[0];
|
|
if (side == -1) {
|
|
if (!isTrueConflict(x)) {
|
|
pushOk(files[0].slice(x[1], x[1] + x[2]));
|
|
} else {
|
|
flushOk();
|
|
result.push({
|
|
conflict: {
|
|
a: a.slice(x[1], x[1] + x[2]),
|
|
aIndex: x[1],
|
|
o: o.slice(x[3], x[3] + x[4]),
|
|
oIndex: x[3],
|
|
b: b.slice(x[5], x[5] + x[6]),
|
|
bIndex: x[5]
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
pushOk(files[side].slice(x[1], x[1] + x[2]));
|
|
}
|
|
}
|
|
flushOk();
|
|
return result;
|
|
}
|
|
module2.exports = diff3Merge2;
|
|
}
|
|
});
|
|
|
|
// node_modules/ms/index.js
|
|
var require_ms = __commonJS({
|
|
"node_modules/ms/index.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
var s = 1e3;
|
|
var m = s * 60;
|
|
var h = m * 60;
|
|
var d = h * 24;
|
|
var w = d * 7;
|
|
var y = d * 365.25;
|
|
module2.exports = function(val, options) {
|
|
options = options || {};
|
|
var type = typeof val;
|
|
if (type === "string" && val.length > 0) {
|
|
return parse2(val);
|
|
} else if (type === "number" && isFinite(val)) {
|
|
return options.long ? fmtLong(val) : fmtShort(val);
|
|
}
|
|
throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
|
|
};
|
|
function parse2(str) {
|
|
str = String(str);
|
|
if (str.length > 100) {
|
|
return;
|
|
}
|
|
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
|
|
if (!match) {
|
|
return;
|
|
}
|
|
var n = parseFloat(match[1]);
|
|
var type = (match[2] || "ms").toLowerCase();
|
|
switch (type) {
|
|
case "years":
|
|
case "year":
|
|
case "yrs":
|
|
case "yr":
|
|
case "y":
|
|
return n * y;
|
|
case "weeks":
|
|
case "week":
|
|
case "w":
|
|
return n * w;
|
|
case "days":
|
|
case "day":
|
|
case "d":
|
|
return n * d;
|
|
case "hours":
|
|
case "hour":
|
|
case "hrs":
|
|
case "hr":
|
|
case "h":
|
|
return n * h;
|
|
case "minutes":
|
|
case "minute":
|
|
case "mins":
|
|
case "min":
|
|
case "m":
|
|
return n * m;
|
|
case "seconds":
|
|
case "second":
|
|
case "secs":
|
|
case "sec":
|
|
case "s":
|
|
return n * s;
|
|
case "milliseconds":
|
|
case "millisecond":
|
|
case "msecs":
|
|
case "msec":
|
|
case "ms":
|
|
return n;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function fmtShort(ms) {
|
|
var msAbs = Math.abs(ms);
|
|
if (msAbs >= d) {
|
|
return Math.round(ms / d) + "d";
|
|
}
|
|
if (msAbs >= h) {
|
|
return Math.round(ms / h) + "h";
|
|
}
|
|
if (msAbs >= m) {
|
|
return Math.round(ms / m) + "m";
|
|
}
|
|
if (msAbs >= s) {
|
|
return Math.round(ms / s) + "s";
|
|
}
|
|
return ms + "ms";
|
|
}
|
|
function fmtLong(ms) {
|
|
var msAbs = Math.abs(ms);
|
|
if (msAbs >= d) {
|
|
return plural(ms, msAbs, d, "day");
|
|
}
|
|
if (msAbs >= h) {
|
|
return plural(ms, msAbs, h, "hour");
|
|
}
|
|
if (msAbs >= m) {
|
|
return plural(ms, msAbs, m, "minute");
|
|
}
|
|
if (msAbs >= s) {
|
|
return plural(ms, msAbs, s, "second");
|
|
}
|
|
return ms + " ms";
|
|
}
|
|
function plural(ms, msAbs, n, name) {
|
|
var isPlural = msAbs >= n * 1.5;
|
|
return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/debug/src/common.js
|
|
var require_common2 = __commonJS({
|
|
"node_modules/debug/src/common.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
function setup(env) {
|
|
createDebug.debug = createDebug;
|
|
createDebug.default = createDebug;
|
|
createDebug.coerce = coerce;
|
|
createDebug.disable = disable;
|
|
createDebug.enable = enable;
|
|
createDebug.enabled = enabled;
|
|
createDebug.humanize = require_ms();
|
|
createDebug.destroy = destroy;
|
|
Object.keys(env).forEach((key2) => {
|
|
createDebug[key2] = env[key2];
|
|
});
|
|
createDebug.names = [];
|
|
createDebug.skips = [];
|
|
createDebug.formatters = {};
|
|
function selectColor(namespace) {
|
|
let hash2 = 0;
|
|
for (let i = 0; i < namespace.length; i++) {
|
|
hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i);
|
|
hash2 |= 0;
|
|
}
|
|
return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
|
|
}
|
|
createDebug.selectColor = selectColor;
|
|
function createDebug(namespace) {
|
|
let prevTime;
|
|
let enableOverride = null;
|
|
let namespacesCache;
|
|
let enabledCache;
|
|
function debug2(...args) {
|
|
if (!debug2.enabled) {
|
|
return;
|
|
}
|
|
const self3 = debug2;
|
|
const curr = Number(new Date());
|
|
const ms = curr - (prevTime || curr);
|
|
self3.diff = ms;
|
|
self3.prev = prevTime;
|
|
self3.curr = curr;
|
|
prevTime = curr;
|
|
args[0] = createDebug.coerce(args[0]);
|
|
if (typeof args[0] !== "string") {
|
|
args.unshift("%O");
|
|
}
|
|
let index2 = 0;
|
|
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
|
|
if (match === "%%") {
|
|
return "%";
|
|
}
|
|
index2++;
|
|
const formatter = createDebug.formatters[format];
|
|
if (typeof formatter === "function") {
|
|
const val = args[index2];
|
|
match = formatter.call(self3, val);
|
|
args.splice(index2, 1);
|
|
index2--;
|
|
}
|
|
return match;
|
|
});
|
|
createDebug.formatArgs.call(self3, args);
|
|
const logFn = self3.log || createDebug.log;
|
|
logFn.apply(self3, args);
|
|
}
|
|
debug2.namespace = namespace;
|
|
debug2.useColors = createDebug.useColors();
|
|
debug2.color = createDebug.selectColor(namespace);
|
|
debug2.extend = extend;
|
|
debug2.destroy = createDebug.destroy;
|
|
Object.defineProperty(debug2, "enabled", {
|
|
enumerable: true,
|
|
configurable: false,
|
|
get: () => {
|
|
if (enableOverride !== null) {
|
|
return enableOverride;
|
|
}
|
|
if (namespacesCache !== createDebug.namespaces) {
|
|
namespacesCache = createDebug.namespaces;
|
|
enabledCache = createDebug.enabled(namespace);
|
|
}
|
|
return enabledCache;
|
|
},
|
|
set: (v) => {
|
|
enableOverride = v;
|
|
}
|
|
});
|
|
if (typeof createDebug.init === "function") {
|
|
createDebug.init(debug2);
|
|
}
|
|
return debug2;
|
|
}
|
|
function extend(namespace, delimiter) {
|
|
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
|
|
newDebug.log = this.log;
|
|
return newDebug;
|
|
}
|
|
function enable(namespaces) {
|
|
createDebug.save(namespaces);
|
|
createDebug.namespaces = namespaces;
|
|
createDebug.names = [];
|
|
createDebug.skips = [];
|
|
let i;
|
|
const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
|
|
const len = split.length;
|
|
for (i = 0; i < len; i++) {
|
|
if (!split[i]) {
|
|
continue;
|
|
}
|
|
namespaces = split[i].replace(/\*/g, ".*?");
|
|
if (namespaces[0] === "-") {
|
|
createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
|
|
} else {
|
|
createDebug.names.push(new RegExp("^" + namespaces + "$"));
|
|
}
|
|
}
|
|
}
|
|
function disable() {
|
|
const namespaces = [
|
|
...createDebug.names.map(toNamespace),
|
|
...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
|
|
].join(",");
|
|
createDebug.enable("");
|
|
return namespaces;
|
|
}
|
|
function enabled(name) {
|
|
if (name[name.length - 1] === "*") {
|
|
return true;
|
|
}
|
|
let i;
|
|
let len;
|
|
for (i = 0, len = createDebug.skips.length; i < len; i++) {
|
|
if (createDebug.skips[i].test(name)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (i = 0, len = createDebug.names.length; i < len; i++) {
|
|
if (createDebug.names[i].test(name)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function toNamespace(regexp) {
|
|
return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
|
|
}
|
|
function coerce(val) {
|
|
if (val instanceof Error) {
|
|
return val.stack || val.message;
|
|
}
|
|
return val;
|
|
}
|
|
function destroy() {
|
|
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
|
|
}
|
|
createDebug.enable(createDebug.load());
|
|
return createDebug;
|
|
}
|
|
module2.exports = setup;
|
|
}
|
|
});
|
|
|
|
// node_modules/debug/src/browser.js
|
|
var require_browser = __commonJS({
|
|
"node_modules/debug/src/browser.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
exports.formatArgs = formatArgs;
|
|
exports.save = save;
|
|
exports.load = load;
|
|
exports.useColors = useColors;
|
|
exports.storage = localstorage();
|
|
exports.destroy = (() => {
|
|
let warned = false;
|
|
return () => {
|
|
if (!warned) {
|
|
warned = true;
|
|
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
|
|
}
|
|
};
|
|
})();
|
|
exports.colors = [
|
|
"#0000CC",
|
|
"#0000FF",
|
|
"#0033CC",
|
|
"#0033FF",
|
|
"#0066CC",
|
|
"#0066FF",
|
|
"#0099CC",
|
|
"#0099FF",
|
|
"#00CC00",
|
|
"#00CC33",
|
|
"#00CC66",
|
|
"#00CC99",
|
|
"#00CCCC",
|
|
"#00CCFF",
|
|
"#3300CC",
|
|
"#3300FF",
|
|
"#3333CC",
|
|
"#3333FF",
|
|
"#3366CC",
|
|
"#3366FF",
|
|
"#3399CC",
|
|
"#3399FF",
|
|
"#33CC00",
|
|
"#33CC33",
|
|
"#33CC66",
|
|
"#33CC99",
|
|
"#33CCCC",
|
|
"#33CCFF",
|
|
"#6600CC",
|
|
"#6600FF",
|
|
"#6633CC",
|
|
"#6633FF",
|
|
"#66CC00",
|
|
"#66CC33",
|
|
"#9900CC",
|
|
"#9900FF",
|
|
"#9933CC",
|
|
"#9933FF",
|
|
"#99CC00",
|
|
"#99CC33",
|
|
"#CC0000",
|
|
"#CC0033",
|
|
"#CC0066",
|
|
"#CC0099",
|
|
"#CC00CC",
|
|
"#CC00FF",
|
|
"#CC3300",
|
|
"#CC3333",
|
|
"#CC3366",
|
|
"#CC3399",
|
|
"#CC33CC",
|
|
"#CC33FF",
|
|
"#CC6600",
|
|
"#CC6633",
|
|
"#CC9900",
|
|
"#CC9933",
|
|
"#CCCC00",
|
|
"#CCCC33",
|
|
"#FF0000",
|
|
"#FF0033",
|
|
"#FF0066",
|
|
"#FF0099",
|
|
"#FF00CC",
|
|
"#FF00FF",
|
|
"#FF3300",
|
|
"#FF3333",
|
|
"#FF3366",
|
|
"#FF3399",
|
|
"#FF33CC",
|
|
"#FF33FF",
|
|
"#FF6600",
|
|
"#FF6633",
|
|
"#FF9900",
|
|
"#FF9933",
|
|
"#FFCC00",
|
|
"#FFCC33"
|
|
];
|
|
function useColors() {
|
|
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
|
|
return true;
|
|
}
|
|
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
|
|
return false;
|
|
}
|
|
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
|
|
}
|
|
function formatArgs(args) {
|
|
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
|
|
if (!this.useColors) {
|
|
return;
|
|
}
|
|
const c = "color: " + this.color;
|
|
args.splice(1, 0, c, "color: inherit");
|
|
let index2 = 0;
|
|
let lastC = 0;
|
|
args[0].replace(/%[a-zA-Z%]/g, (match) => {
|
|
if (match === "%%") {
|
|
return;
|
|
}
|
|
index2++;
|
|
if (match === "%c") {
|
|
lastC = index2;
|
|
}
|
|
});
|
|
args.splice(lastC, 0, c);
|
|
}
|
|
exports.log = console.debug || console.log || (() => {
|
|
});
|
|
function save(namespaces) {
|
|
try {
|
|
if (namespaces) {
|
|
exports.storage.setItem("debug", namespaces);
|
|
} else {
|
|
exports.storage.removeItem("debug");
|
|
}
|
|
} catch (error) {
|
|
}
|
|
}
|
|
function load() {
|
|
let r;
|
|
try {
|
|
r = exports.storage.getItem("debug");
|
|
} catch (error) {
|
|
}
|
|
if (!r && typeof process !== "undefined" && "env" in process) {
|
|
r = process.env.DEBUG;
|
|
}
|
|
return r;
|
|
}
|
|
function localstorage() {
|
|
try {
|
|
return localStorage;
|
|
} catch (error) {
|
|
}
|
|
}
|
|
module2.exports = require_common2()(exports);
|
|
var { formatters } = module2.exports;
|
|
formatters.j = function(v) {
|
|
try {
|
|
return JSON.stringify(v);
|
|
} catch (error) {
|
|
return "[UnexpectedJSONParseError]: " + error.message;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@kwsites/file-exists/dist/src/index.js
|
|
var require_src = __commonJS({
|
|
"node_modules/@kwsites/file-exists/dist/src/index.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
var __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var fs_1 = require("fs");
|
|
var debug_1 = __importDefault(require_browser());
|
|
var log2 = debug_1.default("@kwsites/file-exists");
|
|
function check(path2, isFile, isDirectory) {
|
|
log2(`checking %s`, path2);
|
|
try {
|
|
const stat = fs_1.statSync(path2);
|
|
if (stat.isFile() && isFile) {
|
|
log2(`[OK] path represents a file`);
|
|
return true;
|
|
}
|
|
if (stat.isDirectory() && isDirectory) {
|
|
log2(`[OK] path represents a directory`);
|
|
return true;
|
|
}
|
|
log2(`[FAIL] path represents something other than a file or directory`);
|
|
return false;
|
|
} catch (e) {
|
|
if (e.code === "ENOENT") {
|
|
log2(`[FAIL] path is not accessible: %o`, e);
|
|
return false;
|
|
}
|
|
log2(`[FATAL] %o`, e);
|
|
throw e;
|
|
}
|
|
}
|
|
function exists2(path2, type = exports.READABLE) {
|
|
return check(path2, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
|
|
}
|
|
exports.exists = exists2;
|
|
exports.FILE = 1;
|
|
exports.FOLDER = 2;
|
|
exports.READABLE = exports.FILE + exports.FOLDER;
|
|
}
|
|
});
|
|
|
|
// node_modules/@kwsites/file-exists/dist/index.js
|
|
var require_dist = __commonJS({
|
|
"node_modules/@kwsites/file-exists/dist/index.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
function __export3(m) {
|
|
for (var p in m)
|
|
if (!exports.hasOwnProperty(p))
|
|
exports[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__export3(require_src());
|
|
}
|
|
});
|
|
|
|
// node_modules/@kwsites/promise-deferred/dist/index.js
|
|
var require_dist2 = __commonJS({
|
|
"node_modules/@kwsites/promise-deferred/dist/index.js"(exports) {
|
|
init_polyfill_buffer();
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.createDeferred = exports.deferred = void 0;
|
|
function deferred2() {
|
|
let done;
|
|
let fail;
|
|
let status2 = "pending";
|
|
const promise2 = new Promise((_done, _fail) => {
|
|
done = _done;
|
|
fail = _fail;
|
|
});
|
|
return {
|
|
promise: promise2,
|
|
done(result) {
|
|
if (status2 === "pending") {
|
|
status2 = "resolved";
|
|
done(result);
|
|
}
|
|
},
|
|
fail(error) {
|
|
if (status2 === "pending") {
|
|
status2 = "rejected";
|
|
fail(error);
|
|
}
|
|
},
|
|
get fulfilled() {
|
|
return status2 !== "pending";
|
|
},
|
|
get status() {
|
|
return status2;
|
|
}
|
|
};
|
|
}
|
|
exports.deferred = deferred2;
|
|
exports.createDeferred = deferred2;
|
|
exports.default = deferred2;
|
|
}
|
|
});
|
|
|
|
// node_modules/hogan.js/lib/compiler.js
|
|
var require_compiler = __commonJS({
|
|
"node_modules/hogan.js/lib/compiler.js"(exports) {
|
|
init_polyfill_buffer();
|
|
(function(Hogan4) {
|
|
var rIsWhitespace = /\S/, rQuot = /\"/g, rNewline = /\n/g, rCr = /\r/g, rSlash = /\\/g, rLineSep = /\u2028/, rParagraphSep = /\u2029/;
|
|
Hogan4.tags = {
|
|
"#": 1,
|
|
"^": 2,
|
|
"<": 3,
|
|
"$": 4,
|
|
"/": 5,
|
|
"!": 6,
|
|
">": 7,
|
|
"=": 8,
|
|
"_v": 9,
|
|
"{": 10,
|
|
"&": 11,
|
|
"_t": 12
|
|
};
|
|
Hogan4.scan = function scan(text2, delimiters) {
|
|
var len = text2.length, IN_TEXT = 0, IN_TAG_TYPE = 1, IN_TAG = 2, state = IN_TEXT, tagType = null, tag2 = null, buf = "", tokens = [], seenTag = false, i = 0, lineStart = 0, otag = "{{", ctag = "}}";
|
|
function addBuf() {
|
|
if (buf.length > 0) {
|
|
tokens.push({ tag: "_t", text: new String(buf) });
|
|
buf = "";
|
|
}
|
|
}
|
|
function lineIsWhitespace() {
|
|
var isAllWhitespace = true;
|
|
for (var j = lineStart; j < tokens.length; j++) {
|
|
isAllWhitespace = Hogan4.tags[tokens[j].tag] < Hogan4.tags["_v"] || tokens[j].tag == "_t" && tokens[j].text.match(rIsWhitespace) === null;
|
|
if (!isAllWhitespace) {
|
|
return false;
|
|
}
|
|
}
|
|
return isAllWhitespace;
|
|
}
|
|
function filterLine(haveSeenTag, noNewLine) {
|
|
addBuf();
|
|
if (haveSeenTag && lineIsWhitespace()) {
|
|
for (var j = lineStart, next; j < tokens.length; j++) {
|
|
if (tokens[j].text) {
|
|
if ((next = tokens[j + 1]) && next.tag == ">") {
|
|
next.indent = tokens[j].text.toString();
|
|
}
|
|
tokens.splice(j, 1);
|
|
}
|
|
}
|
|
} else if (!noNewLine) {
|
|
tokens.push({ tag: "\n" });
|
|
}
|
|
seenTag = false;
|
|
lineStart = tokens.length;
|
|
}
|
|
function changeDelimiters(text3, index2) {
|
|
var close = "=" + ctag, closeIndex = text3.indexOf(close, index2), delimiters2 = trim(text3.substring(text3.indexOf("=", index2) + 1, closeIndex)).split(" ");
|
|
otag = delimiters2[0];
|
|
ctag = delimiters2[delimiters2.length - 1];
|
|
return closeIndex + close.length - 1;
|
|
}
|
|
if (delimiters) {
|
|
delimiters = delimiters.split(" ");
|
|
otag = delimiters[0];
|
|
ctag = delimiters[1];
|
|
}
|
|
for (i = 0; i < len; i++) {
|
|
if (state == IN_TEXT) {
|
|
if (tagChange(otag, text2, i)) {
|
|
--i;
|
|
addBuf();
|
|
state = IN_TAG_TYPE;
|
|
} else {
|
|
if (text2.charAt(i) == "\n") {
|
|
filterLine(seenTag);
|
|
} else {
|
|
buf += text2.charAt(i);
|
|
}
|
|
}
|
|
} else if (state == IN_TAG_TYPE) {
|
|
i += otag.length - 1;
|
|
tag2 = Hogan4.tags[text2.charAt(i + 1)];
|
|
tagType = tag2 ? text2.charAt(i + 1) : "_v";
|
|
if (tagType == "=") {
|
|
i = changeDelimiters(text2, i);
|
|
state = IN_TEXT;
|
|
} else {
|
|
if (tag2) {
|
|
i++;
|
|
}
|
|
state = IN_TAG;
|
|
}
|
|
seenTag = i;
|
|
} else {
|
|
if (tagChange(ctag, text2, i)) {
|
|
tokens.push({
|
|
tag: tagType,
|
|
n: trim(buf),
|
|
otag,
|
|
ctag,
|
|
i: tagType == "/" ? seenTag - otag.length : i + ctag.length
|
|
});
|
|
buf = "";
|
|
i += ctag.length - 1;
|
|
state = IN_TEXT;
|
|
if (tagType == "{") {
|
|
if (ctag == "}}") {
|
|
i++;
|
|
} else {
|
|
cleanTripleStache(tokens[tokens.length - 1]);
|
|
}
|
|
}
|
|
} else {
|
|
buf += text2.charAt(i);
|
|
}
|
|
}
|
|
}
|
|
filterLine(seenTag, true);
|
|
return tokens;
|
|
};
|
|
function cleanTripleStache(token) {
|
|
if (token.n.substr(token.n.length - 1) === "}") {
|
|
token.n = token.n.substring(0, token.n.length - 1);
|
|
}
|
|
}
|
|
function trim(s) {
|
|
if (s.trim) {
|
|
return s.trim();
|
|
}
|
|
return s.replace(/^\s*|\s*$/g, "");
|
|
}
|
|
function tagChange(tag2, text2, index2) {
|
|
if (text2.charAt(index2) != tag2.charAt(0)) {
|
|
return false;
|
|
}
|
|
for (var i = 1, l = tag2.length; i < l; i++) {
|
|
if (text2.charAt(index2 + i) != tag2.charAt(i)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var allowedInSuper = { "_t": true, "\n": true, "$": true, "/": true };
|
|
function buildTree(tokens, kind, stack, customTags) {
|
|
var instructions = [], opener = null, tail = null, token = null;
|
|
tail = stack[stack.length - 1];
|
|
while (tokens.length > 0) {
|
|
token = tokens.shift();
|
|
if (tail && tail.tag == "<" && !(token.tag in allowedInSuper)) {
|
|
throw new Error("Illegal content in < super tag.");
|
|
}
|
|
if (Hogan4.tags[token.tag] <= Hogan4.tags["$"] || isOpener(token, customTags)) {
|
|
stack.push(token);
|
|
token.nodes = buildTree(tokens, token.tag, stack, customTags);
|
|
} else if (token.tag == "/") {
|
|
if (stack.length === 0) {
|
|
throw new Error("Closing tag without opener: /" + token.n);
|
|
}
|
|
opener = stack.pop();
|
|
if (token.n != opener.n && !isCloser(token.n, opener.n, customTags)) {
|
|
throw new Error("Nesting error: " + opener.n + " vs. " + token.n);
|
|
}
|
|
opener.end = token.i;
|
|
return instructions;
|
|
} else if (token.tag == "\n") {
|
|
token.last = tokens.length == 0 || tokens[0].tag == "\n";
|
|
}
|
|
instructions.push(token);
|
|
}
|
|
if (stack.length > 0) {
|
|
throw new Error("missing closing tag: " + stack.pop().n);
|
|
}
|
|
return instructions;
|
|
}
|
|
function isOpener(token, tags) {
|
|
for (var i = 0, l = tags.length; i < l; i++) {
|
|
if (tags[i].o == token.n) {
|
|
token.tag = "#";
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
function isCloser(close, open, tags) {
|
|
for (var i = 0, l = tags.length; i < l; i++) {
|
|
if (tags[i].c == close && tags[i].o == open) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
function stringifySubstitutions(obj) {
|
|
var items = [];
|
|
for (var key2 in obj) {
|
|
items.push('"' + esc(key2) + '": function(c,p,t,i) {' + obj[key2] + "}");
|
|
}
|
|
return "{ " + items.join(",") + " }";
|
|
}
|
|
function stringifyPartials(codeObj) {
|
|
var partials = [];
|
|
for (var key2 in codeObj.partials) {
|
|
partials.push('"' + esc(key2) + '":{name:"' + esc(codeObj.partials[key2].name) + '", ' + stringifyPartials(codeObj.partials[key2]) + "}");
|
|
}
|
|
return "partials: {" + partials.join(",") + "}, subs: " + stringifySubstitutions(codeObj.subs);
|
|
}
|
|
Hogan4.stringify = function(codeObj, text2, options) {
|
|
return "{code: function (c,p,i) { " + Hogan4.wrapMain(codeObj.code) + " }," + stringifyPartials(codeObj) + "}";
|
|
};
|
|
var serialNo = 0;
|
|
Hogan4.generate = function(tree, text2, options) {
|
|
serialNo = 0;
|
|
var context = { code: "", subs: {}, partials: {} };
|
|
Hogan4.walk(tree, context);
|
|
if (options.asString) {
|
|
return this.stringify(context, text2, options);
|
|
}
|
|
return this.makeTemplate(context, text2, options);
|
|
};
|
|
Hogan4.wrapMain = function(code) {
|
|
return 'var t=this;t.b(i=i||"");' + code + "return t.fl();";
|
|
};
|
|
Hogan4.template = Hogan4.Template;
|
|
Hogan4.makeTemplate = function(codeObj, text2, options) {
|
|
var template = this.makePartials(codeObj);
|
|
template.code = new Function("c", "p", "i", this.wrapMain(codeObj.code));
|
|
return new this.template(template, text2, this, options);
|
|
};
|
|
Hogan4.makePartials = function(codeObj) {
|
|
var key2, template = { subs: {}, partials: codeObj.partials, name: codeObj.name };
|
|
for (key2 in template.partials) {
|
|
template.partials[key2] = this.makePartials(template.partials[key2]);
|
|
}
|
|
for (key2 in codeObj.subs) {
|
|
template.subs[key2] = new Function("c", "p", "t", "i", codeObj.subs[key2]);
|
|
}
|
|
return template;
|
|
};
|
|
function esc(s) {
|
|
return s.replace(rSlash, "\\\\").replace(rQuot, '\\"').replace(rNewline, "\\n").replace(rCr, "\\r").replace(rLineSep, "\\u2028").replace(rParagraphSep, "\\u2029");
|
|
}
|
|
function chooseMethod(s) {
|
|
return ~s.indexOf(".") ? "d" : "f";
|
|
}
|
|
function createPartial(node, context) {
|
|
var prefix = "<" + (context.prefix || "");
|
|
var sym = prefix + node.n + serialNo++;
|
|
context.partials[sym] = { name: node.n, partials: {} };
|
|
context.code += 't.b(t.rp("' + esc(sym) + '",c,p,"' + (node.indent || "") + '"));';
|
|
return sym;
|
|
}
|
|
Hogan4.codegen = {
|
|
"#": function(node, context) {
|
|
context.code += "if(t.s(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),c,p,0,' + node.i + "," + node.end + ',"' + node.otag + " " + node.ctag + '")){t.rs(c,p,function(c,p,t){';
|
|
Hogan4.walk(node.nodes, context);
|
|
context.code += "});c.pop();}";
|
|
},
|
|
"^": function(node, context) {
|
|
context.code += "if(!t.s(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),c,p,1,0,0,"")){';
|
|
Hogan4.walk(node.nodes, context);
|
|
context.code += "};";
|
|
},
|
|
">": createPartial,
|
|
"<": function(node, context) {
|
|
var ctx = { partials: {}, code: "", subs: {}, inPartial: true };
|
|
Hogan4.walk(node.nodes, ctx);
|
|
var template = context.partials[createPartial(node, context)];
|
|
template.subs = ctx.subs;
|
|
template.partials = ctx.partials;
|
|
},
|
|
"$": function(node, context) {
|
|
var ctx = { subs: {}, code: "", partials: context.partials, prefix: node.n };
|
|
Hogan4.walk(node.nodes, ctx);
|
|
context.subs[node.n] = ctx.code;
|
|
if (!context.inPartial) {
|
|
context.code += 't.sub("' + esc(node.n) + '",c,p,i);';
|
|
}
|
|
},
|
|
"\n": function(node, context) {
|
|
context.code += write('"\\n"' + (node.last ? "" : " + i"));
|
|
},
|
|
"_v": function(node, context) {
|
|
context.code += "t.b(t.v(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
|
|
},
|
|
"_t": function(node, context) {
|
|
context.code += write('"' + esc(node.text) + '"');
|
|
},
|
|
"{": tripleStache,
|
|
"&": tripleStache
|
|
};
|
|
function tripleStache(node, context) {
|
|
context.code += "t.b(t.t(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
|
|
}
|
|
function write(s) {
|
|
return "t.b(" + s + ");";
|
|
}
|
|
Hogan4.walk = function(nodelist, context) {
|
|
var func;
|
|
for (var i = 0, l = nodelist.length; i < l; i++) {
|
|
func = Hogan4.codegen[nodelist[i].tag];
|
|
func && func(nodelist[i], context);
|
|
}
|
|
return context;
|
|
};
|
|
Hogan4.parse = function(tokens, text2, options) {
|
|
options = options || {};
|
|
return buildTree(tokens, "", [], options.sectionTags || []);
|
|
};
|
|
Hogan4.cache = {};
|
|
Hogan4.cacheKey = function(text2, options) {
|
|
return [text2, !!options.asString, !!options.disableLambda, options.delimiters, !!options.modelGet].join("||");
|
|
};
|
|
Hogan4.compile = function(text2, options) {
|
|
options = options || {};
|
|
var key2 = Hogan4.cacheKey(text2, options);
|
|
var template = this.cache[key2];
|
|
if (template) {
|
|
var partials = template.partials;
|
|
for (var name in partials) {
|
|
delete partials[name].instance;
|
|
}
|
|
return template;
|
|
}
|
|
template = this.generate(this.parse(this.scan(text2, options.delimiters), text2, options), text2, options);
|
|
return this.cache[key2] = template;
|
|
};
|
|
})(typeof exports !== "undefined" ? exports : Hogan);
|
|
}
|
|
});
|
|
|
|
// node_modules/hogan.js/lib/template.js
|
|
var require_template = __commonJS({
|
|
"node_modules/hogan.js/lib/template.js"(exports) {
|
|
init_polyfill_buffer();
|
|
var Hogan4 = {};
|
|
(function(Hogan5) {
|
|
Hogan5.Template = function(codeObj, text2, compiler, options) {
|
|
codeObj = codeObj || {};
|
|
this.r = codeObj.code || this.r;
|
|
this.c = compiler;
|
|
this.options = options || {};
|
|
this.text = text2 || "";
|
|
this.partials = codeObj.partials || {};
|
|
this.subs = codeObj.subs || {};
|
|
this.buf = "";
|
|
};
|
|
Hogan5.Template.prototype = {
|
|
r: function(context, partials, indent2) {
|
|
return "";
|
|
},
|
|
v: hoganEscape,
|
|
t: coerceToString,
|
|
render: function render2(context, partials, indent2) {
|
|
return this.ri([context], partials || {}, indent2);
|
|
},
|
|
ri: function(context, partials, indent2) {
|
|
return this.r(context, partials, indent2);
|
|
},
|
|
ep: function(symbol, partials) {
|
|
var partial = this.partials[symbol];
|
|
var template = partials[partial.name];
|
|
if (partial.instance && partial.base == template) {
|
|
return partial.instance;
|
|
}
|
|
if (typeof template == "string") {
|
|
if (!this.c) {
|
|
throw new Error("No compiler available.");
|
|
}
|
|
template = this.c.compile(template, this.options);
|
|
}
|
|
if (!template) {
|
|
return null;
|
|
}
|
|
this.partials[symbol].base = template;
|
|
if (partial.subs) {
|
|
if (!partials.stackText)
|
|
partials.stackText = {};
|
|
for (key in partial.subs) {
|
|
if (!partials.stackText[key]) {
|
|
partials.stackText[key] = this.activeSub !== void 0 && partials.stackText[this.activeSub] ? partials.stackText[this.activeSub] : this.text;
|
|
}
|
|
}
|
|
template = createSpecializedPartial(template, partial.subs, partial.partials, this.stackSubs, this.stackPartials, partials.stackText);
|
|
}
|
|
this.partials[symbol].instance = template;
|
|
return template;
|
|
},
|
|
rp: function(symbol, context, partials, indent2) {
|
|
var partial = this.ep(symbol, partials);
|
|
if (!partial) {
|
|
return "";
|
|
}
|
|
return partial.ri(context, partials, indent2);
|
|
},
|
|
rs: function(context, partials, section) {
|
|
var tail = context[context.length - 1];
|
|
if (!isArray(tail)) {
|
|
section(context, partials, this);
|
|
return;
|
|
}
|
|
for (var i = 0; i < tail.length; i++) {
|
|
context.push(tail[i]);
|
|
section(context, partials, this);
|
|
context.pop();
|
|
}
|
|
},
|
|
s: function(val, ctx, partials, inverted, start, end, tags) {
|
|
var pass;
|
|
if (isArray(val) && val.length === 0) {
|
|
return false;
|
|
}
|
|
if (typeof val == "function") {
|
|
val = this.ms(val, ctx, partials, inverted, start, end, tags);
|
|
}
|
|
pass = !!val;
|
|
if (!inverted && pass && ctx) {
|
|
ctx.push(typeof val == "object" ? val : ctx[ctx.length - 1]);
|
|
}
|
|
return pass;
|
|
},
|
|
d: function(key2, ctx, partials, returnFound) {
|
|
var found, names = key2.split("."), val = this.f(names[0], ctx, partials, returnFound), doModelGet = this.options.modelGet, cx = null;
|
|
if (key2 === "." && isArray(ctx[ctx.length - 2])) {
|
|
val = ctx[ctx.length - 1];
|
|
} else {
|
|
for (var i = 1; i < names.length; i++) {
|
|
found = findInScope(names[i], val, doModelGet);
|
|
if (found !== void 0) {
|
|
cx = val;
|
|
val = found;
|
|
} else {
|
|
val = "";
|
|
}
|
|
}
|
|
}
|
|
if (returnFound && !val) {
|
|
return false;
|
|
}
|
|
if (!returnFound && typeof val == "function") {
|
|
ctx.push(cx);
|
|
val = this.mv(val, ctx, partials);
|
|
ctx.pop();
|
|
}
|
|
return val;
|
|
},
|
|
f: function(key2, ctx, partials, returnFound) {
|
|
var val = false, v = null, found = false, doModelGet = this.options.modelGet;
|
|
for (var i = ctx.length - 1; i >= 0; i--) {
|
|
v = ctx[i];
|
|
val = findInScope(key2, v, doModelGet);
|
|
if (val !== void 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
return returnFound ? false : "";
|
|
}
|
|
if (!returnFound && typeof val == "function") {
|
|
val = this.mv(val, ctx, partials);
|
|
}
|
|
return val;
|
|
},
|
|
ls: function(func, cx, partials, text2, tags) {
|
|
var oldTags = this.options.delimiters;
|
|
this.options.delimiters = tags;
|
|
this.b(this.ct(coerceToString(func.call(cx, text2)), cx, partials));
|
|
this.options.delimiters = oldTags;
|
|
return false;
|
|
},
|
|
ct: function(text2, cx, partials) {
|
|
if (this.options.disableLambda) {
|
|
throw new Error("Lambda features disabled.");
|
|
}
|
|
return this.c.compile(text2, this.options).render(cx, partials);
|
|
},
|
|
b: function(s) {
|
|
this.buf += s;
|
|
},
|
|
fl: function() {
|
|
var r = this.buf;
|
|
this.buf = "";
|
|
return r;
|
|
},
|
|
ms: function(func, ctx, partials, inverted, start, end, tags) {
|
|
var textSource, cx = ctx[ctx.length - 1], result = func.call(cx);
|
|
if (typeof result == "function") {
|
|
if (inverted) {
|
|
return true;
|
|
} else {
|
|
textSource = this.activeSub && this.subsText && this.subsText[this.activeSub] ? this.subsText[this.activeSub] : this.text;
|
|
return this.ls(result, cx, partials, textSource.substring(start, end), tags);
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
mv: function(func, ctx, partials) {
|
|
var cx = ctx[ctx.length - 1];
|
|
var result = func.call(cx);
|
|
if (typeof result == "function") {
|
|
return this.ct(coerceToString(result.call(cx)), cx, partials);
|
|
}
|
|
return result;
|
|
},
|
|
sub: function(name, context, partials, indent2) {
|
|
var f = this.subs[name];
|
|
if (f) {
|
|
this.activeSub = name;
|
|
f(context, partials, this, indent2);
|
|
this.activeSub = false;
|
|
}
|
|
}
|
|
};
|
|
function findInScope(key2, scope, doModelGet) {
|
|
var val;
|
|
if (scope && typeof scope == "object") {
|
|
if (scope[key2] !== void 0) {
|
|
val = scope[key2];
|
|
} else if (doModelGet && scope.get && typeof scope.get == "function") {
|
|
val = scope.get(key2);
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
function createSpecializedPartial(instance6, subs, partials, stackSubs, stackPartials, stackText) {
|
|
function PartialTemplate() {
|
|
}
|
|
;
|
|
PartialTemplate.prototype = instance6;
|
|
function Substitutions() {
|
|
}
|
|
;
|
|
Substitutions.prototype = instance6.subs;
|
|
var key2;
|
|
var partial = new PartialTemplate();
|
|
partial.subs = new Substitutions();
|
|
partial.subsText = {};
|
|
partial.buf = "";
|
|
stackSubs = stackSubs || {};
|
|
partial.stackSubs = stackSubs;
|
|
partial.subsText = stackText;
|
|
for (key2 in subs) {
|
|
if (!stackSubs[key2])
|
|
stackSubs[key2] = subs[key2];
|
|
}
|
|
for (key2 in stackSubs) {
|
|
partial.subs[key2] = stackSubs[key2];
|
|
}
|
|
stackPartials = stackPartials || {};
|
|
partial.stackPartials = stackPartials;
|
|
for (key2 in partials) {
|
|
if (!stackPartials[key2])
|
|
stackPartials[key2] = partials[key2];
|
|
}
|
|
for (key2 in stackPartials) {
|
|
partial.partials[key2] = stackPartials[key2];
|
|
}
|
|
return partial;
|
|
}
|
|
var rAmp = /&/g, rLt = /</g, rGt = />/g, rApos = /\'/g, rQuot = /\"/g, hChars = /[&<>\"\']/;
|
|
function coerceToString(val) {
|
|
return String(val === null || val === void 0 ? "" : val);
|
|
}
|
|
function hoganEscape(str) {
|
|
str = coerceToString(str);
|
|
return hChars.test(str) ? str.replace(rAmp, "&").replace(rLt, "<").replace(rGt, ">").replace(rApos, "'").replace(rQuot, """) : str;
|
|
}
|
|
var isArray = Array.isArray || function(a) {
|
|
return Object.prototype.toString.call(a) === "[object Array]";
|
|
};
|
|
})(typeof exports !== "undefined" ? exports : Hogan4);
|
|
}
|
|
});
|
|
|
|
// node_modules/hogan.js/lib/hogan.js
|
|
var require_hogan = __commonJS({
|
|
"node_modules/hogan.js/lib/hogan.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
var Hogan4 = require_compiler();
|
|
Hogan4.Template = require_template().Template;
|
|
Hogan4.template = Hogan4.Template;
|
|
module2.exports = Hogan4;
|
|
}
|
|
});
|
|
|
|
// node_modules/feather-icons/dist/feather.js
|
|
var require_feather = __commonJS({
|
|
"node_modules/feather-icons/dist/feather.js"(exports, module2) {
|
|
init_polyfill_buffer();
|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if (typeof exports === "object" && typeof module2 === "object")
|
|
module2.exports = factory();
|
|
else if (typeof define === "function" && define.amd)
|
|
define([], factory);
|
|
else if (typeof exports === "object")
|
|
exports["feather"] = factory();
|
|
else
|
|
root["feather"] = factory();
|
|
})(typeof self !== "undefined" ? self : exports, function() {
|
|
return function(modules) {
|
|
var installedModules = {};
|
|
function __webpack_require__(moduleId) {
|
|
if (installedModules[moduleId]) {
|
|
return installedModules[moduleId].exports;
|
|
}
|
|
var module3 = installedModules[moduleId] = {
|
|
i: moduleId,
|
|
l: false,
|
|
exports: {}
|
|
};
|
|
modules[moduleId].call(module3.exports, module3, module3.exports, __webpack_require__);
|
|
module3.l = true;
|
|
return module3.exports;
|
|
}
|
|
__webpack_require__.m = modules;
|
|
__webpack_require__.c = installedModules;
|
|
__webpack_require__.d = function(exports2, name, getter) {
|
|
if (!__webpack_require__.o(exports2, name)) {
|
|
Object.defineProperty(exports2, name, {
|
|
configurable: false,
|
|
enumerable: true,
|
|
get: getter
|
|
});
|
|
}
|
|
};
|
|
__webpack_require__.r = function(exports2) {
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
};
|
|
__webpack_require__.n = function(module3) {
|
|
var getter = module3 && module3.__esModule ? function getDefault() {
|
|
return module3["default"];
|
|
} : function getModuleExports() {
|
|
return module3;
|
|
};
|
|
__webpack_require__.d(getter, "a", getter);
|
|
return getter;
|
|
};
|
|
__webpack_require__.o = function(object, property) {
|
|
return Object.prototype.hasOwnProperty.call(object, property);
|
|
};
|
|
__webpack_require__.p = "";
|
|
return __webpack_require__(__webpack_require__.s = 0);
|
|
}({
|
|
"./dist/icons.json": function(module3) {
|
|
module3.exports = { "activity": '<polyline points="22 12 18 12 15 21 9 3 6 12 2 12"></polyline>', "airplay": '<path d="M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1"></path><polygon points="12 15 17 21 7 21 12 15"></polygon>', "alert-circle": '<circle cx="12" cy="12" r="10"></circle><line x1="12" y1="8" x2="12" y2="12"></line><line x1="12" y1="16" x2="12.01" y2="16"></line>', "alert-octagon": '<polygon points="7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2"></polygon><line x1="12" y1="8" x2="12" y2="12"></line><line x1="12" y1="16" x2="12.01" y2="16"></line>', "alert-triangle": '<path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"></path><line x1="12" y1="9" x2="12" y2="13"></line><line x1="12" y1="17" x2="12.01" y2="17"></line>', "align-center": '<line x1="18" y1="10" x2="6" y2="10"></line><line x1="21" y1="6" x2="3" y2="6"></line><line x1="21" y1="14" x2="3" y2="14"></line><line x1="18" y1="18" x2="6" y2="18"></line>', "align-justify": '<line x1="21" y1="10" x2="3" y2="10"></line><line x1="21" y1="6" x2="3" y2="6"></line><line x1="21" y1="14" x2="3" y2="14"></line><line x1="21" y1="18" x2="3" y2="18"></line>', "align-left": '<line x1="17" y1="10" x2="3" y2="10"></line><line x1="21" y1="6" x2="3" y2="6"></line><line x1="21" y1="14" x2="3" y2="14"></line><line x1="17" y1="18" x2="3" y2="18"></line>', "align-right": '<line x1="21" y1="10" x2="7" y2="10"></line><line x1="21" y1="6" x2="3" y2="6"></line><line x1="21" y1="14" x2="3" y2="14"></line><line x1="21" y1="18" x2="7" y2="18"></line>', "anchor": '<circle cx="12" cy="5" r="3"></circle><line x1="12" y1="22" x2="12" y2="8"></line><path d="M5 12H2a10 10 0 0 0 20 0h-3"></path>', "aperture": '<circle cx="12" cy="12" r="10"></circle><line x1="14.31" y1="8" x2="20.05" y2="17.94"></line><line x1="9.69" y1="8" x2="21.17" y2="8"></line><line x1="7.38" y1="12" x2="13.12" y2="2.06"></line><line x1="9.69" y1="16" x2="3.95" y2="6.06"></line><line x1="14.31" y1="16" x2="2.83" y2="16"></line><line x1="16.62" y1="12" x2="10.88" y2="21.94"></line>', "archive": '<polyline points="21 8 21 21 3 21 3 8"></polyline><rect x="1" y="3" width="22" height="5"></rect><line x1="10" y1="12" x2="14" y2="12"></line>', "arrow-down-circle": '<circle cx="12" cy="12" r="10"></circle><polyline points="8 12 12 16 16 12"></polyline><line x1="12" y1="8" x2="12" y2="16"></line>', "arrow-down-left": '<line x1="17" y1="7" x2="7" y2="17"></line><polyline points="17 17 7 17 7 7"></polyline>', "arrow-down-right": '<line x1="7" y1="7" x2="17" y2="17"></line><polyline points="17 7 17 17 7 17"></polyline>', "arrow-down": '<line x1="12" y1="5" x2="12" y2="19"></line><polyline points="19 12 12 19 5 12"></polyline>', "arrow-left-circle": '<circle cx="12" cy="12" r="10"></circle><polyline points="12 8 8 12 12 16"></polyline><line x1="16" y1="12" x2="8" y2="12"></line>', "arrow-left": '<line x1="19" y1="12" x2="5" y2="12"></line><polyline points="12 19 5 12 12 5"></polyline>', "arrow-right-circle": '<circle cx="12" cy="12" r="10"></circle><polyline points="12 16 16 12 12 8"></polyline><line x1="8" y1="12" x2="16" y2="12"></line>', "arrow-right": '<line x1="5" y1="12" x2="19" y2="12"></line><polyline points="12 5 19 12 12 19"></polyline>', "arrow-up-circle": '<circle cx="12" cy="12" r="10"></circle><polyline points="16 12 12 8 8 12"></polyline><line x1="12" y1="16" x2="12" y2="8"></line>', "arrow-up-left": '<line x1="17" y1="17" x2="7" y2="7"></line><polyline points="7 17 7 7 17 7"></polyline>', "arrow-up-right": '<line x1="7" y1="17" x2="17" y2="7"></line><polyline points="7 7 17 7 17 17"></polyline>', "arrow-up": '<line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline>', "at-sign": '<circle cx="12" cy="12" r="4"></circle><path d="M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-3.92 7.94"></path>', "award": '<circle cx="12" cy="8" r="7"></circle><polyline points="8.21 13.89 7 23 12 20 17 23 15.79 13.88"></polyline>', "bar-chart-2": '<line x1="18" y1="20" x2="18" y2="10"></line><line x1="12" y1="20" x2="12" y2="4"></line><line x1="6" y1="20" x2="6" y2="14"></line>', "bar-chart": '<line x1="12" y1="20" x2="12" y2="10"></line><line x1="18" y1="20" x2="18" y2="4"></line><line x1="6" y1="20" x2="6" y2="16"></line>', "battery-charging": '<path d="M5 18H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3.19M15 6h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-3.19"></path><line x1="23" y1="13" x2="23" y2="11"></line><polyline points="11 6 7 12 13 12 9 18"></polyline>', "battery": '<rect x="1" y="6" width="18" height="12" rx="2" ry="2"></rect><line x1="23" y1="13" x2="23" y2="11"></line>', "bell-off": '<path d="M13.73 21a2 2 0 0 1-3.46 0"></path><path d="M18.63 13A17.89 17.89 0 0 1 18 8"></path><path d="M6.26 6.26A5.86 5.86 0 0 0 6 8c0 7-3 9-3 9h14"></path><path d="M18 8a6 6 0 0 0-9.33-5"></path><line x1="1" y1="1" x2="23" y2="23"></line>', "bell": '<path d="M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9"></path><path d="M13.73 21a2 2 0 0 1-3.46 0"></path>', "bluetooth": '<polyline points="6.5 6.5 17.5 17.5 12 23 12 1 17.5 6.5 6.5 17.5"></polyline>', "bold": '<path d="M6 4h8a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z"></path><path d="M6 12h9a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z"></path>', "book-open": '<path d="M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"></path><path d="M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"></path>', "book": '<path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"></path><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"></path>', "bookmark": '<path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"></path>', "box": '<path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"></path><polyline points="3.27 6.96 12 12.01 20.73 6.96"></polyline><line x1="12" y1="22.08" x2="12" y2="12"></line>', "briefcase": '<rect x="2" y="7" width="20" height="14" rx="2" ry="2"></rect><path d="M16 21V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16"></path>', "calendar": '<rect x="3" y="4" width="18" height="18" rx="2" ry="2"></rect><line x1="16" y1="2" x2="16" y2="6"></line><line x1="8" y1="2" x2="8" y2="6"></line><line x1="3" y1="10" x2="21" y2="10"></line>', "camera-off": '<line x1="1" y1="1" x2="23" y2="23"></line><path d="M21 21H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3m3-3h6l2 3h4a2 2 0 0 1 2 2v9.34m-7.72-2.06a4 4 0 1 1-5.56-5.56"></path>', "camera": '<path d="M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z"></path><circle cx="12" cy="13" r="4"></circle>', "cast": '<path d="M2 16.1A5 5 0 0 1 5.9 20M2 12.05A9 9 0 0 1 9.95 20M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6"></path><line x1="2" y1="20" x2="2.01" y2="20"></line>', "check-circle": '<path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"></path><polyline points="22 4 12 14.01 9 11.01"></polyline>', "check-square": '<polyline points="9 11 12 14 22 4"></polyline><path d="M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"></path>', "check": '<polyline points="20 6 9 17 4 12"></polyline>', "chevron-down": '<polyline points="6 9 12 15 18 9"></polyline>', "chevron-left": '<polyline points="15 18 9 12 15 6"></polyline>', "chevron-right": '<polyline points="9 18 15 12 9 6"></polyline>', "chevron-up": '<polyline points="18 15 12 9 6 15"></polyline>', "chevrons-down": '<polyline points="7 13 12 18 17 13"></polyline><polyline points="7 6 12 11 17 6"></polyline>', "chevrons-left": '<polyline points="11 17 6 12 11 7"></polyline><polyline points="18 17 13 12 18 7"></polyline>', "chevrons-right": '<polyline points="13 17 18 12 13 7"></polyline><polyline points="6 17 11 12 6 7"></polyline>', "chevrons-up": '<polyline points="17 11 12 6 7 11"></polyline><polyline points="17 18 12 13 7 18"></polyline>', "chrome": '<circle cx="12" cy="12" r="10"></circle><circle cx="12" cy="12" r="4"></circle><line x1="21.17" y1="8" x2="12" y2="8"></line><line x1="3.95" y1="6.06" x2="8.54" y2="14"></line><line x1="10.88" y1="21.94" x2="15.46" y2="14"></line>', "circle": '<circle cx="12" cy="12" r="10"></circle>', "clipboard": '<path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path><rect x="8" y="2" width="8" height="4" rx="1" ry="1"></rect>', "clock": '<circle cx="12" cy="12" r="10"></circle><polyline points="12 6 12 12 16 14"></polyline>', "cloud-drizzle": '<line x1="8" y1="19" x2="8" y2="21"></line><line x1="8" y1="13" x2="8" y2="15"></line><line x1="16" y1="19" x2="16" y2="21"></line><line x1="16" y1="13" x2="16" y2="15"></line><line x1="12" y1="21" x2="12" y2="23"></line><line x1="12" y1="15" x2="12" y2="17"></line><path d="M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25"></path>', "cloud-lightning": '<path d="M19 16.9A5 5 0 0 0 18 7h-1.26a8 8 0 1 0-11.62 9"></path><polyline points="13 11 9 17 15 17 11 23"></polyline>', "cloud-off": '<path d="M22.61 16.95A5 5 0 0 0 18 10h-1.26a8 8 0 0 0-7.05-6M5 5a8 8 0 0 0 4 15h9a5 5 0 0 0 1.7-.3"></path><line x1="1" y1="1" x2="23" y2="23"></line>', "cloud-rain": '<line x1="16" y1="13" x2="16" y2="21"></line><line x1="8" y1="13" x2="8" y2="21"></line><line x1="12" y1="15" x2="12" y2="23"></line><path d="M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25"></path>', "cloud-snow": '<path d="M20 17.58A5 5 0 0 0 18 8h-1.26A8 8 0 1 0 4 16.25"></path><line x1="8" y1="16" x2="8.01" y2="16"></line><line x1="8" y1="20" x2="8.01" y2="20"></line><line x1="12" y1="18" x2="12.01" y2="18"></line><line x1="12" y1="22" x2="12.01" y2="22"></line><line x1="16" y1="16" x2="16.01" y2="16"></line><line x1="16" y1="20" x2="16.01" y2="20"></line>', "cloud": '<path d="M18 10h-1.26A8 8 0 1 0 9 20h9a5 5 0 0 0 0-10z"></path>', "code": '<polyline points="16 18 22 12 16 6"></polyline><polyline points="8 6 2 12 8 18"></polyline>', "codepen": '<polygon points="12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2"></polygon><line x1="12" y1="22" x2="12" y2="15.5"></line><polyline points="22 8.5 12 15.5 2 8.5"></polyline><polyline points="2 15.5 12 8.5 22 15.5"></polyline><line x1="12" y1="2" x2="12" y2="8.5"></line>', "codesandbox": '<path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"></path><polyline points="7.5 4.21 12 6.81 16.5 4.21"></polyline><polyline points="7.5 19.79 7.5 14.6 3 12"></polyline><polyline points="21 12 16.5 14.6 16.5 19.79"></polyline><polyline points="3.27 6.96 12 12.01 20.73 6.96"></polyline><line x1="12" y1="22.08" x2="12" y2="12"></line>', "coffee": '<path d="M18 8h1a4 4 0 0 1 0 8h-1"></path><path d="M2 8h16v9a4 4 0 0 1-4 4H6a4 4 0 0 1-4-4V8z"></path><line x1="6" y1="1" x2="6" y2="4"></line><line x1="10" y1="1" x2="10" y2="4"></line><line x1="14" y1="1" x2="14" y2="4"></line>', "columns": '<path d="M12 3h7a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-7m0-18H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7m0-18v18"></path>', "command": '<path d="M18 3a3 3 0 0 0-3 3v12a3 3 0 0 0 3 3 3 3 0 0 0 3-3 3 3 0 0 0-3-3H6a3 3 0 0 0-3 3 3 3 0 0 0 3 3 3 3 0 0 0 3-3V6a3 3 0 0 0-3-3 3 3 0 0 0-3 3 3 3 0 0 0 3 3h12a3 3 0 0 0 3-3 3 3 0 0 0-3-3z"></path>', "compass": '<circle cx="12" cy="12" r="10"></circle><polygon points="16.24 7.76 14.12 14.12 7.76 16.24 9.88 9.88 16.24 7.76"></polygon>', "copy": '<rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>', "corner-down-left": '<polyline points="9 10 4 15 9 20"></polyline><path d="M20 4v7a4 4 0 0 1-4 4H4"></path>', "corner-down-right": '<polyline points="15 10 20 15 15 20"></polyline><path d="M4 4v7a4 4 0 0 0 4 4h12"></path>', "corner-left-down": '<polyline points="14 15 9 20 4 15"></polyline><path d="M20 4h-7a4 4 0 0 0-4 4v12"></path>', "corner-left-up": '<polyline points="14 9 9 4 4 9"></polyline><path d="M20 20h-7a4 4 0 0 1-4-4V4"></path>', "corner-right-down": '<polyline points="10 15 15 20 20 15"></polyline><path d="M4 4h7a4 4 0 0 1 4 4v12"></path>', "corner-right-up": '<polyline points="10 9 15 4 20 9"></polyline><path d="M4 20h7a4 4 0 0 0 4-4V4"></path>', "corner-up-left": '<polyline points="9 14 4 9 9 4"></polyline><path d="M20 20v-7a4 4 0 0 0-4-4H4"></path>', "corner-up-right": '<polyline points="15 14 20 9 15 4"></polyline><path d="M4 20v-7a4 4 0 0 1 4-4h12"></path>', "cpu": '<rect x="4" y="4" width="16" height="16" rx="2" ry="2"></rect><rect x="9" y="9" width="6" height="6"></rect><line x1="9" y1="1" x2="9" y2="4"></line><line x1="15" y1="1" x2="15" y2="4"></line><line x1="9" y1="20" x2="9" y2="23"></line><line x1="15" y1="20" x2="15" y2="23"></line><line x1="20" y1="9" x2="23" y2="9"></line><line x1="20" y1="14" x2="23" y2="14"></line><line x1="1" y1="9" x2="4" y2="9"></line><line x1="1" y1="14" x2="4" y2="14"></line>', "credit-card": '<rect x="1" y="4" width="22" height="16" rx="2" ry="2"></rect><line x1="1" y1="10" x2="23" y2="10"></line>', "crop": '<path d="M6.13 1L6 16a2 2 0 0 0 2 2h15"></path><path d="M1 6.13L16 6a2 2 0 0 1 2 2v15"></path>', "crosshair": '<circle cx="12" cy="12" r="10"></circle><line x1="22" y1="12" x2="18" y2="12"></line><line x1="6" y1="12" x2="2" y2="12"></line><line x1="12" y1="6" x2="12" y2="2"></line><line x1="12" y1="22" x2="12" y2="18"></line>', "database": '<ellipse cx="12" cy="5" rx="9" ry="3"></ellipse><path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path><path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path>', "delete": '<path d="M21 4H8l-7 8 7 8h13a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2z"></path><line x1="18" y1="9" x2="12" y2="15"></line><line x1="12" y1="9" x2="18" y2="15"></line>', "disc": '<circle cx="12" cy="12" r="10"></circle><circle cx="12" cy="12" r="3"></circle>', "divide-circle": '<line x1="8" y1="12" x2="16" y2="12"></line><line x1="12" y1="16" x2="12" y2="16"></line><line x1="12" y1="8" x2="12" y2="8"></line><circle cx="12" cy="12" r="10"></circle>', "divide-square": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><line x1="8" y1="12" x2="16" y2="12"></line><line x1="12" y1="16" x2="12" y2="16"></line><line x1="12" y1="8" x2="12" y2="8"></line>', "divide": '<circle cx="12" cy="6" r="2"></circle><line x1="5" y1="12" x2="19" y2="12"></line><circle cx="12" cy="18" r="2"></circle>', "dollar-sign": '<line x1="12" y1="1" x2="12" y2="23"></line><path d="M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"></path>', "download-cloud": '<polyline points="8 17 12 21 16 17"></polyline><line x1="12" y1="12" x2="12" y2="21"></line><path d="M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29"></path>', "download": '<path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="7 10 12 15 17 10"></polyline><line x1="12" y1="15" x2="12" y2="3"></line>', "dribbble": '<circle cx="12" cy="12" r="10"></circle><path d="M8.56 2.75c4.37 6.03 6.02 9.42 8.03 17.72m2.54-15.38c-3.72 4.35-8.94 5.66-16.88 5.85m19.5 1.9c-3.5-.93-6.63-.82-8.94 0-2.58.92-5.01 2.86-7.44 6.32"></path>', "droplet": '<path d="M12 2.69l5.66 5.66a8 8 0 1 1-11.31 0z"></path>', "edit-2": '<path d="M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z"></path>', "edit-3": '<path d="M12 20h9"></path><path d="M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4L16.5 3.5z"></path>', "edit": '<path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"></path>', "external-link": '<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line>', "eye-off": '<path d="M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24"></path><line x1="1" y1="1" x2="23" y2="23"></line>', "eye": '<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"></path><circle cx="12" cy="12" r="3"></circle>', "facebook": '<path d="M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z"></path>', "fast-forward": '<polygon points="13 19 22 12 13 5 13 19"></polygon><polygon points="2 19 11 12 2 5 2 19"></polygon>', "feather": '<path d="M20.24 12.24a6 6 0 0 0-8.49-8.49L5 10.5V19h8.5z"></path><line x1="16" y1="8" x2="2" y2="22"></line><line x1="17.5" y1="15" x2="9" y2="15"></line>', "figma": '<path d="M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z"></path><path d="M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z"></path><path d="M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z"></path><path d="M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z"></path><path d="M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z"></path>', "file-minus": '<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline><line x1="9" y1="15" x2="15" y2="15"></line>', "file-plus": '<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline><line x1="12" y1="18" x2="12" y2="12"></line><line x1="9" y1="15" x2="15" y2="15"></line>', "file-text": '<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline><line x1="16" y1="13" x2="8" y2="13"></line><line x1="16" y1="17" x2="8" y2="17"></line><polyline points="10 9 9 9 8 9"></polyline>', "file": '<path d="M13 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z"></path><polyline points="13 2 13 9 20 9"></polyline>', "film": '<rect x="2" y="2" width="20" height="20" rx="2.18" ry="2.18"></rect><line x1="7" y1="2" x2="7" y2="22"></line><line x1="17" y1="2" x2="17" y2="22"></line><line x1="2" y1="12" x2="22" y2="12"></line><line x1="2" y1="7" x2="7" y2="7"></line><line x1="2" y1="17" x2="7" y2="17"></line><line x1="17" y1="17" x2="22" y2="17"></line><line x1="17" y1="7" x2="22" y2="7"></line>', "filter": '<polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon>', "flag": '<path d="M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z"></path><line x1="4" y1="22" x2="4" y2="15"></line>', "folder-minus": '<path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path><line x1="9" y1="14" x2="15" y2="14"></line>', "folder-plus": '<path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path><line x1="12" y1="11" x2="12" y2="17"></line><line x1="9" y1="14" x2="15" y2="14"></line>', "folder": '<path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path>', "framer": '<path d="M5 16V9h14V2H5l14 14h-7m-7 0l7 7v-7m-7 0h7"></path>', "frown": '<circle cx="12" cy="12" r="10"></circle><path d="M16 16s-1.5-2-4-2-4 2-4 2"></path><line x1="9" y1="9" x2="9.01" y2="9"></line><line x1="15" y1="9" x2="15.01" y2="9"></line>', "gift": '<polyline points="20 12 20 22 4 22 4 12"></polyline><rect x="2" y="7" width="20" height="5"></rect><line x1="12" y1="22" x2="12" y2="7"></line><path d="M12 7H7.5a2.5 2.5 0 0 1 0-5C11 2 12 7 12 7z"></path><path d="M12 7h4.5a2.5 2.5 0 0 0 0-5C13 2 12 7 12 7z"></path>', "git-branch": '<line x1="6" y1="3" x2="6" y2="15"></line><circle cx="18" cy="6" r="3"></circle><circle cx="6" cy="18" r="3"></circle><path d="M18 9a9 9 0 0 1-9 9"></path>', "git-commit": '<circle cx="12" cy="12" r="4"></circle><line x1="1.05" y1="12" x2="7" y2="12"></line><line x1="17.01" y1="12" x2="22.96" y2="12"></line>', "git-merge": '<circle cx="18" cy="18" r="3"></circle><circle cx="6" cy="6" r="3"></circle><path d="M6 21V9a9 9 0 0 0 9 9"></path>', "git-pull-request": '<circle cx="18" cy="18" r="3"></circle><circle cx="6" cy="6" r="3"></circle><path d="M13 6h3a2 2 0 0 1 2 2v7"></path><line x1="6" y1="9" x2="6" y2="21"></line>', "github": '<path d="M9 19c-5 1.5-5-2.5-7-3m14 6v-3.87a3.37 3.37 0 0 0-.94-2.61c3.14-.35 6.44-1.54 6.44-7A5.44 5.44 0 0 0 20 4.77 5.07 5.07 0 0 0 19.91 1S18.73.65 16 2.48a13.38 13.38 0 0 0-7 0C6.27.65 5.09 1 5.09 1A5.07 5.07 0 0 0 5 4.77a5.44 5.44 0 0 0-1.5 3.78c0 5.42 3.3 6.61 6.44 7A3.37 3.37 0 0 0 9 18.13V22"></path>', "gitlab": '<path d="M22.65 14.39L12 22.13 1.35 14.39a.84.84 0 0 1-.3-.94l1.22-3.78 2.44-7.51A.42.42 0 0 1 4.82 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.49h8.1l2.44-7.51A.42.42 0 0 1 18.6 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.51L23 13.45a.84.84 0 0 1-.35.94z"></path>', "globe": '<circle cx="12" cy="12" r="10"></circle><line x1="2" y1="12" x2="22" y2="12"></line><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"></path>', "grid": '<rect x="3" y="3" width="7" height="7"></rect><rect x="14" y="3" width="7" height="7"></rect><rect x="14" y="14" width="7" height="7"></rect><rect x="3" y="14" width="7" height="7"></rect>', "hard-drive": '<line x1="22" y1="12" x2="2" y2="12"></line><path d="M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"></path><line x1="6" y1="16" x2="6.01" y2="16"></line><line x1="10" y1="16" x2="10.01" y2="16"></line>', "hash": '<line x1="4" y1="9" x2="20" y2="9"></line><line x1="4" y1="15" x2="20" y2="15"></line><line x1="10" y1="3" x2="8" y2="21"></line><line x1="16" y1="3" x2="14" y2="21"></line>', "headphones": '<path d="M3 18v-6a9 9 0 0 1 18 0v6"></path><path d="M21 19a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3zM3 19a2 2 0 0 0 2 2h1a2 2 0 0 0 2-2v-3a2 2 0 0 0-2-2H3z"></path>', "heart": '<path d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z"></path>', "help-circle": '<circle cx="12" cy="12" r="10"></circle><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"></path><line x1="12" y1="17" x2="12.01" y2="17"></line>', "hexagon": '<path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"></path>', "home": '<path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path><polyline points="9 22 9 12 15 12 15 22"></polyline>', "image": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline>', "inbox": '<polyline points="22 12 16 12 14 15 10 15 8 12 2 12"></polyline><path d="M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"></path>', "info": '<circle cx="12" cy="12" r="10"></circle><line x1="12" y1="16" x2="12" y2="12"></line><line x1="12" y1="8" x2="12.01" y2="8"></line>', "instagram": '<rect x="2" y="2" width="20" height="20" rx="5" ry="5"></rect><path d="M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z"></path><line x1="17.5" y1="6.5" x2="17.51" y2="6.5"></line>', "italic": '<line x1="19" y1="4" x2="10" y2="4"></line><line x1="14" y1="20" x2="5" y2="20"></line><line x1="15" y1="4" x2="9" y2="20"></line>', "key": '<path d="M21 2l-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0l3 3L22 7l-3-3m-3.5 3.5L19 4"></path>', "layers": '<polygon points="12 2 2 7 12 12 22 7 12 2"></polygon><polyline points="2 17 12 22 22 17"></polyline><polyline points="2 12 12 17 22 12"></polyline>', "layout": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><line x1="3" y1="9" x2="21" y2="9"></line><line x1="9" y1="21" x2="9" y2="9"></line>', "life-buoy": '<circle cx="12" cy="12" r="10"></circle><circle cx="12" cy="12" r="4"></circle><line x1="4.93" y1="4.93" x2="9.17" y2="9.17"></line><line x1="14.83" y1="14.83" x2="19.07" y2="19.07"></line><line x1="14.83" y1="9.17" x2="19.07" y2="4.93"></line><line x1="14.83" y1="9.17" x2="18.36" y2="5.64"></line><line x1="4.93" y1="19.07" x2="9.17" y2="14.83"></line>', "link-2": '<path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path><line x1="8" y1="12" x2="16" y2="12"></line>', "link": '<path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"></path><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"></path>', "linkedin": '<path d="M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z"></path><rect x="2" y="9" width="4" height="12"></rect><circle cx="4" cy="4" r="2"></circle>', "list": '<line x1="8" y1="6" x2="21" y2="6"></line><line x1="8" y1="12" x2="21" y2="12"></line><line x1="8" y1="18" x2="21" y2="18"></line><line x1="3" y1="6" x2="3.01" y2="6"></line><line x1="3" y1="12" x2="3.01" y2="12"></line><line x1="3" y1="18" x2="3.01" y2="18"></line>', "loader": '<line x1="12" y1="2" x2="12" y2="6"></line><line x1="12" y1="18" x2="12" y2="22"></line><line x1="4.93" y1="4.93" x2="7.76" y2="7.76"></line><line x1="16.24" y1="16.24" x2="19.07" y2="19.07"></line><line x1="2" y1="12" x2="6" y2="12"></line><line x1="18" y1="12" x2="22" y2="12"></line><line x1="4.93" y1="19.07" x2="7.76" y2="16.24"></line><line x1="16.24" y1="7.76" x2="19.07" y2="4.93"></line>', "lock": '<rect x="3" y="11" width="18" height="11" rx="2" ry="2"></rect><path d="M7 11V7a5 5 0 0 1 10 0v4"></path>', "log-in": '<path d="M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4"></path><polyline points="10 17 15 12 10 7"></polyline><line x1="15" y1="12" x2="3" y2="12"></line>', "log-out": '<path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4"></path><polyline points="16 17 21 12 16 7"></polyline><line x1="21" y1="12" x2="9" y2="12"></line>', "mail": '<path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"></path><polyline points="22,6 12,13 2,6"></polyline>', "map-pin": '<path d="M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z"></path><circle cx="12" cy="10" r="3"></circle>', "map": '<polygon points="1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6"></polygon><line x1="8" y1="2" x2="8" y2="18"></line><line x1="16" y1="6" x2="16" y2="22"></line>', "maximize-2": '<polyline points="15 3 21 3 21 9"></polyline><polyline points="9 21 3 21 3 15"></polyline><line x1="21" y1="3" x2="14" y2="10"></line><line x1="3" y1="21" x2="10" y2="14"></line>', "maximize": '<path d="M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3"></path>', "meh": '<circle cx="12" cy="12" r="10"></circle><line x1="8" y1="15" x2="16" y2="15"></line><line x1="9" y1="9" x2="9.01" y2="9"></line><line x1="15" y1="9" x2="15.01" y2="9"></line>', "menu": '<line x1="3" y1="12" x2="21" y2="12"></line><line x1="3" y1="6" x2="21" y2="6"></line><line x1="3" y1="18" x2="21" y2="18"></line>', "message-circle": '<path d="M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z"></path>', "message-square": '<path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>', "mic-off": '<line x1="1" y1="1" x2="23" y2="23"></line><path d="M9 9v3a3 3 0 0 0 5.12 2.12M15 9.34V4a3 3 0 0 0-5.94-.6"></path><path d="M17 16.95A7 7 0 0 1 5 12v-2m14 0v2a7 7 0 0 1-.11 1.23"></path><line x1="12" y1="19" x2="12" y2="23"></line><line x1="8" y1="23" x2="16" y2="23"></line>', "mic": '<path d="M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z"></path><path d="M19 10v2a7 7 0 0 1-14 0v-2"></path><line x1="12" y1="19" x2="12" y2="23"></line><line x1="8" y1="23" x2="16" y2="23"></line>', "minimize-2": '<polyline points="4 14 10 14 10 20"></polyline><polyline points="20 10 14 10 14 4"></polyline><line x1="14" y1="10" x2="21" y2="3"></line><line x1="3" y1="21" x2="10" y2="14"></line>', "minimize": '<path d="M8 3v3a2 2 0 0 1-2 2H3m18 0h-3a2 2 0 0 1-2-2V3m0 18v-3a2 2 0 0 1 2-2h3M3 16h3a2 2 0 0 1 2 2v3"></path>', "minus-circle": '<circle cx="12" cy="12" r="10"></circle><line x1="8" y1="12" x2="16" y2="12"></line>', "minus-square": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><line x1="8" y1="12" x2="16" y2="12"></line>', "minus": '<line x1="5" y1="12" x2="19" y2="12"></line>', "monitor": '<rect x="2" y="3" width="20" height="14" rx="2" ry="2"></rect><line x1="8" y1="21" x2="16" y2="21"></line><line x1="12" y1="17" x2="12" y2="21"></line>', "moon": '<path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"></path>', "more-horizontal": '<circle cx="12" cy="12" r="1"></circle><circle cx="19" cy="12" r="1"></circle><circle cx="5" cy="12" r="1"></circle>', "more-vertical": '<circle cx="12" cy="12" r="1"></circle><circle cx="12" cy="5" r="1"></circle><circle cx="12" cy="19" r="1"></circle>', "mouse-pointer": '<path d="M3 3l7.07 16.97 2.51-7.39 7.39-2.51L3 3z"></path><path d="M13 13l6 6"></path>', "move": '<polyline points="5 9 2 12 5 15"></polyline><polyline points="9 5 12 2 15 5"></polyline><polyline points="15 19 12 22 9 19"></polyline><polyline points="19 9 22 12 19 15"></polyline><line x1="2" y1="12" x2="22" y2="12"></line><line x1="12" y1="2" x2="12" y2="22"></line>', "music": '<path d="M9 18V5l12-2v13"></path><circle cx="6" cy="18" r="3"></circle><circle cx="18" cy="16" r="3"></circle>', "navigation-2": '<polygon points="12 2 19 21 12 17 5 21 12 2"></polygon>', "navigation": '<polygon points="3 11 22 2 13 21 11 13 3 11"></polygon>', "octagon": '<polygon points="7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2"></polygon>', "package": '<line x1="16.5" y1="9.4" x2="7.5" y2="4.21"></line><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"></path><polyline points="3.27 6.96 12 12.01 20.73 6.96"></polyline><line x1="12" y1="22.08" x2="12" y2="12"></line>', "paperclip": '<path d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"></path>', "pause-circle": '<circle cx="12" cy="12" r="10"></circle><line x1="10" y1="15" x2="10" y2="9"></line><line x1="14" y1="15" x2="14" y2="9"></line>', "pause": '<rect x="6" y="4" width="4" height="16"></rect><rect x="14" y="4" width="4" height="16"></rect>', "pen-tool": '<path d="M12 19l7-7 3 3-7 7-3-3z"></path><path d="M18 13l-1.5-7.5L2 2l3.5 14.5L13 18l5-5z"></path><path d="M2 2l7.586 7.586"></path><circle cx="11" cy="11" r="2"></circle>', "percent": '<line x1="19" y1="5" x2="5" y2="19"></line><circle cx="6.5" cy="6.5" r="2.5"></circle><circle cx="17.5" cy="17.5" r="2.5"></circle>', "phone-call": '<path d="M15.05 5A5 5 0 0 1 19 8.95M15.05 1A9 9 0 0 1 23 8.94m-1 7.98v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>', "phone-forwarded": '<polyline points="19 1 23 5 19 9"></polyline><line x1="15" y1="5" x2="23" y2="5"></line><path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>', "phone-incoming": '<polyline points="16 2 16 8 22 8"></polyline><line x1="23" y1="1" x2="16" y2="8"></line><path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>', "phone-missed": '<line x1="23" y1="1" x2="17" y2="7"></line><line x1="17" y1="1" x2="23" y2="7"></line><path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>', "phone-off": '<path d="M10.68 13.31a16 16 0 0 0 3.41 2.6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7 2 2 0 0 1 1.72 2v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.42 19.42 0 0 1-3.33-2.67m-2.67-3.34a19.79 19.79 0 0 1-3.07-8.63A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91"></path><line x1="23" y1="1" x2="1" y2="23"></line>', "phone-outgoing": '<polyline points="23 7 23 1 17 1"></polyline><line x1="16" y1="8" x2="23" y2="1"></line><path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>', "phone": '<path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>', "pie-chart": '<path d="M21.21 15.89A10 10 0 1 1 8 2.83"></path><path d="M22 12A10 10 0 0 0 12 2v10z"></path>', "play-circle": '<circle cx="12" cy="12" r="10"></circle><polygon points="10 8 16 12 10 16 10 8"></polygon>', "play": '<polygon points="5 3 19 12 5 21 5 3"></polygon>', "plus-circle": '<circle cx="12" cy="12" r="10"></circle><line x1="12" y1="8" x2="12" y2="16"></line><line x1="8" y1="12" x2="16" y2="12"></line>', "plus-square": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><line x1="12" y1="8" x2="12" y2="16"></line><line x1="8" y1="12" x2="16" y2="12"></line>', "plus": '<line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line>', "pocket": '<path d="M4 3h16a2 2 0 0 1 2 2v6a10 10 0 0 1-10 10A10 10 0 0 1 2 11V5a2 2 0 0 1 2-2z"></path><polyline points="8 10 12 14 16 10"></polyline>', "power": '<path d="M18.36 6.64a9 9 0 1 1-12.73 0"></path><line x1="12" y1="2" x2="12" y2="12"></line>', "printer": '<polyline points="6 9 6 2 18 2 18 9"></polyline><path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"></path><rect x="6" y="14" width="12" height="8"></rect>', "radio": '<circle cx="12" cy="12" r="2"></circle><path d="M16.24 7.76a6 6 0 0 1 0 8.49m-8.48-.01a6 6 0 0 1 0-8.49m11.31-2.82a10 10 0 0 1 0 14.14m-14.14 0a10 10 0 0 1 0-14.14"></path>', "refresh-ccw": '<polyline points="1 4 1 10 7 10"></polyline><polyline points="23 20 23 14 17 14"></polyline><path d="M20.49 9A9 9 0 0 0 5.64 5.64L1 10m22 4l-4.64 4.36A9 9 0 0 1 3.51 15"></path>', "refresh-cw": '<polyline points="23 4 23 10 17 10"></polyline><polyline points="1 20 1 14 7 14"></polyline><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path>', "repeat": '<polyline points="17 1 21 5 17 9"></polyline><path d="M3 11V9a4 4 0 0 1 4-4h14"></path><polyline points="7 23 3 19 7 15"></polyline><path d="M21 13v2a4 4 0 0 1-4 4H3"></path>', "rewind": '<polygon points="11 19 2 12 11 5 11 19"></polygon><polygon points="22 19 13 12 22 5 22 19"></polygon>', "rotate-ccw": '<polyline points="1 4 1 10 7 10"></polyline><path d="M3.51 15a9 9 0 1 0 2.13-9.36L1 10"></path>', "rotate-cw": '<polyline points="23 4 23 10 17 10"></polyline><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"></path>', "rss": '<path d="M4 11a9 9 0 0 1 9 9"></path><path d="M4 4a16 16 0 0 1 16 16"></path><circle cx="5" cy="19" r="1"></circle>', "save": '<path d="M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z"></path><polyline points="17 21 17 13 7 13 7 21"></polyline><polyline points="7 3 7 8 15 8"></polyline>', "scissors": '<circle cx="6" cy="6" r="3"></circle><circle cx="6" cy="18" r="3"></circle><line x1="20" y1="4" x2="8.12" y2="15.88"></line><line x1="14.47" y1="14.48" x2="20" y2="20"></line><line x1="8.12" y1="8.12" x2="12" y2="12"></line>', "search": '<circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line>', "send": '<line x1="22" y1="2" x2="11" y2="13"></line><polygon points="22 2 15 22 11 13 2 9 22 2"></polygon>', "server": '<rect x="2" y="2" width="20" height="8" rx="2" ry="2"></rect><rect x="2" y="14" width="20" height="8" rx="2" ry="2"></rect><line x1="6" y1="6" x2="6.01" y2="6"></line><line x1="6" y1="18" x2="6.01" y2="18"></line>', "settings": '<circle cx="12" cy="12" r="3"></circle><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"></path>', "share-2": '<circle cx="18" cy="5" r="3"></circle><circle cx="6" cy="12" r="3"></circle><circle cx="18" cy="19" r="3"></circle><line x1="8.59" y1="13.51" x2="15.42" y2="17.49"></line><line x1="15.41" y1="6.51" x2="8.59" y2="10.49"></line>', "share": '<path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"></path><polyline points="16 6 12 2 8 6"></polyline><line x1="12" y1="2" x2="12" y2="15"></line>', "shield-off": '<path d="M19.69 14a6.9 6.9 0 0 0 .31-2V5l-8-3-3.16 1.18"></path><path d="M4.73 4.73L4 5v7c0 6 8 10 8 10a20.29 20.29 0 0 0 5.62-4.38"></path><line x1="1" y1="1" x2="23" y2="23"></line>', "shield": '<path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"></path>', "shopping-bag": '<path d="M6 2L3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4z"></path><line x1="3" y1="6" x2="21" y2="6"></line><path d="M16 10a4 4 0 0 1-8 0"></path>', "shopping-cart": '<circle cx="9" cy="21" r="1"></circle><circle cx="20" cy="21" r="1"></circle><path d="M1 1h4l2.68 13.39a2 2 0 0 0 2 1.61h9.72a2 2 0 0 0 2-1.61L23 6H6"></path>', "shuffle": '<polyline points="16 3 21 3 21 8"></polyline><line x1="4" y1="20" x2="21" y2="3"></line><polyline points="21 16 21 21 16 21"></polyline><line x1="15" y1="15" x2="21" y2="21"></line><line x1="4" y1="4" x2="9" y2="9"></line>', "sidebar": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><line x1="9" y1="3" x2="9" y2="21"></line>', "skip-back": '<polygon points="19 20 9 12 19 4 19 20"></polygon><line x1="5" y1="19" x2="5" y2="5"></line>', "skip-forward": '<polygon points="5 4 15 12 5 20 5 4"></polygon><line x1="19" y1="5" x2="19" y2="19"></line>', "slack": '<path d="M14.5 10c-.83 0-1.5-.67-1.5-1.5v-5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5z"></path><path d="M20.5 10H19V8.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path><path d="M9.5 14c.83 0 1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5S8 21.33 8 20.5v-5c0-.83.67-1.5 1.5-1.5z"></path><path d="M3.5 14H5v1.5c0 .83-.67 1.5-1.5 1.5S2 16.33 2 15.5 2.67 14 3.5 14z"></path><path d="M14 14.5c0-.83.67-1.5 1.5-1.5h5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-5c-.83 0-1.5-.67-1.5-1.5z"></path><path d="M15.5 19H14v1.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path><path d="M10 9.5C10 8.67 9.33 8 8.5 8h-5C2.67 8 2 8.67 2 9.5S2.67 11 3.5 11h5c.83 0 1.5-.67 1.5-1.5z"></path><path d="M8.5 5H10V3.5C10 2.67 9.33 2 8.5 2S7 2.67 7 3.5 7.67 5 8.5 5z"></path>', "slash": '<circle cx="12" cy="12" r="10"></circle><line x1="4.93" y1="4.93" x2="19.07" y2="19.07"></line>', "sliders": '<line x1="4" y1="21" x2="4" y2="14"></line><line x1="4" y1="10" x2="4" y2="3"></line><line x1="12" y1="21" x2="12" y2="12"></line><line x1="12" y1="8" x2="12" y2="3"></line><line x1="20" y1="21" x2="20" y2="16"></line><line x1="20" y1="12" x2="20" y2="3"></line><line x1="1" y1="14" x2="7" y2="14"></line><line x1="9" y1="8" x2="15" y2="8"></line><line x1="17" y1="16" x2="23" y2="16"></line>', "smartphone": '<rect x="5" y="2" width="14" height="20" rx="2" ry="2"></rect><line x1="12" y1="18" x2="12.01" y2="18"></line>', "smile": '<circle cx="12" cy="12" r="10"></circle><path d="M8 14s1.5 2 4 2 4-2 4-2"></path><line x1="9" y1="9" x2="9.01" y2="9"></line><line x1="15" y1="9" x2="15.01" y2="9"></line>', "speaker": '<rect x="4" y="2" width="16" height="20" rx="2" ry="2"></rect><circle cx="12" cy="14" r="4"></circle><line x1="12" y1="6" x2="12.01" y2="6"></line>', "square": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>', "star": '<polygon points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2"></polygon>', "stop-circle": '<circle cx="12" cy="12" r="10"></circle><rect x="9" y="9" width="6" height="6"></rect>', "sun": '<circle cx="12" cy="12" r="5"></circle><line x1="12" y1="1" x2="12" y2="3"></line><line x1="12" y1="21" x2="12" y2="23"></line><line x1="4.22" y1="4.22" x2="5.64" y2="5.64"></line><line x1="18.36" y1="18.36" x2="19.78" y2="19.78"></line><line x1="1" y1="12" x2="3" y2="12"></line><line x1="21" y1="12" x2="23" y2="12"></line><line x1="4.22" y1="19.78" x2="5.64" y2="18.36"></line><line x1="18.36" y1="5.64" x2="19.78" y2="4.22"></line>', "sunrise": '<path d="M17 18a5 5 0 0 0-10 0"></path><line x1="12" y1="2" x2="12" y2="9"></line><line x1="4.22" y1="10.22" x2="5.64" y2="11.64"></line><line x1="1" y1="18" x2="3" y2="18"></line><line x1="21" y1="18" x2="23" y2="18"></line><line x1="18.36" y1="11.64" x2="19.78" y2="10.22"></line><line x1="23" y1="22" x2="1" y2="22"></line><polyline points="8 6 12 2 16 6"></polyline>', "sunset": '<path d="M17 18a5 5 0 0 0-10 0"></path><line x1="12" y1="9" x2="12" y2="2"></line><line x1="4.22" y1="10.22" x2="5.64" y2="11.64"></line><line x1="1" y1="18" x2="3" y2="18"></line><line x1="21" y1="18" x2="23" y2="18"></line><line x1="18.36" y1="11.64" x2="19.78" y2="10.22"></line><line x1="23" y1="22" x2="1" y2="22"></line><polyline points="16 5 12 9 8 5"></polyline>', "table": '<path d="M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18"></path>', "tablet": '<rect x="4" y="2" width="16" height="20" rx="2" ry="2"></rect><line x1="12" y1="18" x2="12.01" y2="18"></line>', "tag": '<path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z"></path><line x1="7" y1="7" x2="7.01" y2="7"></line>', "target": '<circle cx="12" cy="12" r="10"></circle><circle cx="12" cy="12" r="6"></circle><circle cx="12" cy="12" r="2"></circle>', "terminal": '<polyline points="4 17 10 11 4 5"></polyline><line x1="12" y1="19" x2="20" y2="19"></line>', "thermometer": '<path d="M14 14.76V3.5a2.5 2.5 0 0 0-5 0v11.26a4.5 4.5 0 1 0 5 0z"></path>', "thumbs-down": '<path d="M10 15v4a3 3 0 0 0 3 3l4-9V2H5.72a2 2 0 0 0-2 1.7l-1.38 9a2 2 0 0 0 2 2.3zm7-13h2.67A2.31 2.31 0 0 1 22 4v7a2.31 2.31 0 0 1-2.33 2H17"></path>', "thumbs-up": '<path d="M14 9V5a3 3 0 0 0-3-3l-4 9v11h11.28a2 2 0 0 0 2-1.7l1.38-9a2 2 0 0 0-2-2.3zM7 22H4a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h3"></path>', "toggle-left": '<rect x="1" y="5" width="22" height="14" rx="7" ry="7"></rect><circle cx="8" cy="12" r="3"></circle>', "toggle-right": '<rect x="1" y="5" width="22" height="14" rx="7" ry="7"></rect><circle cx="16" cy="12" r="3"></circle>', "tool": '<path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"></path>', "trash-2": '<polyline points="3 6 5 6 21 6"></polyline><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path><line x1="10" y1="11" x2="10" y2="17"></line><line x1="14" y1="11" x2="14" y2="17"></line>', "trash": '<polyline points="3 6 5 6 21 6"></polyline><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path>', "trello": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><rect x="7" y="7" width="3" height="9"></rect><rect x="14" y="7" width="3" height="5"></rect>', "trending-down": '<polyline points="23 18 13.5 8.5 8.5 13.5 1 6"></polyline><polyline points="17 18 23 18 23 12"></polyline>', "trending-up": '<polyline points="23 6 13.5 15.5 8.5 10.5 1 18"></polyline><polyline points="17 6 23 6 23 12"></polyline>', "triangle": '<path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"></path>', "truck": '<rect x="1" y="3" width="15" height="13"></rect><polygon points="16 8 20 8 23 11 23 16 16 16 16 8"></polygon><circle cx="5.5" cy="18.5" r="2.5"></circle><circle cx="18.5" cy="18.5" r="2.5"></circle>', "tv": '<rect x="2" y="7" width="20" height="15" rx="2" ry="2"></rect><polyline points="17 2 12 7 7 2"></polyline>', "twitch": '<path d="M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7"></path>', "twitter": '<path d="M23 3a10.9 10.9 0 0 1-3.14 1.53 4.48 4.48 0 0 0-7.86 3v1A10.66 10.66 0 0 1 3 4s-4 9 5 13a11.64 11.64 0 0 1-7 2c9 5 20 0 20-11.5a4.5 4.5 0 0 0-.08-.83A7.72 7.72 0 0 0 23 3z"></path>', "type": '<polyline points="4 7 4 4 20 4 20 7"></polyline><line x1="9" y1="20" x2="15" y2="20"></line><line x1="12" y1="4" x2="12" y2="20"></line>', "umbrella": '<path d="M23 12a11.05 11.05 0 0 0-22 0zm-5 7a3 3 0 0 1-6 0v-7"></path>', "underline": '<path d="M6 3v7a6 6 0 0 0 6 6 6 6 0 0 0 6-6V3"></path><line x1="4" y1="21" x2="20" y2="21"></line>', "unlock": '<rect x="3" y="11" width="18" height="11" rx="2" ry="2"></rect><path d="M7 11V7a5 5 0 0 1 9.9-1"></path>', "upload-cloud": '<polyline points="16 16 12 12 8 16"></polyline><line x1="12" y1="12" x2="12" y2="21"></line><path d="M20.39 18.39A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.3"></path><polyline points="16 16 12 12 8 16"></polyline>', "upload": '<path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line>', "user-check": '<path d="M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path><circle cx="8.5" cy="7" r="4"></circle><polyline points="17 11 19 13 23 9"></polyline>', "user-minus": '<path d="M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path><circle cx="8.5" cy="7" r="4"></circle><line x1="23" y1="11" x2="17" y2="11"></line>', "user-plus": '<path d="M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path><circle cx="8.5" cy="7" r="4"></circle><line x1="20" y1="8" x2="20" y2="14"></line><line x1="23" y1="11" x2="17" y2="11"></line>', "user-x": '<path d="M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path><circle cx="8.5" cy="7" r="4"></circle><line x1="18" y1="8" x2="23" y2="13"></line><line x1="23" y1="8" x2="18" y2="13"></line>', "user": '<path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"></path><circle cx="12" cy="7" r="4"></circle>', "users": '<path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path><circle cx="9" cy="7" r="4"></circle><path d="M23 21v-2a4 4 0 0 0-3-3.87"></path><path d="M16 3.13a4 4 0 0 1 0 7.75"></path>', "video-off": '<path d="M16 16v1a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2m5.66 0H14a2 2 0 0 1 2 2v3.34l1 1L23 7v10"></path><line x1="1" y1="1" x2="23" y2="23"></line>', "video": '<polygon points="23 7 16 12 23 17 23 7"></polygon><rect x="1" y="5" width="15" height="14" rx="2" ry="2"></rect>', "voicemail": '<circle cx="5.5" cy="11.5" r="4.5"></circle><circle cx="18.5" cy="11.5" r="4.5"></circle><line x1="5.5" y1="16" x2="18.5" y2="16"></line>', "volume-1": '<polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon><path d="M15.54 8.46a5 5 0 0 1 0 7.07"></path>', "volume-2": '<polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon><path d="M19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07"></path>', "volume-x": '<polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon><line x1="23" y1="9" x2="17" y2="15"></line><line x1="17" y1="9" x2="23" y2="15"></line>', "volume": '<polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon>', "watch": '<circle cx="12" cy="12" r="7"></circle><polyline points="12 9 12 12 13.5 13.5"></polyline><path d="M16.51 17.35l-.35 3.83a2 2 0 0 1-2 1.82H9.83a2 2 0 0 1-2-1.82l-.35-3.83m.01-10.7l.35-3.83A2 2 0 0 1 9.83 1h4.35a2 2 0 0 1 2 1.82l.35 3.83"></path>', "wifi-off": '<line x1="1" y1="1" x2="23" y2="23"></line><path d="M16.72 11.06A10.94 10.94 0 0 1 19 12.55"></path><path d="M5 12.55a10.94 10.94 0 0 1 5.17-2.39"></path><path d="M10.71 5.05A16 16 0 0 1 22.58 9"></path><path d="M1.42 9a15.91 15.91 0 0 1 4.7-2.88"></path><path d="M8.53 16.11a6 6 0 0 1 6.95 0"></path><line x1="12" y1="20" x2="12.01" y2="20"></line>', "wifi": '<path d="M5 12.55a11 11 0 0 1 14.08 0"></path><path d="M1.42 9a16 16 0 0 1 21.16 0"></path><path d="M8.53 16.11a6 6 0 0 1 6.95 0"></path><line x1="12" y1="20" x2="12.01" y2="20"></line>', "wind": '<path d="M9.59 4.59A2 2 0 1 1 11 8H2m10.59 11.41A2 2 0 1 0 14 16H2m15.73-8.27A2.5 2.5 0 1 1 19.5 12H2"></path>', "x-circle": '<circle cx="12" cy="12" r="10"></circle><line x1="15" y1="9" x2="9" y2="15"></line><line x1="9" y1="9" x2="15" y2="15"></line>', "x-octagon": '<polygon points="7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2"></polygon><line x1="15" y1="9" x2="9" y2="15"></line><line x1="9" y1="9" x2="15" y2="15"></line>', "x-square": '<rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><line x1="9" y1="9" x2="15" y2="15"></line><line x1="15" y1="9" x2="9" y2="15"></line>', "x": '<line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line>', "youtube": '<path d="M22.54 6.42a2.78 2.78 0 0 0-1.94-2C18.88 4 12 4 12 4s-6.88 0-8.6.46a2.78 2.78 0 0 0-1.94 2A29 29 0 0 0 1 11.75a29 29 0 0 0 .46 5.33A2.78 2.78 0 0 0 3.4 19c1.72.46 8.6.46 8.6.46s6.88 0 8.6-.46a2.78 2.78 0 0 0 1.94-2 29 29 0 0 0 .46-5.25 29 29 0 0 0-.46-5.33z"></path><polygon points="9.75 15.02 15.5 11.75 9.75 8.48 9.75 15.02"></polygon>', "zap-off": '<polyline points="12.41 6.75 13 2 10.57 4.92"></polyline><polyline points="18.57 12.91 21 10 15.66 10"></polyline><polyline points="8 8 3 14 12 14 11 22 16 16"></polyline><line x1="1" y1="1" x2="23" y2="23"></line>', "zap": '<polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon>', "zoom-in": '<circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line><line x1="11" y1="8" x2="11" y2="14"></line><line x1="8" y1="11" x2="14" y2="11"></line>', "zoom-out": '<circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line><line x1="8" y1="11" x2="14" y2="11"></line>' };
|
|
},
|
|
"./node_modules/classnames/dedupe.js": function(module3, exports2, __webpack_require__) {
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
|
|
(function() {
|
|
"use strict";
|
|
var classNames = function() {
|
|
function StorageObject() {
|
|
}
|
|
StorageObject.prototype = Object.create(null);
|
|
function _parseArray(resultSet, array) {
|
|
var length = array.length;
|
|
for (var i = 0; i < length; ++i) {
|
|
_parse(resultSet, array[i]);
|
|
}
|
|
}
|
|
var hasOwn = {}.hasOwnProperty;
|
|
function _parseNumber(resultSet, num2) {
|
|
resultSet[num2] = true;
|
|
}
|
|
function _parseObject(resultSet, object) {
|
|
for (var k in object) {
|
|
if (hasOwn.call(object, k)) {
|
|
resultSet[k] = !!object[k];
|
|
}
|
|
}
|
|
}
|
|
var SPACE = /\s+/;
|
|
function _parseString(resultSet, str) {
|
|
var array = str.split(SPACE);
|
|
var length = array.length;
|
|
for (var i = 0; i < length; ++i) {
|
|
resultSet[array[i]] = true;
|
|
}
|
|
}
|
|
function _parse(resultSet, arg) {
|
|
if (!arg)
|
|
return;
|
|
var argType = typeof arg;
|
|
if (argType === "string") {
|
|
_parseString(resultSet, arg);
|
|
} else if (Array.isArray(arg)) {
|
|
_parseArray(resultSet, arg);
|
|
} else if (argType === "object") {
|
|
_parseObject(resultSet, arg);
|
|
} else if (argType === "number") {
|
|
_parseNumber(resultSet, arg);
|
|
}
|
|
}
|
|
function _classNames() {
|
|
var len = arguments.length;
|
|
var args = Array(len);
|
|
for (var i = 0; i < len; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
var classSet = new StorageObject();
|
|
_parseArray(classSet, args);
|
|
var list = [];
|
|
for (var k in classSet) {
|
|
if (classSet[k]) {
|
|
list.push(k);
|
|
}
|
|
}
|
|
return list.join(" ");
|
|
}
|
|
return _classNames;
|
|
}();
|
|
if (typeof module3 !== "undefined" && module3.exports) {
|
|
module3.exports = classNames;
|
|
} else if (true) {
|
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
|
|
return classNames;
|
|
}.apply(exports2, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module3.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
} else {
|
|
}
|
|
})();
|
|
},
|
|
"./node_modules/core-js/es/array/from.js": function(module3, exports2, __webpack_require__) {
|
|
__webpack_require__("./node_modules/core-js/modules/es.string.iterator.js");
|
|
__webpack_require__("./node_modules/core-js/modules/es.array.from.js");
|
|
var path2 = __webpack_require__("./node_modules/core-js/internals/path.js");
|
|
module3.exports = path2.Array.from;
|
|
},
|
|
"./node_modules/core-js/internals/a-function.js": function(module3, exports2) {
|
|
module3.exports = function(it) {
|
|
if (typeof it != "function") {
|
|
throw TypeError(String(it) + " is not a function");
|
|
}
|
|
return it;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/an-object.js": function(module3, exports2, __webpack_require__) {
|
|
var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
|
|
module3.exports = function(it) {
|
|
if (!isObject(it)) {
|
|
throw TypeError(String(it) + " is not an object");
|
|
}
|
|
return it;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/array-from.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var bind = __webpack_require__("./node_modules/core-js/internals/bind-context.js");
|
|
var toObject = __webpack_require__("./node_modules/core-js/internals/to-object.js");
|
|
var callWithSafeIterationClosing = __webpack_require__("./node_modules/core-js/internals/call-with-safe-iteration-closing.js");
|
|
var isArrayIteratorMethod = __webpack_require__("./node_modules/core-js/internals/is-array-iterator-method.js");
|
|
var toLength = __webpack_require__("./node_modules/core-js/internals/to-length.js");
|
|
var createProperty = __webpack_require__("./node_modules/core-js/internals/create-property.js");
|
|
var getIteratorMethod = __webpack_require__("./node_modules/core-js/internals/get-iterator-method.js");
|
|
module3.exports = function from(arrayLike) {
|
|
var O = toObject(arrayLike);
|
|
var C = typeof this == "function" ? this : Array;
|
|
var argumentsLength = arguments.length;
|
|
var mapfn = argumentsLength > 1 ? arguments[1] : void 0;
|
|
var mapping = mapfn !== void 0;
|
|
var index2 = 0;
|
|
var iteratorMethod = getIteratorMethod(O);
|
|
var length, result, step, iterator;
|
|
if (mapping)
|
|
mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : void 0, 2);
|
|
if (iteratorMethod != void 0 && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
|
|
iterator = iteratorMethod.call(O);
|
|
result = new C();
|
|
for (; !(step = iterator.next()).done; index2++) {
|
|
createProperty(result, index2, mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index2], true) : step.value);
|
|
}
|
|
} else {
|
|
length = toLength(O.length);
|
|
result = new C(length);
|
|
for (; length > index2; index2++) {
|
|
createProperty(result, index2, mapping ? mapfn(O[index2], index2) : O[index2]);
|
|
}
|
|
}
|
|
result.length = index2;
|
|
return result;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/array-includes.js": function(module3, exports2, __webpack_require__) {
|
|
var toIndexedObject = __webpack_require__("./node_modules/core-js/internals/to-indexed-object.js");
|
|
var toLength = __webpack_require__("./node_modules/core-js/internals/to-length.js");
|
|
var toAbsoluteIndex = __webpack_require__("./node_modules/core-js/internals/to-absolute-index.js");
|
|
module3.exports = function(IS_INCLUDES) {
|
|
return function($this, el, fromIndex) {
|
|
var O = toIndexedObject($this);
|
|
var length = toLength(O.length);
|
|
var index2 = toAbsoluteIndex(fromIndex, length);
|
|
var value;
|
|
if (IS_INCLUDES && el != el)
|
|
while (length > index2) {
|
|
value = O[index2++];
|
|
if (value != value)
|
|
return true;
|
|
}
|
|
else
|
|
for (; length > index2; index2++)
|
|
if (IS_INCLUDES || index2 in O) {
|
|
if (O[index2] === el)
|
|
return IS_INCLUDES || index2 || 0;
|
|
}
|
|
return !IS_INCLUDES && -1;
|
|
};
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/bind-context.js": function(module3, exports2, __webpack_require__) {
|
|
var aFunction = __webpack_require__("./node_modules/core-js/internals/a-function.js");
|
|
module3.exports = function(fn, that, length) {
|
|
aFunction(fn);
|
|
if (that === void 0)
|
|
return fn;
|
|
switch (length) {
|
|
case 0:
|
|
return function() {
|
|
return fn.call(that);
|
|
};
|
|
case 1:
|
|
return function(a) {
|
|
return fn.call(that, a);
|
|
};
|
|
case 2:
|
|
return function(a, b) {
|
|
return fn.call(that, a, b);
|
|
};
|
|
case 3:
|
|
return function(a, b, c) {
|
|
return fn.call(that, a, b, c);
|
|
};
|
|
}
|
|
return function() {
|
|
return fn.apply(that, arguments);
|
|
};
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/call-with-safe-iteration-closing.js": function(module3, exports2, __webpack_require__) {
|
|
var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
|
|
module3.exports = function(iterator, fn, value, ENTRIES) {
|
|
try {
|
|
return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
|
|
} catch (error) {
|
|
var returnMethod = iterator["return"];
|
|
if (returnMethod !== void 0)
|
|
anObject(returnMethod.call(iterator));
|
|
throw error;
|
|
}
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/check-correctness-of-iteration.js": function(module3, exports2, __webpack_require__) {
|
|
var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
|
|
var ITERATOR = wellKnownSymbol("iterator");
|
|
var SAFE_CLOSING = false;
|
|
try {
|
|
var called = 0;
|
|
var iteratorWithReturn = {
|
|
next: function() {
|
|
return { done: !!called++ };
|
|
},
|
|
"return": function() {
|
|
SAFE_CLOSING = true;
|
|
}
|
|
};
|
|
iteratorWithReturn[ITERATOR] = function() {
|
|
return this;
|
|
};
|
|
Array.from(iteratorWithReturn, function() {
|
|
throw 2;
|
|
});
|
|
} catch (error) {
|
|
}
|
|
module3.exports = function(exec, SKIP_CLOSING) {
|
|
if (!SKIP_CLOSING && !SAFE_CLOSING)
|
|
return false;
|
|
var ITERATION_SUPPORT = false;
|
|
try {
|
|
var object = {};
|
|
object[ITERATOR] = function() {
|
|
return {
|
|
next: function() {
|
|
return { done: ITERATION_SUPPORT = true };
|
|
}
|
|
};
|
|
};
|
|
exec(object);
|
|
} catch (error) {
|
|
}
|
|
return ITERATION_SUPPORT;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/classof-raw.js": function(module3, exports2) {
|
|
var toString = {}.toString;
|
|
module3.exports = function(it) {
|
|
return toString.call(it).slice(8, -1);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/classof.js": function(module3, exports2, __webpack_require__) {
|
|
var classofRaw = __webpack_require__("./node_modules/core-js/internals/classof-raw.js");
|
|
var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
|
|
var TO_STRING_TAG = wellKnownSymbol("toStringTag");
|
|
var CORRECT_ARGUMENTS = classofRaw(function() {
|
|
return arguments;
|
|
}()) == "Arguments";
|
|
var tryGet = function(it, key2) {
|
|
try {
|
|
return it[key2];
|
|
} catch (error) {
|
|
}
|
|
};
|
|
module3.exports = function(it) {
|
|
var O, tag2, result;
|
|
return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag2 = tryGet(O = Object(it), TO_STRING_TAG)) == "string" ? tag2 : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) == "Object" && typeof O.callee == "function" ? "Arguments" : result;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/copy-constructor-properties.js": function(module3, exports2, __webpack_require__) {
|
|
var has = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var ownKeys = __webpack_require__("./node_modules/core-js/internals/own-keys.js");
|
|
var getOwnPropertyDescriptorModule = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-descriptor.js");
|
|
var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
|
|
module3.exports = function(target, source) {
|
|
var keys = ownKeys(source);
|
|
var defineProperty = definePropertyModule.f;
|
|
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key2 = keys[i];
|
|
if (!has(target, key2))
|
|
defineProperty(target, key2, getOwnPropertyDescriptor(source, key2));
|
|
}
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/correct-prototype-getter.js": function(module3, exports2, __webpack_require__) {
|
|
var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
|
|
module3.exports = !fails(function() {
|
|
function F() {
|
|
}
|
|
F.prototype.constructor = null;
|
|
return Object.getPrototypeOf(new F()) !== F.prototype;
|
|
});
|
|
},
|
|
"./node_modules/core-js/internals/create-iterator-constructor.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var IteratorPrototype = __webpack_require__("./node_modules/core-js/internals/iterators-core.js").IteratorPrototype;
|
|
var create = __webpack_require__("./node_modules/core-js/internals/object-create.js");
|
|
var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
|
|
var setToStringTag = __webpack_require__("./node_modules/core-js/internals/set-to-string-tag.js");
|
|
var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
|
|
var returnThis = function() {
|
|
return this;
|
|
};
|
|
module3.exports = function(IteratorConstructor, NAME, next) {
|
|
var TO_STRING_TAG = NAME + " Iterator";
|
|
IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });
|
|
setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
|
|
Iterators[TO_STRING_TAG] = returnThis;
|
|
return IteratorConstructor;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/create-property-descriptor.js": function(module3, exports2) {
|
|
module3.exports = function(bitmap, value) {
|
|
return {
|
|
enumerable: !(bitmap & 1),
|
|
configurable: !(bitmap & 2),
|
|
writable: !(bitmap & 4),
|
|
value
|
|
};
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/create-property.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var toPrimitive = __webpack_require__("./node_modules/core-js/internals/to-primitive.js");
|
|
var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
|
|
var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
|
|
module3.exports = function(object, key2, value) {
|
|
var propertyKey = toPrimitive(key2);
|
|
if (propertyKey in object)
|
|
definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
|
|
else
|
|
object[propertyKey] = value;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/define-iterator.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var $ = __webpack_require__("./node_modules/core-js/internals/export.js");
|
|
var createIteratorConstructor = __webpack_require__("./node_modules/core-js/internals/create-iterator-constructor.js");
|
|
var getPrototypeOf = __webpack_require__("./node_modules/core-js/internals/object-get-prototype-of.js");
|
|
var setPrototypeOf = __webpack_require__("./node_modules/core-js/internals/object-set-prototype-of.js");
|
|
var setToStringTag = __webpack_require__("./node_modules/core-js/internals/set-to-string-tag.js");
|
|
var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
|
|
var redefine = __webpack_require__("./node_modules/core-js/internals/redefine.js");
|
|
var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
|
|
var IS_PURE = __webpack_require__("./node_modules/core-js/internals/is-pure.js");
|
|
var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
|
|
var IteratorsCore = __webpack_require__("./node_modules/core-js/internals/iterators-core.js");
|
|
var IteratorPrototype = IteratorsCore.IteratorPrototype;
|
|
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
|
|
var ITERATOR = wellKnownSymbol("iterator");
|
|
var KEYS = "keys";
|
|
var VALUES = "values";
|
|
var ENTRIES = "entries";
|
|
var returnThis = function() {
|
|
return this;
|
|
};
|
|
module3.exports = function(Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
|
|
createIteratorConstructor(IteratorConstructor, NAME, next);
|
|
var getIterationMethod = function(KIND) {
|
|
if (KIND === DEFAULT && defaultIterator)
|
|
return defaultIterator;
|
|
if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype)
|
|
return IterablePrototype[KIND];
|
|
switch (KIND) {
|
|
case KEYS:
|
|
return function keys() {
|
|
return new IteratorConstructor(this, KIND);
|
|
};
|
|
case VALUES:
|
|
return function values() {
|
|
return new IteratorConstructor(this, KIND);
|
|
};
|
|
case ENTRIES:
|
|
return function entries() {
|
|
return new IteratorConstructor(this, KIND);
|
|
};
|
|
}
|
|
return function() {
|
|
return new IteratorConstructor(this);
|
|
};
|
|
};
|
|
var TO_STRING_TAG = NAME + " Iterator";
|
|
var INCORRECT_VALUES_NAME = false;
|
|
var IterablePrototype = Iterable.prototype;
|
|
var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype["@@iterator"] || DEFAULT && IterablePrototype[DEFAULT];
|
|
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
|
|
var anyNativeIterator = NAME == "Array" ? IterablePrototype.entries || nativeIterator : nativeIterator;
|
|
var CurrentIteratorPrototype, methods, KEY;
|
|
if (anyNativeIterator) {
|
|
CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
|
|
if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
|
|
if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
|
|
if (setPrototypeOf) {
|
|
setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
|
|
} else if (typeof CurrentIteratorPrototype[ITERATOR] != "function") {
|
|
hide(CurrentIteratorPrototype, ITERATOR, returnThis);
|
|
}
|
|
}
|
|
setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
|
|
if (IS_PURE)
|
|
Iterators[TO_STRING_TAG] = returnThis;
|
|
}
|
|
}
|
|
if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
|
INCORRECT_VALUES_NAME = true;
|
|
defaultIterator = function values() {
|
|
return nativeIterator.call(this);
|
|
};
|
|
}
|
|
if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
|
|
hide(IterablePrototype, ITERATOR, defaultIterator);
|
|
}
|
|
Iterators[NAME] = defaultIterator;
|
|
if (DEFAULT) {
|
|
methods = {
|
|
values: getIterationMethod(VALUES),
|
|
keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
|
|
entries: getIterationMethod(ENTRIES)
|
|
};
|
|
if (FORCED)
|
|
for (KEY in methods) {
|
|
if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
|
|
redefine(IterablePrototype, KEY, methods[KEY]);
|
|
}
|
|
}
|
|
else
|
|
$({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
|
|
}
|
|
return methods;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/descriptors.js": function(module3, exports2, __webpack_require__) {
|
|
var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
|
|
module3.exports = !fails(function() {
|
|
return Object.defineProperty({}, "a", { get: function() {
|
|
return 7;
|
|
} }).a != 7;
|
|
});
|
|
},
|
|
"./node_modules/core-js/internals/document-create-element.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
|
|
var document2 = global2.document;
|
|
var exist = isObject(document2) && isObject(document2.createElement);
|
|
module3.exports = function(it) {
|
|
return exist ? document2.createElement(it) : {};
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/enum-bug-keys.js": function(module3, exports2) {
|
|
module3.exports = [
|
|
"constructor",
|
|
"hasOwnProperty",
|
|
"isPrototypeOf",
|
|
"propertyIsEnumerable",
|
|
"toLocaleString",
|
|
"toString",
|
|
"valueOf"
|
|
];
|
|
},
|
|
"./node_modules/core-js/internals/export.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var getOwnPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-descriptor.js").f;
|
|
var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
|
|
var redefine = __webpack_require__("./node_modules/core-js/internals/redefine.js");
|
|
var setGlobal = __webpack_require__("./node_modules/core-js/internals/set-global.js");
|
|
var copyConstructorProperties = __webpack_require__("./node_modules/core-js/internals/copy-constructor-properties.js");
|
|
var isForced = __webpack_require__("./node_modules/core-js/internals/is-forced.js");
|
|
module3.exports = function(options, source) {
|
|
var TARGET = options.target;
|
|
var GLOBAL = options.global;
|
|
var STATIC = options.stat;
|
|
var FORCED, target, key2, targetProperty, sourceProperty, descriptor;
|
|
if (GLOBAL) {
|
|
target = global2;
|
|
} else if (STATIC) {
|
|
target = global2[TARGET] || setGlobal(TARGET, {});
|
|
} else {
|
|
target = (global2[TARGET] || {}).prototype;
|
|
}
|
|
if (target)
|
|
for (key2 in source) {
|
|
sourceProperty = source[key2];
|
|
if (options.noTargetGet) {
|
|
descriptor = getOwnPropertyDescriptor(target, key2);
|
|
targetProperty = descriptor && descriptor.value;
|
|
} else
|
|
targetProperty = target[key2];
|
|
FORCED = isForced(GLOBAL ? key2 : TARGET + (STATIC ? "." : "#") + key2, options.forced);
|
|
if (!FORCED && targetProperty !== void 0) {
|
|
if (typeof sourceProperty === typeof targetProperty)
|
|
continue;
|
|
copyConstructorProperties(sourceProperty, targetProperty);
|
|
}
|
|
if (options.sham || targetProperty && targetProperty.sham) {
|
|
hide(sourceProperty, "sham", true);
|
|
}
|
|
redefine(target, key2, sourceProperty, options);
|
|
}
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/fails.js": function(module3, exports2) {
|
|
module3.exports = function(exec) {
|
|
try {
|
|
return !!exec();
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/function-to-string.js": function(module3, exports2, __webpack_require__) {
|
|
var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
|
|
module3.exports = shared("native-function-to-string", Function.toString);
|
|
},
|
|
"./node_modules/core-js/internals/get-iterator-method.js": function(module3, exports2, __webpack_require__) {
|
|
var classof = __webpack_require__("./node_modules/core-js/internals/classof.js");
|
|
var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
|
|
var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
|
|
var ITERATOR = wellKnownSymbol("iterator");
|
|
module3.exports = function(it) {
|
|
if (it != void 0)
|
|
return it[ITERATOR] || it["@@iterator"] || Iterators[classof(it)];
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/global.js": function(module3, exports2, __webpack_require__) {
|
|
(function(global2) {
|
|
var O = "object";
|
|
var check = function(it) {
|
|
return it && it.Math == Math && it;
|
|
};
|
|
module3.exports = check(typeof globalThis == O && globalThis) || check(typeof window == O && window) || check(typeof self == O && self) || check(typeof global2 == O && global2) || Function("return this")();
|
|
}).call(this, __webpack_require__("./node_modules/webpack/buildin/global.js"));
|
|
},
|
|
"./node_modules/core-js/internals/has.js": function(module3, exports2) {
|
|
var hasOwnProperty = {}.hasOwnProperty;
|
|
module3.exports = function(it, key2) {
|
|
return hasOwnProperty.call(it, key2);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/hidden-keys.js": function(module3, exports2) {
|
|
module3.exports = {};
|
|
},
|
|
"./node_modules/core-js/internals/hide.js": function(module3, exports2, __webpack_require__) {
|
|
var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
|
|
var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
|
|
var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
|
|
module3.exports = DESCRIPTORS ? function(object, key2, value) {
|
|
return definePropertyModule.f(object, key2, createPropertyDescriptor(1, value));
|
|
} : function(object, key2, value) {
|
|
object[key2] = value;
|
|
return object;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/html.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var document2 = global2.document;
|
|
module3.exports = document2 && document2.documentElement;
|
|
},
|
|
"./node_modules/core-js/internals/ie8-dom-define.js": function(module3, exports2, __webpack_require__) {
|
|
var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
|
|
var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
|
|
var createElement = __webpack_require__("./node_modules/core-js/internals/document-create-element.js");
|
|
module3.exports = !DESCRIPTORS && !fails(function() {
|
|
return Object.defineProperty(createElement("div"), "a", {
|
|
get: function() {
|
|
return 7;
|
|
}
|
|
}).a != 7;
|
|
});
|
|
},
|
|
"./node_modules/core-js/internals/indexed-object.js": function(module3, exports2, __webpack_require__) {
|
|
var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
|
|
var classof = __webpack_require__("./node_modules/core-js/internals/classof-raw.js");
|
|
var split = "".split;
|
|
module3.exports = fails(function() {
|
|
return !Object("z").propertyIsEnumerable(0);
|
|
}) ? function(it) {
|
|
return classof(it) == "String" ? split.call(it, "") : Object(it);
|
|
} : Object;
|
|
},
|
|
"./node_modules/core-js/internals/internal-state.js": function(module3, exports2, __webpack_require__) {
|
|
var NATIVE_WEAK_MAP = __webpack_require__("./node_modules/core-js/internals/native-weak-map.js");
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
|
|
var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
|
|
var objectHas = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var sharedKey = __webpack_require__("./node_modules/core-js/internals/shared-key.js");
|
|
var hiddenKeys = __webpack_require__("./node_modules/core-js/internals/hidden-keys.js");
|
|
var WeakMap2 = global2.WeakMap;
|
|
var set, get, has;
|
|
var enforce = function(it) {
|
|
return has(it) ? get(it) : set(it, {});
|
|
};
|
|
var getterFor = function(TYPE) {
|
|
return function(it) {
|
|
var state;
|
|
if (!isObject(it) || (state = get(it)).type !== TYPE) {
|
|
throw TypeError("Incompatible receiver, " + TYPE + " required");
|
|
}
|
|
return state;
|
|
};
|
|
};
|
|
if (NATIVE_WEAK_MAP) {
|
|
var store = new WeakMap2();
|
|
var wmget = store.get;
|
|
var wmhas = store.has;
|
|
var wmset = store.set;
|
|
set = function(it, metadata) {
|
|
wmset.call(store, it, metadata);
|
|
return metadata;
|
|
};
|
|
get = function(it) {
|
|
return wmget.call(store, it) || {};
|
|
};
|
|
has = function(it) {
|
|
return wmhas.call(store, it);
|
|
};
|
|
} else {
|
|
var STATE = sharedKey("state");
|
|
hiddenKeys[STATE] = true;
|
|
set = function(it, metadata) {
|
|
hide(it, STATE, metadata);
|
|
return metadata;
|
|
};
|
|
get = function(it) {
|
|
return objectHas(it, STATE) ? it[STATE] : {};
|
|
};
|
|
has = function(it) {
|
|
return objectHas(it, STATE);
|
|
};
|
|
}
|
|
module3.exports = {
|
|
set,
|
|
get,
|
|
has,
|
|
enforce,
|
|
getterFor
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/is-array-iterator-method.js": function(module3, exports2, __webpack_require__) {
|
|
var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
|
|
var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
|
|
var ITERATOR = wellKnownSymbol("iterator");
|
|
var ArrayPrototype = Array.prototype;
|
|
module3.exports = function(it) {
|
|
return it !== void 0 && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/is-forced.js": function(module3, exports2, __webpack_require__) {
|
|
var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
|
|
var replacement = /#|\.prototype\./;
|
|
var isForced = function(feature, detection) {
|
|
var value = data[normalize(feature)];
|
|
return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == "function" ? fails(detection) : !!detection;
|
|
};
|
|
var normalize = isForced.normalize = function(string) {
|
|
return String(string).replace(replacement, ".").toLowerCase();
|
|
};
|
|
var data = isForced.data = {};
|
|
var NATIVE = isForced.NATIVE = "N";
|
|
var POLYFILL = isForced.POLYFILL = "P";
|
|
module3.exports = isForced;
|
|
},
|
|
"./node_modules/core-js/internals/is-object.js": function(module3, exports2) {
|
|
module3.exports = function(it) {
|
|
return typeof it === "object" ? it !== null : typeof it === "function";
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/is-pure.js": function(module3, exports2) {
|
|
module3.exports = false;
|
|
},
|
|
"./node_modules/core-js/internals/iterators-core.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var getPrototypeOf = __webpack_require__("./node_modules/core-js/internals/object-get-prototype-of.js");
|
|
var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
|
|
var has = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
|
|
var IS_PURE = __webpack_require__("./node_modules/core-js/internals/is-pure.js");
|
|
var ITERATOR = wellKnownSymbol("iterator");
|
|
var BUGGY_SAFARI_ITERATORS = false;
|
|
var returnThis = function() {
|
|
return this;
|
|
};
|
|
var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
|
|
if ([].keys) {
|
|
arrayIterator = [].keys();
|
|
if (!("next" in arrayIterator))
|
|
BUGGY_SAFARI_ITERATORS = true;
|
|
else {
|
|
PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
|
|
if (PrototypeOfArrayIteratorPrototype !== Object.prototype)
|
|
IteratorPrototype = PrototypeOfArrayIteratorPrototype;
|
|
}
|
|
}
|
|
if (IteratorPrototype == void 0)
|
|
IteratorPrototype = {};
|
|
if (!IS_PURE && !has(IteratorPrototype, ITERATOR))
|
|
hide(IteratorPrototype, ITERATOR, returnThis);
|
|
module3.exports = {
|
|
IteratorPrototype,
|
|
BUGGY_SAFARI_ITERATORS
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/iterators.js": function(module3, exports2) {
|
|
module3.exports = {};
|
|
},
|
|
"./node_modules/core-js/internals/native-symbol.js": function(module3, exports2, __webpack_require__) {
|
|
var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
|
|
module3.exports = !!Object.getOwnPropertySymbols && !fails(function() {
|
|
return !String(Symbol());
|
|
});
|
|
},
|
|
"./node_modules/core-js/internals/native-weak-map.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var nativeFunctionToString = __webpack_require__("./node_modules/core-js/internals/function-to-string.js");
|
|
var WeakMap2 = global2.WeakMap;
|
|
module3.exports = typeof WeakMap2 === "function" && /native code/.test(nativeFunctionToString.call(WeakMap2));
|
|
},
|
|
"./node_modules/core-js/internals/object-create.js": function(module3, exports2, __webpack_require__) {
|
|
var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
|
|
var defineProperties = __webpack_require__("./node_modules/core-js/internals/object-define-properties.js");
|
|
var enumBugKeys = __webpack_require__("./node_modules/core-js/internals/enum-bug-keys.js");
|
|
var hiddenKeys = __webpack_require__("./node_modules/core-js/internals/hidden-keys.js");
|
|
var html2 = __webpack_require__("./node_modules/core-js/internals/html.js");
|
|
var documentCreateElement = __webpack_require__("./node_modules/core-js/internals/document-create-element.js");
|
|
var sharedKey = __webpack_require__("./node_modules/core-js/internals/shared-key.js");
|
|
var IE_PROTO = sharedKey("IE_PROTO");
|
|
var PROTOTYPE = "prototype";
|
|
var Empty = function() {
|
|
};
|
|
var createDict = function() {
|
|
var iframe = documentCreateElement("iframe");
|
|
var length = enumBugKeys.length;
|
|
var lt = "<";
|
|
var script = "script";
|
|
var gt = ">";
|
|
var js = "java" + script + ":";
|
|
var iframeDocument;
|
|
iframe.style.display = "none";
|
|
html2.appendChild(iframe);
|
|
iframe.src = String(js);
|
|
iframeDocument = iframe.contentWindow.document;
|
|
iframeDocument.open();
|
|
iframeDocument.write(lt + script + gt + "document.F=Object" + lt + "/" + script + gt);
|
|
iframeDocument.close();
|
|
createDict = iframeDocument.F;
|
|
while (length--)
|
|
delete createDict[PROTOTYPE][enumBugKeys[length]];
|
|
return createDict();
|
|
};
|
|
module3.exports = Object.create || function create(O, Properties) {
|
|
var result;
|
|
if (O !== null) {
|
|
Empty[PROTOTYPE] = anObject(O);
|
|
result = new Empty();
|
|
Empty[PROTOTYPE] = null;
|
|
result[IE_PROTO] = O;
|
|
} else
|
|
result = createDict();
|
|
return Properties === void 0 ? result : defineProperties(result, Properties);
|
|
};
|
|
hiddenKeys[IE_PROTO] = true;
|
|
},
|
|
"./node_modules/core-js/internals/object-define-properties.js": function(module3, exports2, __webpack_require__) {
|
|
var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
|
|
var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
|
|
var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
|
|
var objectKeys = __webpack_require__("./node_modules/core-js/internals/object-keys.js");
|
|
module3.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
|
|
anObject(O);
|
|
var keys = objectKeys(Properties);
|
|
var length = keys.length;
|
|
var i = 0;
|
|
var key2;
|
|
while (length > i)
|
|
definePropertyModule.f(O, key2 = keys[i++], Properties[key2]);
|
|
return O;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/object-define-property.js": function(module3, exports2, __webpack_require__) {
|
|
var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
|
|
var IE8_DOM_DEFINE = __webpack_require__("./node_modules/core-js/internals/ie8-dom-define.js");
|
|
var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
|
|
var toPrimitive = __webpack_require__("./node_modules/core-js/internals/to-primitive.js");
|
|
var nativeDefineProperty = Object.defineProperty;
|
|
exports2.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPrimitive(P, true);
|
|
anObject(Attributes);
|
|
if (IE8_DOM_DEFINE)
|
|
try {
|
|
return nativeDefineProperty(O, P, Attributes);
|
|
} catch (error) {
|
|
}
|
|
if ("get" in Attributes || "set" in Attributes)
|
|
throw TypeError("Accessors not supported");
|
|
if ("value" in Attributes)
|
|
O[P] = Attributes.value;
|
|
return O;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/object-get-own-property-descriptor.js": function(module3, exports2, __webpack_require__) {
|
|
var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
|
|
var propertyIsEnumerableModule = __webpack_require__("./node_modules/core-js/internals/object-property-is-enumerable.js");
|
|
var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
|
|
var toIndexedObject = __webpack_require__("./node_modules/core-js/internals/to-indexed-object.js");
|
|
var toPrimitive = __webpack_require__("./node_modules/core-js/internals/to-primitive.js");
|
|
var has = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var IE8_DOM_DEFINE = __webpack_require__("./node_modules/core-js/internals/ie8-dom-define.js");
|
|
var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
exports2.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
|
O = toIndexedObject(O);
|
|
P = toPrimitive(P, true);
|
|
if (IE8_DOM_DEFINE)
|
|
try {
|
|
return nativeGetOwnPropertyDescriptor(O, P);
|
|
} catch (error) {
|
|
}
|
|
if (has(O, P))
|
|
return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/object-get-own-property-names.js": function(module3, exports2, __webpack_require__) {
|
|
var internalObjectKeys = __webpack_require__("./node_modules/core-js/internals/object-keys-internal.js");
|
|
var enumBugKeys = __webpack_require__("./node_modules/core-js/internals/enum-bug-keys.js");
|
|
var hiddenKeys = enumBugKeys.concat("length", "prototype");
|
|
exports2.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
|
|
return internalObjectKeys(O, hiddenKeys);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/object-get-own-property-symbols.js": function(module3, exports2) {
|
|
exports2.f = Object.getOwnPropertySymbols;
|
|
},
|
|
"./node_modules/core-js/internals/object-get-prototype-of.js": function(module3, exports2, __webpack_require__) {
|
|
var has = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var toObject = __webpack_require__("./node_modules/core-js/internals/to-object.js");
|
|
var sharedKey = __webpack_require__("./node_modules/core-js/internals/shared-key.js");
|
|
var CORRECT_PROTOTYPE_GETTER = __webpack_require__("./node_modules/core-js/internals/correct-prototype-getter.js");
|
|
var IE_PROTO = sharedKey("IE_PROTO");
|
|
var ObjectPrototype = Object.prototype;
|
|
module3.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function(O) {
|
|
O = toObject(O);
|
|
if (has(O, IE_PROTO))
|
|
return O[IE_PROTO];
|
|
if (typeof O.constructor == "function" && O instanceof O.constructor) {
|
|
return O.constructor.prototype;
|
|
}
|
|
return O instanceof Object ? ObjectPrototype : null;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/object-keys-internal.js": function(module3, exports2, __webpack_require__) {
|
|
var has = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var toIndexedObject = __webpack_require__("./node_modules/core-js/internals/to-indexed-object.js");
|
|
var arrayIncludes = __webpack_require__("./node_modules/core-js/internals/array-includes.js");
|
|
var hiddenKeys = __webpack_require__("./node_modules/core-js/internals/hidden-keys.js");
|
|
var arrayIndexOf = arrayIncludes(false);
|
|
module3.exports = function(object, names) {
|
|
var O = toIndexedObject(object);
|
|
var i = 0;
|
|
var result = [];
|
|
var key2;
|
|
for (key2 in O)
|
|
!has(hiddenKeys, key2) && has(O, key2) && result.push(key2);
|
|
while (names.length > i)
|
|
if (has(O, key2 = names[i++])) {
|
|
~arrayIndexOf(result, key2) || result.push(key2);
|
|
}
|
|
return result;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/object-keys.js": function(module3, exports2, __webpack_require__) {
|
|
var internalObjectKeys = __webpack_require__("./node_modules/core-js/internals/object-keys-internal.js");
|
|
var enumBugKeys = __webpack_require__("./node_modules/core-js/internals/enum-bug-keys.js");
|
|
module3.exports = Object.keys || function keys(O) {
|
|
return internalObjectKeys(O, enumBugKeys);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/object-property-is-enumerable.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
|
|
exports2.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
|
|
var descriptor = getOwnPropertyDescriptor(this, V);
|
|
return !!descriptor && descriptor.enumerable;
|
|
} : nativePropertyIsEnumerable;
|
|
},
|
|
"./node_modules/core-js/internals/object-set-prototype-of.js": function(module3, exports2, __webpack_require__) {
|
|
var validateSetPrototypeOfArguments = __webpack_require__("./node_modules/core-js/internals/validate-set-prototype-of-arguments.js");
|
|
module3.exports = Object.setPrototypeOf || ("__proto__" in {} ? function() {
|
|
var correctSetter = false;
|
|
var test = {};
|
|
var setter;
|
|
try {
|
|
setter = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__").set;
|
|
setter.call(test, []);
|
|
correctSetter = test instanceof Array;
|
|
} catch (error) {
|
|
}
|
|
return function setPrototypeOf(O, proto) {
|
|
validateSetPrototypeOfArguments(O, proto);
|
|
if (correctSetter)
|
|
setter.call(O, proto);
|
|
else
|
|
O.__proto__ = proto;
|
|
return O;
|
|
};
|
|
}() : void 0);
|
|
},
|
|
"./node_modules/core-js/internals/own-keys.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var getOwnPropertyNamesModule = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-names.js");
|
|
var getOwnPropertySymbolsModule = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-symbols.js");
|
|
var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
|
|
var Reflect = global2.Reflect;
|
|
module3.exports = Reflect && Reflect.ownKeys || function ownKeys(it) {
|
|
var keys = getOwnPropertyNamesModule.f(anObject(it));
|
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/path.js": function(module3, exports2, __webpack_require__) {
|
|
module3.exports = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
},
|
|
"./node_modules/core-js/internals/redefine.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
|
|
var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
|
|
var has = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var setGlobal = __webpack_require__("./node_modules/core-js/internals/set-global.js");
|
|
var nativeFunctionToString = __webpack_require__("./node_modules/core-js/internals/function-to-string.js");
|
|
var InternalStateModule = __webpack_require__("./node_modules/core-js/internals/internal-state.js");
|
|
var getInternalState = InternalStateModule.get;
|
|
var enforceInternalState = InternalStateModule.enforce;
|
|
var TEMPLATE = String(nativeFunctionToString).split("toString");
|
|
shared("inspectSource", function(it) {
|
|
return nativeFunctionToString.call(it);
|
|
});
|
|
(module3.exports = function(O, key2, value, options) {
|
|
var unsafe = options ? !!options.unsafe : false;
|
|
var simple = options ? !!options.enumerable : false;
|
|
var noTargetGet = options ? !!options.noTargetGet : false;
|
|
if (typeof value == "function") {
|
|
if (typeof key2 == "string" && !has(value, "name"))
|
|
hide(value, "name", key2);
|
|
enforceInternalState(value).source = TEMPLATE.join(typeof key2 == "string" ? key2 : "");
|
|
}
|
|
if (O === global2) {
|
|
if (simple)
|
|
O[key2] = value;
|
|
else
|
|
setGlobal(key2, value);
|
|
return;
|
|
} else if (!unsafe) {
|
|
delete O[key2];
|
|
} else if (!noTargetGet && O[key2]) {
|
|
simple = true;
|
|
}
|
|
if (simple)
|
|
O[key2] = value;
|
|
else
|
|
hide(O, key2, value);
|
|
})(Function.prototype, "toString", function toString() {
|
|
return typeof this == "function" && getInternalState(this).source || nativeFunctionToString.call(this);
|
|
});
|
|
},
|
|
"./node_modules/core-js/internals/require-object-coercible.js": function(module3, exports2) {
|
|
module3.exports = function(it) {
|
|
if (it == void 0)
|
|
throw TypeError("Can't call method on " + it);
|
|
return it;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/set-global.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
|
|
module3.exports = function(key2, value) {
|
|
try {
|
|
hide(global2, key2, value);
|
|
} catch (error) {
|
|
global2[key2] = value;
|
|
}
|
|
return value;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/set-to-string-tag.js": function(module3, exports2, __webpack_require__) {
|
|
var defineProperty = __webpack_require__("./node_modules/core-js/internals/object-define-property.js").f;
|
|
var has = __webpack_require__("./node_modules/core-js/internals/has.js");
|
|
var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
|
|
var TO_STRING_TAG = wellKnownSymbol("toStringTag");
|
|
module3.exports = function(it, TAG, STATIC) {
|
|
if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
|
|
defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });
|
|
}
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/shared-key.js": function(module3, exports2, __webpack_require__) {
|
|
var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
|
|
var uid = __webpack_require__("./node_modules/core-js/internals/uid.js");
|
|
var keys = shared("keys");
|
|
module3.exports = function(key2) {
|
|
return keys[key2] || (keys[key2] = uid(key2));
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/shared.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var setGlobal = __webpack_require__("./node_modules/core-js/internals/set-global.js");
|
|
var IS_PURE = __webpack_require__("./node_modules/core-js/internals/is-pure.js");
|
|
var SHARED = "__core-js_shared__";
|
|
var store = global2[SHARED] || setGlobal(SHARED, {});
|
|
(module3.exports = function(key2, value) {
|
|
return store[key2] || (store[key2] = value !== void 0 ? value : {});
|
|
})("versions", []).push({
|
|
version: "3.1.3",
|
|
mode: IS_PURE ? "pure" : "global",
|
|
copyright: "\xA9 2019 Denis Pushkarev (zloirock.ru)"
|
|
});
|
|
},
|
|
"./node_modules/core-js/internals/string-at.js": function(module3, exports2, __webpack_require__) {
|
|
var toInteger = __webpack_require__("./node_modules/core-js/internals/to-integer.js");
|
|
var requireObjectCoercible = __webpack_require__("./node_modules/core-js/internals/require-object-coercible.js");
|
|
module3.exports = function(that, pos, CONVERT_TO_STRING) {
|
|
var S = String(requireObjectCoercible(that));
|
|
var position = toInteger(pos);
|
|
var size = S.length;
|
|
var first2, second;
|
|
if (position < 0 || position >= size)
|
|
return CONVERT_TO_STRING ? "" : void 0;
|
|
first2 = S.charCodeAt(position);
|
|
return first2 < 55296 || first2 > 56319 || position + 1 === size || (second = S.charCodeAt(position + 1)) < 56320 || second > 57343 ? CONVERT_TO_STRING ? S.charAt(position) : first2 : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first2 - 55296 << 10) + (second - 56320) + 65536;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/to-absolute-index.js": function(module3, exports2, __webpack_require__) {
|
|
var toInteger = __webpack_require__("./node_modules/core-js/internals/to-integer.js");
|
|
var max = Math.max;
|
|
var min = Math.min;
|
|
module3.exports = function(index2, length) {
|
|
var integer = toInteger(index2);
|
|
return integer < 0 ? max(integer + length, 0) : min(integer, length);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/to-indexed-object.js": function(module3, exports2, __webpack_require__) {
|
|
var IndexedObject = __webpack_require__("./node_modules/core-js/internals/indexed-object.js");
|
|
var requireObjectCoercible = __webpack_require__("./node_modules/core-js/internals/require-object-coercible.js");
|
|
module3.exports = function(it) {
|
|
return IndexedObject(requireObjectCoercible(it));
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/to-integer.js": function(module3, exports2) {
|
|
var ceil = Math.ceil;
|
|
var floor = Math.floor;
|
|
module3.exports = function(argument) {
|
|
return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/to-length.js": function(module3, exports2, __webpack_require__) {
|
|
var toInteger = __webpack_require__("./node_modules/core-js/internals/to-integer.js");
|
|
var min = Math.min;
|
|
module3.exports = function(argument) {
|
|
return argument > 0 ? min(toInteger(argument), 9007199254740991) : 0;
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/to-object.js": function(module3, exports2, __webpack_require__) {
|
|
var requireObjectCoercible = __webpack_require__("./node_modules/core-js/internals/require-object-coercible.js");
|
|
module3.exports = function(argument) {
|
|
return Object(requireObjectCoercible(argument));
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/to-primitive.js": function(module3, exports2, __webpack_require__) {
|
|
var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
|
|
module3.exports = function(it, S) {
|
|
if (!isObject(it))
|
|
return it;
|
|
var fn, val;
|
|
if (S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it)))
|
|
return val;
|
|
if (typeof (fn = it.valueOf) == "function" && !isObject(val = fn.call(it)))
|
|
return val;
|
|
if (!S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it)))
|
|
return val;
|
|
throw TypeError("Can't convert object to primitive value");
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/uid.js": function(module3, exports2) {
|
|
var id = 0;
|
|
var postfix = Math.random();
|
|
module3.exports = function(key2) {
|
|
return "Symbol(".concat(key2 === void 0 ? "" : key2, ")_", (++id + postfix).toString(36));
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/validate-set-prototype-of-arguments.js": function(module3, exports2, __webpack_require__) {
|
|
var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
|
|
var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
|
|
module3.exports = function(O, proto) {
|
|
anObject(O);
|
|
if (!isObject(proto) && proto !== null) {
|
|
throw TypeError("Can't set " + String(proto) + " as a prototype");
|
|
}
|
|
};
|
|
},
|
|
"./node_modules/core-js/internals/well-known-symbol.js": function(module3, exports2, __webpack_require__) {
|
|
var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
|
|
var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
|
|
var uid = __webpack_require__("./node_modules/core-js/internals/uid.js");
|
|
var NATIVE_SYMBOL = __webpack_require__("./node_modules/core-js/internals/native-symbol.js");
|
|
var Symbol2 = global2.Symbol;
|
|
var store = shared("wks");
|
|
module3.exports = function(name) {
|
|
return store[name] || (store[name] = NATIVE_SYMBOL && Symbol2[name] || (NATIVE_SYMBOL ? Symbol2 : uid)("Symbol." + name));
|
|
};
|
|
},
|
|
"./node_modules/core-js/modules/es.array.from.js": function(module3, exports2, __webpack_require__) {
|
|
var $ = __webpack_require__("./node_modules/core-js/internals/export.js");
|
|
var from = __webpack_require__("./node_modules/core-js/internals/array-from.js");
|
|
var checkCorrectnessOfIteration = __webpack_require__("./node_modules/core-js/internals/check-correctness-of-iteration.js");
|
|
var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function(iterable) {
|
|
Array.from(iterable);
|
|
});
|
|
$({ target: "Array", stat: true, forced: INCORRECT_ITERATION }, {
|
|
from
|
|
});
|
|
},
|
|
"./node_modules/core-js/modules/es.string.iterator.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var codePointAt = __webpack_require__("./node_modules/core-js/internals/string-at.js");
|
|
var InternalStateModule = __webpack_require__("./node_modules/core-js/internals/internal-state.js");
|
|
var defineIterator = __webpack_require__("./node_modules/core-js/internals/define-iterator.js");
|
|
var STRING_ITERATOR = "String Iterator";
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
|
|
defineIterator(String, "String", function(iterated) {
|
|
setInternalState(this, {
|
|
type: STRING_ITERATOR,
|
|
string: String(iterated),
|
|
index: 0
|
|
});
|
|
}, function next() {
|
|
var state = getInternalState(this);
|
|
var string = state.string;
|
|
var index2 = state.index;
|
|
var point;
|
|
if (index2 >= string.length)
|
|
return { value: void 0, done: true };
|
|
point = codePointAt(string, index2, true);
|
|
state.index += point.length;
|
|
return { value: point, done: false };
|
|
});
|
|
},
|
|
"./node_modules/webpack/buildin/global.js": function(module3, exports2) {
|
|
var g;
|
|
g = function() {
|
|
return this;
|
|
}();
|
|
try {
|
|
g = g || Function("return this")() || (1, eval)("this");
|
|
} catch (e) {
|
|
if (typeof window === "object")
|
|
g = window;
|
|
}
|
|
module3.exports = g;
|
|
},
|
|
"./src/default-attrs.json": function(module3) {
|
|
module3.exports = { "xmlns": "http://www.w3.org/2000/svg", "width": 24, "height": 24, "viewBox": "0 0 24 24", "fill": "none", "stroke": "currentColor", "stroke-width": 2, "stroke-linecap": "round", "stroke-linejoin": "round" };
|
|
},
|
|
"./src/icon.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {
|
|
value: true
|
|
});
|
|
var _extends = Object.assign || function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key2 in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key2)) {
|
|
target[key2] = source[key2];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
var _createClass = function() {
|
|
function defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor)
|
|
descriptor.writable = true;
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
return function(Constructor, protoProps, staticProps) {
|
|
if (protoProps)
|
|
defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps)
|
|
defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
};
|
|
}();
|
|
var _dedupe = __webpack_require__("./node_modules/classnames/dedupe.js");
|
|
var _dedupe2 = _interopRequireDefault(_dedupe);
|
|
var _defaultAttrs = __webpack_require__("./src/default-attrs.json");
|
|
var _defaultAttrs2 = _interopRequireDefault(_defaultAttrs);
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
function _classCallCheck(instance6, Constructor) {
|
|
if (!(instance6 instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
var Icon = function() {
|
|
function Icon2(name, contents) {
|
|
var tags = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
|
|
_classCallCheck(this, Icon2);
|
|
this.name = name;
|
|
this.contents = contents;
|
|
this.tags = tags;
|
|
this.attrs = _extends({}, _defaultAttrs2.default, { class: "feather feather-" + name });
|
|
}
|
|
_createClass(Icon2, [{
|
|
key: "toSvg",
|
|
value: function toSvg() {
|
|
var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
|
var combinedAttrs = _extends({}, this.attrs, attrs, { class: (0, _dedupe2.default)(this.attrs.class, attrs.class) });
|
|
return "<svg " + attrsToString(combinedAttrs) + ">" + this.contents + "</svg>";
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return this.contents;
|
|
}
|
|
}]);
|
|
return Icon2;
|
|
}();
|
|
function attrsToString(attrs) {
|
|
return Object.keys(attrs).map(function(key2) {
|
|
return key2 + '="' + attrs[key2] + '"';
|
|
}).join(" ");
|
|
}
|
|
exports2.default = Icon;
|
|
},
|
|
"./src/icons.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {
|
|
value: true
|
|
});
|
|
var _icon = __webpack_require__("./src/icon.js");
|
|
var _icon2 = _interopRequireDefault(_icon);
|
|
var _icons = __webpack_require__("./dist/icons.json");
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
var _tags = __webpack_require__("./src/tags.json");
|
|
var _tags2 = _interopRequireDefault(_tags);
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
exports2.default = Object.keys(_icons2.default).map(function(key2) {
|
|
return new _icon2.default(key2, _icons2.default[key2], _tags2.default[key2]);
|
|
}).reduce(function(object, icon) {
|
|
object[icon.name] = icon;
|
|
return object;
|
|
}, {});
|
|
},
|
|
"./src/index.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
var _icons = __webpack_require__("./src/icons.js");
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
var _toSvg = __webpack_require__("./src/to-svg.js");
|
|
var _toSvg2 = _interopRequireDefault(_toSvg);
|
|
var _replace = __webpack_require__("./src/replace.js");
|
|
var _replace2 = _interopRequireDefault(_replace);
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
module3.exports = { icons: _icons2.default, toSvg: _toSvg2.default, replace: _replace2.default };
|
|
},
|
|
"./src/replace.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {
|
|
value: true
|
|
});
|
|
var _extends = Object.assign || function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key2 in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key2)) {
|
|
target[key2] = source[key2];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
var _dedupe = __webpack_require__("./node_modules/classnames/dedupe.js");
|
|
var _dedupe2 = _interopRequireDefault(_dedupe);
|
|
var _icons = __webpack_require__("./src/icons.js");
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
function replace() {
|
|
var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
|
if (typeof document === "undefined") {
|
|
throw new Error("`feather.replace()` only works in a browser environment.");
|
|
}
|
|
var elementsToReplace = document.querySelectorAll("[data-feather]");
|
|
Array.from(elementsToReplace).forEach(function(element2) {
|
|
return replaceElement(element2, attrs);
|
|
});
|
|
}
|
|
function replaceElement(element2) {
|
|
var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
|
|
var elementAttrs = getAttrs(element2);
|
|
var name = elementAttrs["data-feather"];
|
|
delete elementAttrs["data-feather"];
|
|
var svgString = _icons2.default[name].toSvg(_extends({}, attrs, elementAttrs, { class: (0, _dedupe2.default)(attrs.class, elementAttrs.class) }));
|
|
var svgDocument = new DOMParser().parseFromString(svgString, "image/svg+xml");
|
|
var svgElement = svgDocument.querySelector("svg");
|
|
element2.parentNode.replaceChild(svgElement, element2);
|
|
}
|
|
function getAttrs(element2) {
|
|
return Array.from(element2.attributes).reduce(function(attrs, attr2) {
|
|
attrs[attr2.name] = attr2.value;
|
|
return attrs;
|
|
}, {});
|
|
}
|
|
exports2.default = replace;
|
|
},
|
|
"./src/tags.json": function(module3) {
|
|
module3.exports = { "activity": ["pulse", "health", "action", "motion"], "airplay": ["stream", "cast", "mirroring"], "alert-circle": ["warning", "alert", "danger"], "alert-octagon": ["warning", "alert", "danger"], "alert-triangle": ["warning", "alert", "danger"], "align-center": ["text alignment", "center"], "align-justify": ["text alignment", "justified"], "align-left": ["text alignment", "left"], "align-right": ["text alignment", "right"], "anchor": [], "archive": ["index", "box"], "at-sign": ["mention", "at", "email", "message"], "award": ["achievement", "badge"], "aperture": ["camera", "photo"], "bar-chart": ["statistics", "diagram", "graph"], "bar-chart-2": ["statistics", "diagram", "graph"], "battery": ["power", "electricity"], "battery-charging": ["power", "electricity"], "bell": ["alarm", "notification", "sound"], "bell-off": ["alarm", "notification", "silent"], "bluetooth": ["wireless"], "book-open": ["read", "library"], "book": ["read", "dictionary", "booklet", "magazine", "library"], "bookmark": ["read", "clip", "marker", "tag"], "box": ["cube"], "briefcase": ["work", "bag", "baggage", "folder"], "calendar": ["date"], "camera": ["photo"], "cast": ["chromecast", "airplay"], "chevron-down": ["expand"], "chevron-up": ["collapse"], "circle": ["off", "zero", "record"], "clipboard": ["copy"], "clock": ["time", "watch", "alarm"], "cloud-drizzle": ["weather", "shower"], "cloud-lightning": ["weather", "bolt"], "cloud-rain": ["weather"], "cloud-snow": ["weather", "blizzard"], "cloud": ["weather"], "codepen": ["logo"], "codesandbox": ["logo"], "code": ["source", "programming"], "coffee": ["drink", "cup", "mug", "tea", "cafe", "hot", "beverage"], "columns": ["layout"], "command": ["keyboard", "cmd", "terminal", "prompt"], "compass": ["navigation", "safari", "travel", "direction"], "copy": ["clone", "duplicate"], "corner-down-left": ["arrow", "return"], "corner-down-right": ["arrow"], "corner-left-down": ["arrow"], "corner-left-up": ["arrow"], "corner-right-down": ["arrow"], "corner-right-up": ["arrow"], "corner-up-left": ["arrow"], "corner-up-right": ["arrow"], "cpu": ["processor", "technology"], "credit-card": ["purchase", "payment", "cc"], "crop": ["photo", "image"], "crosshair": ["aim", "target"], "database": ["storage", "memory"], "delete": ["remove"], "disc": ["album", "cd", "dvd", "music"], "dollar-sign": ["currency", "money", "payment"], "droplet": ["water"], "edit": ["pencil", "change"], "edit-2": ["pencil", "change"], "edit-3": ["pencil", "change"], "eye": ["view", "watch"], "eye-off": ["view", "watch", "hide", "hidden"], "external-link": ["outbound"], "facebook": ["logo", "social"], "fast-forward": ["music"], "figma": ["logo", "design", "tool"], "file-minus": ["delete", "remove", "erase"], "file-plus": ["add", "create", "new"], "file-text": ["data", "txt", "pdf"], "film": ["movie", "video"], "filter": ["funnel", "hopper"], "flag": ["report"], "folder-minus": ["directory"], "folder-plus": ["directory"], "folder": ["directory"], "framer": ["logo", "design", "tool"], "frown": ["emoji", "face", "bad", "sad", "emotion"], "gift": ["present", "box", "birthday", "party"], "git-branch": ["code", "version control"], "git-commit": ["code", "version control"], "git-merge": ["code", "version control"], "git-pull-request": ["code", "version control"], "github": ["logo", "version control"], "gitlab": ["logo", "version control"], "globe": ["world", "browser", "language", "translate"], "hard-drive": ["computer", "server", "memory", "data"], "hash": ["hashtag", "number", "pound"], "headphones": ["music", "audio", "sound"], "heart": ["like", "love", "emotion"], "help-circle": ["question mark"], "hexagon": ["shape", "node.js", "logo"], "home": ["house", "living"], "image": ["picture"], "inbox": ["email"], "instagram": ["logo", "camera"], "key": ["password", "login", "authentication", "secure"], "layers": ["stack"], "layout": ["window", "webpage"], "life-bouy": ["help", "life ring", "support"], "link": ["chain", "url"], "link-2": ["chain", "url"], "linkedin": ["logo", "social media"], "list": ["options"], "lock": ["security", "password", "secure"], "log-in": ["sign in", "arrow", "enter"], "log-out": ["sign out", "arrow", "exit"], "mail": ["email", "message"], "map-pin": ["location", "navigation", "travel", "marker"], "map": ["location", "navigation", "travel"], "maximize": ["fullscreen"], "maximize-2": ["fullscreen", "arrows", "expand"], "meh": ["emoji", "face", "neutral", "emotion"], "menu": ["bars", "navigation", "hamburger"], "message-circle": ["comment", "chat"], "message-square": ["comment", "chat"], "mic-off": ["record", "sound", "mute"], "mic": ["record", "sound", "listen"], "minimize": ["exit fullscreen", "close"], "minimize-2": ["exit fullscreen", "arrows", "close"], "minus": ["subtract"], "monitor": ["tv", "screen", "display"], "moon": ["dark", "night"], "more-horizontal": ["ellipsis"], "more-vertical": ["ellipsis"], "mouse-pointer": ["arrow", "cursor"], "move": ["arrows"], "music": ["note"], "navigation": ["location", "travel"], "navigation-2": ["location", "travel"], "octagon": ["stop"], "package": ["box", "container"], "paperclip": ["attachment"], "pause": ["music", "stop"], "pause-circle": ["music", "audio", "stop"], "pen-tool": ["vector", "drawing"], "percent": ["discount"], "phone-call": ["ring"], "phone-forwarded": ["call"], "phone-incoming": ["call"], "phone-missed": ["call"], "phone-off": ["call", "mute"], "phone-outgoing": ["call"], "phone": ["call"], "play": ["music", "start"], "pie-chart": ["statistics", "diagram"], "play-circle": ["music", "start"], "plus": ["add", "new"], "plus-circle": ["add", "new"], "plus-square": ["add", "new"], "pocket": ["logo", "save"], "power": ["on", "off"], "printer": ["fax", "office", "device"], "radio": ["signal"], "refresh-cw": ["synchronise", "arrows"], "refresh-ccw": ["arrows"], "repeat": ["loop", "arrows"], "rewind": ["music"], "rotate-ccw": ["arrow"], "rotate-cw": ["arrow"], "rss": ["feed", "subscribe"], "save": ["floppy disk"], "scissors": ["cut"], "search": ["find", "magnifier", "magnifying glass"], "send": ["message", "mail", "email", "paper airplane", "paper aeroplane"], "settings": ["cog", "edit", "gear", "preferences"], "share-2": ["network", "connections"], "shield": ["security", "secure"], "shield-off": ["security", "insecure"], "shopping-bag": ["ecommerce", "cart", "purchase", "store"], "shopping-cart": ["ecommerce", "cart", "purchase", "store"], "shuffle": ["music"], "skip-back": ["music"], "skip-forward": ["music"], "slack": ["logo"], "slash": ["ban", "no"], "sliders": ["settings", "controls"], "smartphone": ["cellphone", "device"], "smile": ["emoji", "face", "happy", "good", "emotion"], "speaker": ["audio", "music"], "star": ["bookmark", "favorite", "like"], "stop-circle": ["media", "music"], "sun": ["brightness", "weather", "light"], "sunrise": ["weather", "time", "morning", "day"], "sunset": ["weather", "time", "evening", "night"], "tablet": ["device"], "tag": ["label"], "target": ["logo", "bullseye"], "terminal": ["code", "command line", "prompt"], "thermometer": ["temperature", "celsius", "fahrenheit", "weather"], "thumbs-down": ["dislike", "bad", "emotion"], "thumbs-up": ["like", "good", "emotion"], "toggle-left": ["on", "off", "switch"], "toggle-right": ["on", "off", "switch"], "tool": ["settings", "spanner"], "trash": ["garbage", "delete", "remove", "bin"], "trash-2": ["garbage", "delete", "remove", "bin"], "triangle": ["delta"], "truck": ["delivery", "van", "shipping", "transport", "lorry"], "tv": ["television", "stream"], "twitch": ["logo"], "twitter": ["logo", "social"], "type": ["text"], "umbrella": ["rain", "weather"], "unlock": ["security"], "user-check": ["followed", "subscribed"], "user-minus": ["delete", "remove", "unfollow", "unsubscribe"], "user-plus": ["new", "add", "create", "follow", "subscribe"], "user-x": ["delete", "remove", "unfollow", "unsubscribe", "unavailable"], "user": ["person", "account"], "users": ["group"], "video-off": ["camera", "movie", "film"], "video": ["camera", "movie", "film"], "voicemail": ["phone"], "volume": ["music", "sound", "mute"], "volume-1": ["music", "sound"], "volume-2": ["music", "sound"], "volume-x": ["music", "sound", "mute"], "watch": ["clock", "time"], "wifi-off": ["disabled"], "wifi": ["connection", "signal", "wireless"], "wind": ["weather", "air"], "x-circle": ["cancel", "close", "delete", "remove", "times", "clear"], "x-octagon": ["delete", "stop", "alert", "warning", "times", "clear"], "x-square": ["cancel", "close", "delete", "remove", "times", "clear"], "x": ["cancel", "close", "delete", "remove", "times", "clear"], "youtube": ["logo", "video", "play"], "zap-off": ["flash", "camera", "lightning"], "zap": ["flash", "camera", "lightning"], "zoom-in": ["magnifying glass"], "zoom-out": ["magnifying glass"] };
|
|
},
|
|
"./src/to-svg.js": function(module3, exports2, __webpack_require__) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {
|
|
value: true
|
|
});
|
|
var _icons = __webpack_require__("./src/icons.js");
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
function toSvg(name) {
|
|
var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
|
|
console.warn("feather.toSvg() is deprecated. Please use feather.icons[name].toSvg() instead.");
|
|
if (!name) {
|
|
throw new Error("The required `key` (icon name) parameter is missing.");
|
|
}
|
|
if (!_icons2.default[name]) {
|
|
throw new Error("No icon matching '" + name + "'. See the complete list of icons at https://feathericons.com");
|
|
}
|
|
return _icons2.default[name].toSvg(attrs);
|
|
}
|
|
exports2.default = toSvg;
|
|
},
|
|
0: function(module3, exports2, __webpack_require__) {
|
|
__webpack_require__("./node_modules/core-js/es/array/from.js");
|
|
module3.exports = __webpack_require__("./src/index.js");
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
// src/main.ts
|
|
__export(exports, {
|
|
default: () => ObsidianGit
|
|
});
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/isomorphic-git/index.js
|
|
init_polyfill_buffer();
|
|
var import_async_lock = __toModule(require_async_lock());
|
|
var import_sha1 = __toModule(require_sha1());
|
|
var import_crc_32 = __toModule(require_crc32());
|
|
var import_pako = __toModule(require_pako());
|
|
var import_ignore = __toModule(require_ignore());
|
|
var import_pify = __toModule(require_pify());
|
|
var import_clean_git_ref = __toModule(require_lib2());
|
|
var import_diff3 = __toModule(require_diff3());
|
|
var BaseError = class extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.caller = "";
|
|
}
|
|
toJSON() {
|
|
return {
|
|
code: this.code,
|
|
data: this.data,
|
|
caller: this.caller,
|
|
message: this.message,
|
|
stack: this.stack
|
|
};
|
|
}
|
|
fromJSON(json) {
|
|
const e = new BaseError(json.message);
|
|
e.code = json.code;
|
|
e.data = json.data;
|
|
e.caller = json.caller;
|
|
e.stack = json.stack;
|
|
return e;
|
|
}
|
|
get isIsomorphicGitError() {
|
|
return true;
|
|
}
|
|
};
|
|
var InternalError = class extends BaseError {
|
|
constructor(message) {
|
|
super(`An internal error caused this command to fail. Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/issues with this error message: ${message}`);
|
|
this.code = this.name = InternalError.code;
|
|
this.data = { message };
|
|
}
|
|
};
|
|
InternalError.code = "InternalError";
|
|
var UnsafeFilepathError = class extends BaseError {
|
|
constructor(filepath) {
|
|
super(`The filepath "${filepath}" contains unsafe character sequences`);
|
|
this.code = this.name = UnsafeFilepathError.code;
|
|
this.data = { filepath };
|
|
}
|
|
};
|
|
UnsafeFilepathError.code = "UnsafeFilepathError";
|
|
var BufferCursor = class {
|
|
constructor(buffer2) {
|
|
this.buffer = buffer2;
|
|
this._start = 0;
|
|
}
|
|
eof() {
|
|
return this._start >= this.buffer.length;
|
|
}
|
|
tell() {
|
|
return this._start;
|
|
}
|
|
seek(n) {
|
|
this._start = n;
|
|
}
|
|
slice(n) {
|
|
const r = this.buffer.slice(this._start, this._start + n);
|
|
this._start += n;
|
|
return r;
|
|
}
|
|
toString(enc, length) {
|
|
const r = this.buffer.toString(enc, this._start, this._start + length);
|
|
this._start += length;
|
|
return r;
|
|
}
|
|
write(value, length, enc) {
|
|
const r = this.buffer.write(value, this._start, length, enc);
|
|
this._start += length;
|
|
return r;
|
|
}
|
|
copy(source, start, end) {
|
|
const r = source.copy(this.buffer, this._start, start, end);
|
|
this._start += r;
|
|
return r;
|
|
}
|
|
readUInt8() {
|
|
const r = this.buffer.readUInt8(this._start);
|
|
this._start += 1;
|
|
return r;
|
|
}
|
|
writeUInt8(value) {
|
|
const r = this.buffer.writeUInt8(value, this._start);
|
|
this._start += 1;
|
|
return r;
|
|
}
|
|
readUInt16BE() {
|
|
const r = this.buffer.readUInt16BE(this._start);
|
|
this._start += 2;
|
|
return r;
|
|
}
|
|
writeUInt16BE(value) {
|
|
const r = this.buffer.writeUInt16BE(value, this._start);
|
|
this._start += 2;
|
|
return r;
|
|
}
|
|
readUInt32BE() {
|
|
const r = this.buffer.readUInt32BE(this._start);
|
|
this._start += 4;
|
|
return r;
|
|
}
|
|
writeUInt32BE(value) {
|
|
const r = this.buffer.writeUInt32BE(value, this._start);
|
|
this._start += 4;
|
|
return r;
|
|
}
|
|
};
|
|
function compareStrings(a, b) {
|
|
return -(a < b) || +(a > b);
|
|
}
|
|
function comparePath(a, b) {
|
|
return compareStrings(a.path, b.path);
|
|
}
|
|
function normalizeMode(mode) {
|
|
let type = mode > 0 ? mode >> 12 : 0;
|
|
if (type !== 4 && type !== 8 && type !== 10 && type !== 14) {
|
|
type = 8;
|
|
}
|
|
let permissions = mode & 511;
|
|
if (permissions & 73) {
|
|
permissions = 493;
|
|
} else {
|
|
permissions = 420;
|
|
}
|
|
if (type !== 8)
|
|
permissions = 0;
|
|
return (type << 12) + permissions;
|
|
}
|
|
var MAX_UINT32 = 2 ** 32;
|
|
function SecondsNanoseconds(givenSeconds, givenNanoseconds, milliseconds, date) {
|
|
if (givenSeconds !== void 0 && givenNanoseconds !== void 0) {
|
|
return [givenSeconds, givenNanoseconds];
|
|
}
|
|
if (milliseconds === void 0) {
|
|
milliseconds = date.valueOf();
|
|
}
|
|
const seconds = Math.floor(milliseconds / 1e3);
|
|
const nanoseconds = (milliseconds - seconds * 1e3) * 1e6;
|
|
return [seconds, nanoseconds];
|
|
}
|
|
function normalizeStats(e) {
|
|
const [ctimeSeconds, ctimeNanoseconds] = SecondsNanoseconds(e.ctimeSeconds, e.ctimeNanoseconds, e.ctimeMs, e.ctime);
|
|
const [mtimeSeconds, mtimeNanoseconds] = SecondsNanoseconds(e.mtimeSeconds, e.mtimeNanoseconds, e.mtimeMs, e.mtime);
|
|
return {
|
|
ctimeSeconds: ctimeSeconds % MAX_UINT32,
|
|
ctimeNanoseconds: ctimeNanoseconds % MAX_UINT32,
|
|
mtimeSeconds: mtimeSeconds % MAX_UINT32,
|
|
mtimeNanoseconds: mtimeNanoseconds % MAX_UINT32,
|
|
dev: e.dev % MAX_UINT32,
|
|
ino: e.ino % MAX_UINT32,
|
|
mode: normalizeMode(e.mode % MAX_UINT32),
|
|
uid: e.uid % MAX_UINT32,
|
|
gid: e.gid % MAX_UINT32,
|
|
size: e.size > -1 ? e.size % MAX_UINT32 : 0
|
|
};
|
|
}
|
|
function toHex(buffer2) {
|
|
let hex = "";
|
|
for (const byte of new Uint8Array(buffer2)) {
|
|
if (byte < 16)
|
|
hex += "0";
|
|
hex += byte.toString(16);
|
|
}
|
|
return hex;
|
|
}
|
|
var supportsSubtleSHA1 = null;
|
|
async function shasum(buffer2) {
|
|
if (supportsSubtleSHA1 === null) {
|
|
supportsSubtleSHA1 = await testSubtleSHA1();
|
|
}
|
|
return supportsSubtleSHA1 ? subtleSHA1(buffer2) : shasumSync(buffer2);
|
|
}
|
|
function shasumSync(buffer2) {
|
|
return new import_sha1.default().update(buffer2).digest("hex");
|
|
}
|
|
async function subtleSHA1(buffer2) {
|
|
const hash2 = await crypto.subtle.digest("SHA-1", buffer2);
|
|
return toHex(hash2);
|
|
}
|
|
async function testSubtleSHA1() {
|
|
try {
|
|
const hash2 = await subtleSHA1(new Uint8Array([]));
|
|
if (hash2 === "da39a3ee5e6b4b0d3255bfef95601890afd80709")
|
|
return true;
|
|
} catch (_) {
|
|
}
|
|
return false;
|
|
}
|
|
function parseCacheEntryFlags(bits) {
|
|
return {
|
|
assumeValid: Boolean(bits & 32768),
|
|
extended: Boolean(bits & 16384),
|
|
stage: (bits & 12288) >> 12,
|
|
nameLength: bits & 4095
|
|
};
|
|
}
|
|
function renderCacheEntryFlags(entry) {
|
|
const flags = entry.flags;
|
|
flags.extended = false;
|
|
flags.nameLength = Math.min(Buffer2.from(entry.path).length, 4095);
|
|
return (flags.assumeValid ? 32768 : 0) + (flags.extended ? 16384 : 0) + ((flags.stage & 3) << 12) + (flags.nameLength & 4095);
|
|
}
|
|
var GitIndex = class {
|
|
constructor(entries) {
|
|
this._dirty = false;
|
|
this._entries = entries || new Map();
|
|
}
|
|
static async from(buffer2) {
|
|
if (Buffer2.isBuffer(buffer2)) {
|
|
return GitIndex.fromBuffer(buffer2);
|
|
} else if (buffer2 === null) {
|
|
return new GitIndex(null);
|
|
} else {
|
|
throw new InternalError("invalid type passed to GitIndex.from");
|
|
}
|
|
}
|
|
static async fromBuffer(buffer2) {
|
|
const shaComputed = await shasum(buffer2.slice(0, -20));
|
|
const shaClaimed = buffer2.slice(-20).toString("hex");
|
|
if (shaClaimed !== shaComputed) {
|
|
throw new InternalError(`Invalid checksum in GitIndex buffer: expected ${shaClaimed} but saw ${shaComputed}`);
|
|
}
|
|
const reader = new BufferCursor(buffer2);
|
|
const _entries = new Map();
|
|
const magic = reader.toString("utf8", 4);
|
|
if (magic !== "DIRC") {
|
|
throw new InternalError(`Inavlid dircache magic file number: ${magic}`);
|
|
}
|
|
const version2 = reader.readUInt32BE();
|
|
if (version2 !== 2) {
|
|
throw new InternalError(`Unsupported dircache version: ${version2}`);
|
|
}
|
|
const numEntries = reader.readUInt32BE();
|
|
let i = 0;
|
|
while (!reader.eof() && i < numEntries) {
|
|
const entry = {};
|
|
entry.ctimeSeconds = reader.readUInt32BE();
|
|
entry.ctimeNanoseconds = reader.readUInt32BE();
|
|
entry.mtimeSeconds = reader.readUInt32BE();
|
|
entry.mtimeNanoseconds = reader.readUInt32BE();
|
|
entry.dev = reader.readUInt32BE();
|
|
entry.ino = reader.readUInt32BE();
|
|
entry.mode = reader.readUInt32BE();
|
|
entry.uid = reader.readUInt32BE();
|
|
entry.gid = reader.readUInt32BE();
|
|
entry.size = reader.readUInt32BE();
|
|
entry.oid = reader.slice(20).toString("hex");
|
|
const flags = reader.readUInt16BE();
|
|
entry.flags = parseCacheEntryFlags(flags);
|
|
const pathlength = buffer2.indexOf(0, reader.tell() + 1) - reader.tell();
|
|
if (pathlength < 1) {
|
|
throw new InternalError(`Got a path length of: ${pathlength}`);
|
|
}
|
|
entry.path = reader.toString("utf8", pathlength);
|
|
if (entry.path.includes("..\\") || entry.path.includes("../")) {
|
|
throw new UnsafeFilepathError(entry.path);
|
|
}
|
|
let padding = 8 - (reader.tell() - 12) % 8;
|
|
if (padding === 0)
|
|
padding = 8;
|
|
while (padding--) {
|
|
const tmp = reader.readUInt8();
|
|
if (tmp !== 0) {
|
|
throw new InternalError(`Expected 1-8 null characters but got '${tmp}' after ${entry.path}`);
|
|
} else if (reader.eof()) {
|
|
throw new InternalError("Unexpected end of file");
|
|
}
|
|
}
|
|
_entries.set(entry.path, entry);
|
|
i++;
|
|
}
|
|
return new GitIndex(_entries);
|
|
}
|
|
get entries() {
|
|
return [...this._entries.values()].sort(comparePath);
|
|
}
|
|
get entriesMap() {
|
|
return this._entries;
|
|
}
|
|
*[Symbol.iterator]() {
|
|
for (const entry of this.entries) {
|
|
yield entry;
|
|
}
|
|
}
|
|
insert({ filepath, stats, oid }) {
|
|
stats = normalizeStats(stats);
|
|
const bfilepath = Buffer2.from(filepath);
|
|
const entry = {
|
|
ctimeSeconds: stats.ctimeSeconds,
|
|
ctimeNanoseconds: stats.ctimeNanoseconds,
|
|
mtimeSeconds: stats.mtimeSeconds,
|
|
mtimeNanoseconds: stats.mtimeNanoseconds,
|
|
dev: stats.dev,
|
|
ino: stats.ino,
|
|
mode: stats.mode || 33188,
|
|
uid: stats.uid,
|
|
gid: stats.gid,
|
|
size: stats.size,
|
|
path: filepath,
|
|
oid,
|
|
flags: {
|
|
assumeValid: false,
|
|
extended: false,
|
|
stage: 0,
|
|
nameLength: bfilepath.length < 4095 ? bfilepath.length : 4095
|
|
}
|
|
};
|
|
this._entries.set(entry.path, entry);
|
|
this._dirty = true;
|
|
}
|
|
delete({ filepath }) {
|
|
if (this._entries.has(filepath)) {
|
|
this._entries.delete(filepath);
|
|
} else {
|
|
for (const key2 of this._entries.keys()) {
|
|
if (key2.startsWith(filepath + "/")) {
|
|
this._entries.delete(key2);
|
|
}
|
|
}
|
|
}
|
|
this._dirty = true;
|
|
}
|
|
clear() {
|
|
this._entries.clear();
|
|
this._dirty = true;
|
|
}
|
|
has({ filepath }) {
|
|
return this._entries.has(filepath);
|
|
}
|
|
render() {
|
|
return this.entries.map((entry) => `${entry.mode.toString(8)} ${entry.oid} ${entry.path}`).join("\n");
|
|
}
|
|
async toObject() {
|
|
const header = Buffer2.alloc(12);
|
|
const writer = new BufferCursor(header);
|
|
writer.write("DIRC", 4, "utf8");
|
|
writer.writeUInt32BE(2);
|
|
writer.writeUInt32BE(this.entries.length);
|
|
const body = Buffer2.concat(this.entries.map((entry) => {
|
|
const bpath = Buffer2.from(entry.path);
|
|
const length = Math.ceil((62 + bpath.length + 1) / 8) * 8;
|
|
const written = Buffer2.alloc(length);
|
|
const writer2 = new BufferCursor(written);
|
|
const stat = normalizeStats(entry);
|
|
writer2.writeUInt32BE(stat.ctimeSeconds);
|
|
writer2.writeUInt32BE(stat.ctimeNanoseconds);
|
|
writer2.writeUInt32BE(stat.mtimeSeconds);
|
|
writer2.writeUInt32BE(stat.mtimeNanoseconds);
|
|
writer2.writeUInt32BE(stat.dev);
|
|
writer2.writeUInt32BE(stat.ino);
|
|
writer2.writeUInt32BE(stat.mode);
|
|
writer2.writeUInt32BE(stat.uid);
|
|
writer2.writeUInt32BE(stat.gid);
|
|
writer2.writeUInt32BE(stat.size);
|
|
writer2.write(entry.oid, 20, "hex");
|
|
writer2.writeUInt16BE(renderCacheEntryFlags(entry));
|
|
writer2.write(entry.path, bpath.length, "utf8");
|
|
return written;
|
|
}));
|
|
const main = Buffer2.concat([header, body]);
|
|
const sum = await shasum(main);
|
|
return Buffer2.concat([main, Buffer2.from(sum, "hex")]);
|
|
}
|
|
};
|
|
function compareStats(entry, stats) {
|
|
const e = normalizeStats(entry);
|
|
const s = normalizeStats(stats);
|
|
const staleness = e.mode !== s.mode || e.mtimeSeconds !== s.mtimeSeconds || e.ctimeSeconds !== s.ctimeSeconds || e.uid !== s.uid || e.gid !== s.gid || e.ino !== s.ino || e.size !== s.size;
|
|
return staleness;
|
|
}
|
|
var lock = null;
|
|
var IndexCache = Symbol("IndexCache");
|
|
function createCache() {
|
|
return {
|
|
map: new Map(),
|
|
stats: new Map()
|
|
};
|
|
}
|
|
async function updateCachedIndexFile(fs, filepath, cache) {
|
|
const stat = await fs.lstat(filepath);
|
|
const rawIndexFile = await fs.read(filepath);
|
|
const index2 = await GitIndex.from(rawIndexFile);
|
|
cache.map.set(filepath, index2);
|
|
cache.stats.set(filepath, stat);
|
|
}
|
|
async function isIndexStale(fs, filepath, cache) {
|
|
const savedStats = cache.stats.get(filepath);
|
|
if (savedStats === void 0)
|
|
return true;
|
|
const currStats = await fs.lstat(filepath);
|
|
if (savedStats === null)
|
|
return false;
|
|
if (currStats === null)
|
|
return false;
|
|
return compareStats(savedStats, currStats);
|
|
}
|
|
var GitIndexManager = class {
|
|
static async acquire({ fs, gitdir, cache }, closure) {
|
|
if (!cache[IndexCache])
|
|
cache[IndexCache] = createCache();
|
|
const filepath = `${gitdir}/index`;
|
|
if (lock === null)
|
|
lock = new import_async_lock.default({ maxPending: Infinity });
|
|
let result;
|
|
await lock.acquire(filepath, async () => {
|
|
if (await isIndexStale(fs, filepath, cache[IndexCache])) {
|
|
await updateCachedIndexFile(fs, filepath, cache[IndexCache]);
|
|
}
|
|
const index2 = cache[IndexCache].map.get(filepath);
|
|
result = await closure(index2);
|
|
if (index2._dirty) {
|
|
const buffer2 = await index2.toObject();
|
|
await fs.write(filepath, buffer2);
|
|
cache[IndexCache].stats.set(filepath, await fs.lstat(filepath));
|
|
index2._dirty = false;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
};
|
|
function basename(path2) {
|
|
const last2 = Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\"));
|
|
if (last2 > -1) {
|
|
path2 = path2.slice(last2 + 1);
|
|
}
|
|
return path2;
|
|
}
|
|
function dirname(path2) {
|
|
const last2 = Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\"));
|
|
if (last2 === -1)
|
|
return ".";
|
|
if (last2 === 0)
|
|
return "/";
|
|
return path2.slice(0, last2);
|
|
}
|
|
function flatFileListToDirectoryStructure(files) {
|
|
const inodes = new Map();
|
|
const mkdir = function(name) {
|
|
if (!inodes.has(name)) {
|
|
const dir = {
|
|
type: "tree",
|
|
fullpath: name,
|
|
basename: basename(name),
|
|
metadata: {},
|
|
children: []
|
|
};
|
|
inodes.set(name, dir);
|
|
dir.parent = mkdir(dirname(name));
|
|
if (dir.parent && dir.parent !== dir)
|
|
dir.parent.children.push(dir);
|
|
}
|
|
return inodes.get(name);
|
|
};
|
|
const mkfile = function(name, metadata) {
|
|
if (!inodes.has(name)) {
|
|
const file = {
|
|
type: "blob",
|
|
fullpath: name,
|
|
basename: basename(name),
|
|
metadata,
|
|
parent: mkdir(dirname(name)),
|
|
children: []
|
|
};
|
|
if (file.parent)
|
|
file.parent.children.push(file);
|
|
inodes.set(name, file);
|
|
}
|
|
return inodes.get(name);
|
|
};
|
|
mkdir(".");
|
|
for (const file of files) {
|
|
mkfile(file.path, file);
|
|
}
|
|
return inodes;
|
|
}
|
|
function mode2type(mode) {
|
|
switch (mode) {
|
|
case 16384:
|
|
return "tree";
|
|
case 33188:
|
|
return "blob";
|
|
case 33261:
|
|
return "blob";
|
|
case 40960:
|
|
return "blob";
|
|
case 57344:
|
|
return "commit";
|
|
}
|
|
throw new InternalError(`Unexpected GitTree entry mode: ${mode.toString(8)}`);
|
|
}
|
|
var GitWalkerIndex = class {
|
|
constructor({ fs, gitdir, cache }) {
|
|
this.treePromise = GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
return flatFileListToDirectoryStructure(index2.entries);
|
|
});
|
|
const walker = this;
|
|
this.ConstructEntry = class StageEntry {
|
|
constructor(fullpath) {
|
|
this._fullpath = fullpath;
|
|
this._type = false;
|
|
this._mode = false;
|
|
this._stat = false;
|
|
this._oid = false;
|
|
}
|
|
async type() {
|
|
return walker.type(this);
|
|
}
|
|
async mode() {
|
|
return walker.mode(this);
|
|
}
|
|
async stat() {
|
|
return walker.stat(this);
|
|
}
|
|
async content() {
|
|
return walker.content(this);
|
|
}
|
|
async oid() {
|
|
return walker.oid(this);
|
|
}
|
|
};
|
|
}
|
|
async readdir(entry) {
|
|
const filepath = entry._fullpath;
|
|
const tree = await this.treePromise;
|
|
const inode = tree.get(filepath);
|
|
if (!inode)
|
|
return null;
|
|
if (inode.type === "blob")
|
|
return null;
|
|
if (inode.type !== "tree") {
|
|
throw new Error(`ENOTDIR: not a directory, scandir '${filepath}'`);
|
|
}
|
|
const names = inode.children.map((inode2) => inode2.fullpath);
|
|
names.sort(compareStrings);
|
|
return names;
|
|
}
|
|
async type(entry) {
|
|
if (entry._type === false) {
|
|
await entry.stat();
|
|
}
|
|
return entry._type;
|
|
}
|
|
async mode(entry) {
|
|
if (entry._mode === false) {
|
|
await entry.stat();
|
|
}
|
|
return entry._mode;
|
|
}
|
|
async stat(entry) {
|
|
if (entry._stat === false) {
|
|
const tree = await this.treePromise;
|
|
const inode = tree.get(entry._fullpath);
|
|
if (!inode) {
|
|
throw new Error(`ENOENT: no such file or directory, lstat '${entry._fullpath}'`);
|
|
}
|
|
const stats = inode.type === "tree" ? {} : normalizeStats(inode.metadata);
|
|
entry._type = inode.type === "tree" ? "tree" : mode2type(stats.mode);
|
|
entry._mode = stats.mode;
|
|
if (inode.type === "tree") {
|
|
entry._stat = void 0;
|
|
} else {
|
|
entry._stat = stats;
|
|
}
|
|
}
|
|
return entry._stat;
|
|
}
|
|
async content(_entry) {
|
|
}
|
|
async oid(entry) {
|
|
if (entry._oid === false) {
|
|
const tree = await this.treePromise;
|
|
const inode = tree.get(entry._fullpath);
|
|
entry._oid = inode.metadata.oid;
|
|
}
|
|
return entry._oid;
|
|
}
|
|
};
|
|
var GitWalkSymbol = Symbol("GitWalkSymbol");
|
|
function STAGE() {
|
|
const o = Object.create(null);
|
|
Object.defineProperty(o, GitWalkSymbol, {
|
|
value: function({ fs, gitdir, cache }) {
|
|
return new GitWalkerIndex({ fs, gitdir, cache });
|
|
}
|
|
});
|
|
Object.freeze(o);
|
|
return o;
|
|
}
|
|
var NotFoundError = class extends BaseError {
|
|
constructor(what) {
|
|
super(`Could not find ${what}.`);
|
|
this.code = this.name = NotFoundError.code;
|
|
this.data = { what };
|
|
}
|
|
};
|
|
NotFoundError.code = "NotFoundError";
|
|
var ObjectTypeError = class extends BaseError {
|
|
constructor(oid, actual, expected, filepath) {
|
|
super(`Object ${oid} ${filepath ? `at ${filepath}` : ""}was anticipated to be a ${expected} but it is a ${actual}.`);
|
|
this.code = this.name = ObjectTypeError.code;
|
|
this.data = { oid, actual, expected, filepath };
|
|
}
|
|
};
|
|
ObjectTypeError.code = "ObjectTypeError";
|
|
var InvalidOidError = class extends BaseError {
|
|
constructor(value) {
|
|
super(`Expected a 40-char hex object id but saw "${value}".`);
|
|
this.code = this.name = InvalidOidError.code;
|
|
this.data = { value };
|
|
}
|
|
};
|
|
InvalidOidError.code = "InvalidOidError";
|
|
var NoRefspecError = class extends BaseError {
|
|
constructor(remote) {
|
|
super(`Could not find a fetch refspec for remote "${remote}". Make sure the config file has an entry like the following:
|
|
[remote "${remote}"]
|
|
fetch = +refs/heads/*:refs/remotes/origin/*
|
|
`);
|
|
this.code = this.name = NoRefspecError.code;
|
|
this.data = { remote };
|
|
}
|
|
};
|
|
NoRefspecError.code = "NoRefspecError";
|
|
var GitPackedRefs = class {
|
|
constructor(text2) {
|
|
this.refs = new Map();
|
|
this.parsedConfig = [];
|
|
if (text2) {
|
|
let key2 = null;
|
|
this.parsedConfig = text2.trim().split("\n").map((line) => {
|
|
if (/^\s*#/.test(line)) {
|
|
return { line, comment: true };
|
|
}
|
|
const i = line.indexOf(" ");
|
|
if (line.startsWith("^")) {
|
|
const value = line.slice(1);
|
|
this.refs.set(key2 + "^{}", value);
|
|
return { line, ref: key2, peeled: value };
|
|
} else {
|
|
const value = line.slice(0, i);
|
|
key2 = line.slice(i + 1);
|
|
this.refs.set(key2, value);
|
|
return { line, ref: key2, oid: value };
|
|
}
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
static from(text2) {
|
|
return new GitPackedRefs(text2);
|
|
}
|
|
delete(ref) {
|
|
this.parsedConfig = this.parsedConfig.filter((entry) => entry.ref !== ref);
|
|
this.refs.delete(ref);
|
|
}
|
|
toString() {
|
|
return this.parsedConfig.map(({ line }) => line).join("\n") + "\n";
|
|
}
|
|
};
|
|
var GitRefSpec = class {
|
|
constructor({ remotePath, localPath, force, matchPrefix }) {
|
|
Object.assign(this, {
|
|
remotePath,
|
|
localPath,
|
|
force,
|
|
matchPrefix
|
|
});
|
|
}
|
|
static from(refspec) {
|
|
const [
|
|
forceMatch,
|
|
remotePath,
|
|
remoteGlobMatch,
|
|
localPath,
|
|
localGlobMatch
|
|
] = refspec.match(/^(\+?)(.*?)(\*?):(.*?)(\*?)$/).slice(1);
|
|
const force = forceMatch === "+";
|
|
const remoteIsGlob = remoteGlobMatch === "*";
|
|
const localIsGlob = localGlobMatch === "*";
|
|
if (remoteIsGlob !== localIsGlob) {
|
|
throw new InternalError("Invalid refspec");
|
|
}
|
|
return new GitRefSpec({
|
|
remotePath,
|
|
localPath,
|
|
force,
|
|
matchPrefix: remoteIsGlob
|
|
});
|
|
}
|
|
translate(remoteBranch) {
|
|
if (this.matchPrefix) {
|
|
if (remoteBranch.startsWith(this.remotePath)) {
|
|
return this.localPath + remoteBranch.replace(this.remotePath, "");
|
|
}
|
|
} else {
|
|
if (remoteBranch === this.remotePath)
|
|
return this.localPath;
|
|
}
|
|
return null;
|
|
}
|
|
reverseTranslate(localBranch) {
|
|
if (this.matchPrefix) {
|
|
if (localBranch.startsWith(this.localPath)) {
|
|
return this.remotePath + localBranch.replace(this.localPath, "");
|
|
}
|
|
} else {
|
|
if (localBranch === this.localPath)
|
|
return this.remotePath;
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
var GitRefSpecSet = class {
|
|
constructor(rules = []) {
|
|
this.rules = rules;
|
|
}
|
|
static from(refspecs) {
|
|
const rules = [];
|
|
for (const refspec of refspecs) {
|
|
rules.push(GitRefSpec.from(refspec));
|
|
}
|
|
return new GitRefSpecSet(rules);
|
|
}
|
|
add(refspec) {
|
|
const rule = GitRefSpec.from(refspec);
|
|
this.rules.push(rule);
|
|
}
|
|
translate(remoteRefs) {
|
|
const result = [];
|
|
for (const rule of this.rules) {
|
|
for (const remoteRef of remoteRefs) {
|
|
const localRef = rule.translate(remoteRef);
|
|
if (localRef) {
|
|
result.push([remoteRef, localRef]);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
translateOne(remoteRef) {
|
|
let result = null;
|
|
for (const rule of this.rules) {
|
|
const localRef = rule.translate(remoteRef);
|
|
if (localRef) {
|
|
result = localRef;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
localNamespaces() {
|
|
return this.rules.filter((rule) => rule.matchPrefix).map((rule) => rule.localPath.replace(/\/$/, ""));
|
|
}
|
|
};
|
|
function compareRefNames(a, b) {
|
|
const _a2 = a.replace(/\^\{\}$/, "");
|
|
const _b = b.replace(/\^\{\}$/, "");
|
|
const tmp = -(_a2 < _b) || +(_a2 > _b);
|
|
if (tmp === 0) {
|
|
return a.endsWith("^{}") ? 1 : -1;
|
|
}
|
|
return tmp;
|
|
}
|
|
function normalizePath(path2) {
|
|
return path2.replace(/\/\.\//g, "/").replace(/\/{2,}/g, "/").replace(/^\/\.$/, "/").replace(/^\.\/$/, ".").replace(/^\.\//, "").replace(/\/\.$/, "").replace(/(.+)\/$/, "$1").replace(/^$/, ".");
|
|
}
|
|
function join(...parts) {
|
|
return normalizePath(parts.map(normalizePath).join("/"));
|
|
}
|
|
var num = (val) => {
|
|
val = val.toLowerCase();
|
|
let n = parseInt(val);
|
|
if (val.endsWith("k"))
|
|
n *= 1024;
|
|
if (val.endsWith("m"))
|
|
n *= 1024 * 1024;
|
|
if (val.endsWith("g"))
|
|
n *= 1024 * 1024 * 1024;
|
|
return n;
|
|
};
|
|
var bool = (val) => {
|
|
val = val.trim().toLowerCase();
|
|
if (val === "true" || val === "yes" || val === "on")
|
|
return true;
|
|
if (val === "false" || val === "no" || val === "off")
|
|
return false;
|
|
throw Error(`Expected 'true', 'false', 'yes', 'no', 'on', or 'off', but got ${val}`);
|
|
};
|
|
var schema = {
|
|
core: {
|
|
filemode: bool,
|
|
bare: bool,
|
|
logallrefupdates: bool,
|
|
symlinks: bool,
|
|
ignorecase: bool,
|
|
bigFileThreshold: num
|
|
}
|
|
};
|
|
var SECTION_LINE_REGEX = /^\[([A-Za-z0-9-.]+)(?: "(.*)")?\]$/;
|
|
var SECTION_REGEX = /^[A-Za-z0-9-.]+$/;
|
|
var VARIABLE_LINE_REGEX = /^([A-Za-z][A-Za-z-]*)(?: *= *(.*))?$/;
|
|
var VARIABLE_NAME_REGEX = /^[A-Za-z][A-Za-z-]*$/;
|
|
var VARIABLE_VALUE_COMMENT_REGEX = /^(.*?)( *[#;].*)$/;
|
|
var extractSectionLine = (line) => {
|
|
const matches = SECTION_LINE_REGEX.exec(line);
|
|
if (matches != null) {
|
|
const [section, subsection] = matches.slice(1);
|
|
return [section, subsection];
|
|
}
|
|
return null;
|
|
};
|
|
var extractVariableLine = (line) => {
|
|
const matches = VARIABLE_LINE_REGEX.exec(line);
|
|
if (matches != null) {
|
|
const [name, rawValue = "true"] = matches.slice(1);
|
|
const valueWithoutComments = removeComments(rawValue);
|
|
const valueWithoutQuotes = removeQuotes(valueWithoutComments);
|
|
return [name, valueWithoutQuotes];
|
|
}
|
|
return null;
|
|
};
|
|
var removeComments = (rawValue) => {
|
|
const commentMatches = VARIABLE_VALUE_COMMENT_REGEX.exec(rawValue);
|
|
if (commentMatches == null) {
|
|
return rawValue;
|
|
}
|
|
const [valueWithoutComment, comment] = commentMatches.slice(1);
|
|
if (hasOddNumberOfQuotes(valueWithoutComment) && hasOddNumberOfQuotes(comment)) {
|
|
return `${valueWithoutComment}${comment}`;
|
|
}
|
|
return valueWithoutComment;
|
|
};
|
|
var hasOddNumberOfQuotes = (text2) => {
|
|
const numberOfQuotes = (text2.match(/(?:^|[^\\])"/g) || []).length;
|
|
return numberOfQuotes % 2 !== 0;
|
|
};
|
|
var removeQuotes = (text2) => {
|
|
return text2.split("").reduce((newText, c, idx, text3) => {
|
|
const isQuote = c === '"' && text3[idx - 1] !== "\\";
|
|
const isEscapeForQuote = c === "\\" && text3[idx + 1] === '"';
|
|
if (isQuote || isEscapeForQuote) {
|
|
return newText;
|
|
}
|
|
return newText + c;
|
|
}, "");
|
|
};
|
|
var lower = (text2) => {
|
|
return text2 != null ? text2.toLowerCase() : null;
|
|
};
|
|
var getPath = (section, subsection, name) => {
|
|
return [lower(section), subsection, lower(name)].filter((a) => a != null).join(".");
|
|
};
|
|
var normalizePath$1 = (path2) => {
|
|
const pathSegments = path2.split(".");
|
|
const section = pathSegments.shift();
|
|
const name = pathSegments.pop();
|
|
const subsection = pathSegments.length ? pathSegments.join(".") : void 0;
|
|
return {
|
|
section,
|
|
subsection,
|
|
name,
|
|
path: getPath(section, subsection, name),
|
|
sectionPath: getPath(section, subsection, null)
|
|
};
|
|
};
|
|
var findLastIndex = (array, callback) => {
|
|
return array.reduce((lastIndex, item, index2) => {
|
|
return callback(item) ? index2 : lastIndex;
|
|
}, -1);
|
|
};
|
|
var GitConfig = class {
|
|
constructor(text2) {
|
|
let section = null;
|
|
let subsection = null;
|
|
this.parsedConfig = text2.split("\n").map((line) => {
|
|
let name = null;
|
|
let value = null;
|
|
const trimmedLine = line.trim();
|
|
const extractedSection = extractSectionLine(trimmedLine);
|
|
const isSection = extractedSection != null;
|
|
if (isSection) {
|
|
;
|
|
[section, subsection] = extractedSection;
|
|
} else {
|
|
const extractedVariable = extractVariableLine(trimmedLine);
|
|
const isVariable = extractedVariable != null;
|
|
if (isVariable) {
|
|
;
|
|
[name, value] = extractedVariable;
|
|
}
|
|
}
|
|
const path2 = getPath(section, subsection, name);
|
|
return { line, isSection, section, subsection, name, value, path: path2 };
|
|
});
|
|
}
|
|
static from(text2) {
|
|
return new GitConfig(text2);
|
|
}
|
|
async get(path2, getall = false) {
|
|
const normalizedPath = normalizePath$1(path2).path;
|
|
const allValues = this.parsedConfig.filter((config) => config.path === normalizedPath).map(({ section, name, value }) => {
|
|
const fn = schema[section] && schema[section][name];
|
|
return fn ? fn(value) : value;
|
|
});
|
|
return getall ? allValues : allValues.pop();
|
|
}
|
|
async getall(path2) {
|
|
return this.get(path2, true);
|
|
}
|
|
async getSubsections(section) {
|
|
return this.parsedConfig.filter((config) => config.section === section && config.isSection).map((config) => config.subsection);
|
|
}
|
|
async deleteSection(section, subsection) {
|
|
this.parsedConfig = this.parsedConfig.filter((config) => !(config.section === section && config.subsection === subsection));
|
|
}
|
|
async append(path2, value) {
|
|
return this.set(path2, value, true);
|
|
}
|
|
async set(path2, value, append3 = false) {
|
|
const {
|
|
section,
|
|
subsection,
|
|
name,
|
|
path: normalizedPath,
|
|
sectionPath
|
|
} = normalizePath$1(path2);
|
|
const configIndex = findLastIndex(this.parsedConfig, (config) => config.path === normalizedPath);
|
|
if (value == null) {
|
|
if (configIndex !== -1) {
|
|
this.parsedConfig.splice(configIndex, 1);
|
|
}
|
|
} else {
|
|
if (configIndex !== -1) {
|
|
const config = this.parsedConfig[configIndex];
|
|
const modifiedConfig = Object.assign({}, config, {
|
|
name,
|
|
value,
|
|
modified: true
|
|
});
|
|
if (append3) {
|
|
this.parsedConfig.splice(configIndex + 1, 0, modifiedConfig);
|
|
} else {
|
|
this.parsedConfig[configIndex] = modifiedConfig;
|
|
}
|
|
} else {
|
|
const sectionIndex = this.parsedConfig.findIndex((config) => config.path === sectionPath);
|
|
const newConfig = {
|
|
section,
|
|
subsection,
|
|
name,
|
|
value,
|
|
modified: true,
|
|
path: normalizedPath
|
|
};
|
|
if (SECTION_REGEX.test(section) && VARIABLE_NAME_REGEX.test(name)) {
|
|
if (sectionIndex >= 0) {
|
|
this.parsedConfig.splice(sectionIndex + 1, 0, newConfig);
|
|
} else {
|
|
const newSection = {
|
|
section,
|
|
subsection,
|
|
modified: true,
|
|
path: sectionPath
|
|
};
|
|
this.parsedConfig.push(newSection, newConfig);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
toString() {
|
|
return this.parsedConfig.map(({ line, section, subsection, name, value, modified: modified2 = false }) => {
|
|
if (!modified2) {
|
|
return line;
|
|
}
|
|
if (name != null && value != null) {
|
|
if (typeof value === "string" && /[#;]/.test(value)) {
|
|
return ` ${name} = "${value}"`;
|
|
}
|
|
return ` ${name} = ${value}`;
|
|
}
|
|
if (subsection != null) {
|
|
return `[${section} "${subsection}"]`;
|
|
}
|
|
return `[${section}]`;
|
|
}).join("\n");
|
|
}
|
|
};
|
|
var GitConfigManager = class {
|
|
static async get({ fs, gitdir }) {
|
|
const text2 = await fs.read(`${gitdir}/config`, { encoding: "utf8" });
|
|
return GitConfig.from(text2);
|
|
}
|
|
static async save({ fs, gitdir, config }) {
|
|
await fs.write(`${gitdir}/config`, config.toString(), {
|
|
encoding: "utf8"
|
|
});
|
|
}
|
|
};
|
|
var refpaths = (ref) => [
|
|
`${ref}`,
|
|
`refs/${ref}`,
|
|
`refs/tags/${ref}`,
|
|
`refs/heads/${ref}`,
|
|
`refs/remotes/${ref}`,
|
|
`refs/remotes/${ref}/HEAD`
|
|
];
|
|
var GIT_FILES = ["config", "description", "index", "shallow", "commondir"];
|
|
var GitRefManager = class {
|
|
static async updateRemoteRefs({
|
|
fs,
|
|
gitdir,
|
|
remote,
|
|
refs,
|
|
symrefs,
|
|
tags,
|
|
refspecs = void 0,
|
|
prune = false,
|
|
pruneTags = false
|
|
}) {
|
|
for (const value of refs.values()) {
|
|
if (!value.match(/[0-9a-f]{40}/)) {
|
|
throw new InvalidOidError(value);
|
|
}
|
|
}
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
if (!refspecs) {
|
|
refspecs = await config.getall(`remote.${remote}.fetch`);
|
|
if (refspecs.length === 0) {
|
|
throw new NoRefspecError(remote);
|
|
}
|
|
refspecs.unshift(`+HEAD:refs/remotes/${remote}/HEAD`);
|
|
}
|
|
const refspec = GitRefSpecSet.from(refspecs);
|
|
const actualRefsToWrite = new Map();
|
|
if (pruneTags) {
|
|
const tags2 = await GitRefManager.listRefs({
|
|
fs,
|
|
gitdir,
|
|
filepath: "refs/tags"
|
|
});
|
|
await GitRefManager.deleteRefs({
|
|
fs,
|
|
gitdir,
|
|
refs: tags2.map((tag2) => `refs/tags/${tag2}`)
|
|
});
|
|
}
|
|
if (tags) {
|
|
for (const serverRef of refs.keys()) {
|
|
if (serverRef.startsWith("refs/tags") && !serverRef.endsWith("^{}")) {
|
|
if (!await GitRefManager.exists({ fs, gitdir, ref: serverRef })) {
|
|
const oid = refs.get(serverRef);
|
|
actualRefsToWrite.set(serverRef, oid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const refTranslations = refspec.translate([...refs.keys()]);
|
|
for (const [serverRef, translatedRef] of refTranslations) {
|
|
const value = refs.get(serverRef);
|
|
actualRefsToWrite.set(translatedRef, value);
|
|
}
|
|
const symrefTranslations = refspec.translate([...symrefs.keys()]);
|
|
for (const [serverRef, translatedRef] of symrefTranslations) {
|
|
const value = symrefs.get(serverRef);
|
|
const symtarget = refspec.translateOne(value);
|
|
if (symtarget) {
|
|
actualRefsToWrite.set(translatedRef, `ref: ${symtarget}`);
|
|
}
|
|
}
|
|
const pruned = [];
|
|
if (prune) {
|
|
for (const filepath of refspec.localNamespaces()) {
|
|
const refs2 = (await GitRefManager.listRefs({
|
|
fs,
|
|
gitdir,
|
|
filepath
|
|
})).map((file) => `${filepath}/${file}`);
|
|
for (const ref of refs2) {
|
|
if (!actualRefsToWrite.has(ref)) {
|
|
pruned.push(ref);
|
|
}
|
|
}
|
|
}
|
|
if (pruned.length > 0) {
|
|
await GitRefManager.deleteRefs({ fs, gitdir, refs: pruned });
|
|
}
|
|
}
|
|
for (const [key2, value] of actualRefsToWrite) {
|
|
await fs.write(join(gitdir, key2), `${value.trim()}
|
|
`, "utf8");
|
|
}
|
|
return { pruned };
|
|
}
|
|
static async writeRef({ fs, gitdir, ref, value }) {
|
|
if (!value.match(/[0-9a-f]{40}/)) {
|
|
throw new InvalidOidError(value);
|
|
}
|
|
await fs.write(join(gitdir, ref), `${value.trim()}
|
|
`, "utf8");
|
|
}
|
|
static async writeSymbolicRef({ fs, gitdir, ref, value }) {
|
|
await fs.write(join(gitdir, ref), `ref: ${value.trim()}
|
|
`, "utf8");
|
|
}
|
|
static async deleteRef({ fs, gitdir, ref }) {
|
|
return GitRefManager.deleteRefs({ fs, gitdir, refs: [ref] });
|
|
}
|
|
static async deleteRefs({ fs, gitdir, refs }) {
|
|
await Promise.all(refs.map((ref) => fs.rm(join(gitdir, ref))));
|
|
let text2 = await fs.read(`${gitdir}/packed-refs`, { encoding: "utf8" });
|
|
const packed = GitPackedRefs.from(text2);
|
|
const beforeSize = packed.refs.size;
|
|
for (const ref of refs) {
|
|
if (packed.refs.has(ref)) {
|
|
packed.delete(ref);
|
|
}
|
|
}
|
|
if (packed.refs.size < beforeSize) {
|
|
text2 = packed.toString();
|
|
await fs.write(`${gitdir}/packed-refs`, text2, { encoding: "utf8" });
|
|
}
|
|
}
|
|
static async resolve({ fs, gitdir, ref, depth = void 0 }) {
|
|
if (depth !== void 0) {
|
|
depth--;
|
|
if (depth === -1) {
|
|
return ref;
|
|
}
|
|
}
|
|
let sha;
|
|
if (ref.startsWith("ref: ")) {
|
|
ref = ref.slice("ref: ".length);
|
|
return GitRefManager.resolve({ fs, gitdir, ref, depth });
|
|
}
|
|
if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) {
|
|
return ref;
|
|
}
|
|
const packedMap = await GitRefManager.packedRefs({ fs, gitdir });
|
|
const allpaths = refpaths(ref).filter((p) => !GIT_FILES.includes(p));
|
|
for (const ref2 of allpaths) {
|
|
sha = await fs.read(`${gitdir}/${ref2}`, { encoding: "utf8" }) || packedMap.get(ref2);
|
|
if (sha) {
|
|
return GitRefManager.resolve({ fs, gitdir, ref: sha.trim(), depth });
|
|
}
|
|
}
|
|
throw new NotFoundError(ref);
|
|
}
|
|
static async exists({ fs, gitdir, ref }) {
|
|
try {
|
|
await GitRefManager.expand({ fs, gitdir, ref });
|
|
return true;
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
static async expand({ fs, gitdir, ref }) {
|
|
if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) {
|
|
return ref;
|
|
}
|
|
const packedMap = await GitRefManager.packedRefs({ fs, gitdir });
|
|
const allpaths = refpaths(ref);
|
|
for (const ref2 of allpaths) {
|
|
if (await fs.exists(`${gitdir}/${ref2}`))
|
|
return ref2;
|
|
if (packedMap.has(ref2))
|
|
return ref2;
|
|
}
|
|
throw new NotFoundError(ref);
|
|
}
|
|
static async expandAgainstMap({ ref, map }) {
|
|
const allpaths = refpaths(ref);
|
|
for (const ref2 of allpaths) {
|
|
if (await map.has(ref2))
|
|
return ref2;
|
|
}
|
|
throw new NotFoundError(ref);
|
|
}
|
|
static resolveAgainstMap({ ref, fullref = ref, depth = void 0, map }) {
|
|
if (depth !== void 0) {
|
|
depth--;
|
|
if (depth === -1) {
|
|
return { fullref, oid: ref };
|
|
}
|
|
}
|
|
if (ref.startsWith("ref: ")) {
|
|
ref = ref.slice("ref: ".length);
|
|
return GitRefManager.resolveAgainstMap({ ref, fullref, depth, map });
|
|
}
|
|
if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) {
|
|
return { fullref, oid: ref };
|
|
}
|
|
const allpaths = refpaths(ref);
|
|
for (const ref2 of allpaths) {
|
|
const sha = map.get(ref2);
|
|
if (sha) {
|
|
return GitRefManager.resolveAgainstMap({
|
|
ref: sha.trim(),
|
|
fullref: ref2,
|
|
depth,
|
|
map
|
|
});
|
|
}
|
|
}
|
|
throw new NotFoundError(ref);
|
|
}
|
|
static async packedRefs({ fs, gitdir }) {
|
|
const text2 = await fs.read(`${gitdir}/packed-refs`, { encoding: "utf8" });
|
|
const packed = GitPackedRefs.from(text2);
|
|
return packed.refs;
|
|
}
|
|
static async listRefs({ fs, gitdir, filepath }) {
|
|
const packedMap = GitRefManager.packedRefs({ fs, gitdir });
|
|
let files = null;
|
|
try {
|
|
files = await fs.readdirDeep(`${gitdir}/${filepath}`);
|
|
files = files.map((x) => x.replace(`${gitdir}/${filepath}/`, ""));
|
|
} catch (err) {
|
|
files = [];
|
|
}
|
|
for (let key2 of (await packedMap).keys()) {
|
|
if (key2.startsWith(filepath)) {
|
|
key2 = key2.replace(filepath + "/", "");
|
|
if (!files.includes(key2)) {
|
|
files.push(key2);
|
|
}
|
|
}
|
|
}
|
|
files.sort(compareRefNames);
|
|
return files;
|
|
}
|
|
static async listBranches({ fs, gitdir, remote }) {
|
|
if (remote) {
|
|
return GitRefManager.listRefs({
|
|
fs,
|
|
gitdir,
|
|
filepath: `refs/remotes/${remote}`
|
|
});
|
|
} else {
|
|
return GitRefManager.listRefs({ fs, gitdir, filepath: `refs/heads` });
|
|
}
|
|
}
|
|
static async listTags({ fs, gitdir }) {
|
|
const tags = await GitRefManager.listRefs({
|
|
fs,
|
|
gitdir,
|
|
filepath: `refs/tags`
|
|
});
|
|
return tags.filter((x) => !x.endsWith("^{}"));
|
|
}
|
|
};
|
|
function compareTreeEntryPath(a, b) {
|
|
return compareStrings(appendSlashIfDir(a), appendSlashIfDir(b));
|
|
}
|
|
function appendSlashIfDir(entry) {
|
|
return entry.mode === "040000" ? entry.path + "/" : entry.path;
|
|
}
|
|
function mode2type$1(mode) {
|
|
switch (mode) {
|
|
case "040000":
|
|
return "tree";
|
|
case "100644":
|
|
return "blob";
|
|
case "100755":
|
|
return "blob";
|
|
case "120000":
|
|
return "blob";
|
|
case "160000":
|
|
return "commit";
|
|
}
|
|
throw new InternalError(`Unexpected GitTree entry mode: ${mode}`);
|
|
}
|
|
function parseBuffer(buffer2) {
|
|
const _entries = [];
|
|
let cursor = 0;
|
|
while (cursor < buffer2.length) {
|
|
const space2 = buffer2.indexOf(32, cursor);
|
|
if (space2 === -1) {
|
|
throw new InternalError(`GitTree: Error parsing buffer at byte location ${cursor}: Could not find the next space character.`);
|
|
}
|
|
const nullchar = buffer2.indexOf(0, cursor);
|
|
if (nullchar === -1) {
|
|
throw new InternalError(`GitTree: Error parsing buffer at byte location ${cursor}: Could not find the next null character.`);
|
|
}
|
|
let mode = buffer2.slice(cursor, space2).toString("utf8");
|
|
if (mode === "40000")
|
|
mode = "040000";
|
|
const type = mode2type$1(mode);
|
|
const path2 = buffer2.slice(space2 + 1, nullchar).toString("utf8");
|
|
if (path2.includes("\\") || path2.includes("/")) {
|
|
throw new UnsafeFilepathError(path2);
|
|
}
|
|
const oid = buffer2.slice(nullchar + 1, nullchar + 21).toString("hex");
|
|
cursor = nullchar + 21;
|
|
_entries.push({ mode, path: path2, oid, type });
|
|
}
|
|
return _entries;
|
|
}
|
|
function limitModeToAllowed(mode) {
|
|
if (typeof mode === "number") {
|
|
mode = mode.toString(8);
|
|
}
|
|
if (mode.match(/^0?4.*/))
|
|
return "040000";
|
|
if (mode.match(/^1006.*/))
|
|
return "100644";
|
|
if (mode.match(/^1007.*/))
|
|
return "100755";
|
|
if (mode.match(/^120.*/))
|
|
return "120000";
|
|
if (mode.match(/^160.*/))
|
|
return "160000";
|
|
throw new InternalError(`Could not understand file mode: ${mode}`);
|
|
}
|
|
function nudgeIntoShape(entry) {
|
|
if (!entry.oid && entry.sha) {
|
|
entry.oid = entry.sha;
|
|
}
|
|
entry.mode = limitModeToAllowed(entry.mode);
|
|
if (!entry.type) {
|
|
entry.type = mode2type$1(entry.mode);
|
|
}
|
|
return entry;
|
|
}
|
|
var GitTree = class {
|
|
constructor(entries) {
|
|
if (Buffer2.isBuffer(entries)) {
|
|
this._entries = parseBuffer(entries);
|
|
} else if (Array.isArray(entries)) {
|
|
this._entries = entries.map(nudgeIntoShape);
|
|
} else {
|
|
throw new InternalError("invalid type passed to GitTree constructor");
|
|
}
|
|
this._entries.sort(comparePath);
|
|
}
|
|
static from(tree) {
|
|
return new GitTree(tree);
|
|
}
|
|
render() {
|
|
return this._entries.map((entry) => `${entry.mode} ${entry.type} ${entry.oid} ${entry.path}`).join("\n");
|
|
}
|
|
toObject() {
|
|
const entries = [...this._entries];
|
|
entries.sort(compareTreeEntryPath);
|
|
return Buffer2.concat(entries.map((entry) => {
|
|
const mode = Buffer2.from(entry.mode.replace(/^0/, ""));
|
|
const space2 = Buffer2.from(" ");
|
|
const path2 = Buffer2.from(entry.path, "utf8");
|
|
const nullchar = Buffer2.from([0]);
|
|
const oid = Buffer2.from(entry.oid, "hex");
|
|
return Buffer2.concat([mode, space2, path2, nullchar, oid]);
|
|
}));
|
|
}
|
|
entries() {
|
|
return this._entries;
|
|
}
|
|
*[Symbol.iterator]() {
|
|
for (const entry of this._entries) {
|
|
yield entry;
|
|
}
|
|
}
|
|
};
|
|
var GitObject = class {
|
|
static wrap({ type, object }) {
|
|
return Buffer2.concat([
|
|
Buffer2.from(`${type} ${object.byteLength.toString()}\0`),
|
|
Buffer2.from(object)
|
|
]);
|
|
}
|
|
static unwrap(buffer2) {
|
|
const s = buffer2.indexOf(32);
|
|
const i = buffer2.indexOf(0);
|
|
const type = buffer2.slice(0, s).toString("utf8");
|
|
const length = buffer2.slice(s + 1, i).toString("utf8");
|
|
const actualLength = buffer2.length - (i + 1);
|
|
if (parseInt(length) !== actualLength) {
|
|
throw new InternalError(`Length mismatch: expected ${length} bytes but got ${actualLength} instead.`);
|
|
}
|
|
return {
|
|
type,
|
|
object: Buffer2.from(buffer2.slice(i + 1))
|
|
};
|
|
}
|
|
};
|
|
async function readObjectLoose({ fs, gitdir, oid }) {
|
|
const source = `objects/${oid.slice(0, 2)}/${oid.slice(2)}`;
|
|
const file = await fs.read(`${gitdir}/${source}`);
|
|
if (!file) {
|
|
return null;
|
|
}
|
|
return { object: file, format: "deflated", source };
|
|
}
|
|
function applyDelta(delta, source) {
|
|
const reader = new BufferCursor(delta);
|
|
const sourceSize = readVarIntLE(reader);
|
|
if (sourceSize !== source.byteLength) {
|
|
throw new InternalError(`applyDelta expected source buffer to be ${sourceSize} bytes but the provided buffer was ${source.length} bytes`);
|
|
}
|
|
const targetSize = readVarIntLE(reader);
|
|
let target;
|
|
const firstOp = readOp(reader, source);
|
|
if (firstOp.byteLength === targetSize) {
|
|
target = firstOp;
|
|
} else {
|
|
target = Buffer2.alloc(targetSize);
|
|
const writer = new BufferCursor(target);
|
|
writer.copy(firstOp);
|
|
while (!reader.eof()) {
|
|
writer.copy(readOp(reader, source));
|
|
}
|
|
const tell = writer.tell();
|
|
if (targetSize !== tell) {
|
|
throw new InternalError(`applyDelta expected target buffer to be ${targetSize} bytes but the resulting buffer was ${tell} bytes`);
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
function readVarIntLE(reader) {
|
|
let result = 0;
|
|
let shift = 0;
|
|
let byte = null;
|
|
do {
|
|
byte = reader.readUInt8();
|
|
result |= (byte & 127) << shift;
|
|
shift += 7;
|
|
} while (byte & 128);
|
|
return result;
|
|
}
|
|
function readCompactLE(reader, flags, size) {
|
|
let result = 0;
|
|
let shift = 0;
|
|
while (size--) {
|
|
if (flags & 1) {
|
|
result |= reader.readUInt8() << shift;
|
|
}
|
|
flags >>= 1;
|
|
shift += 8;
|
|
}
|
|
return result;
|
|
}
|
|
function readOp(reader, source) {
|
|
const byte = reader.readUInt8();
|
|
const COPY = 128;
|
|
const OFFS = 15;
|
|
const SIZE = 112;
|
|
if (byte & COPY) {
|
|
const offset = readCompactLE(reader, byte & OFFS, 4);
|
|
let size = readCompactLE(reader, (byte & SIZE) >> 4, 3);
|
|
if (size === 0)
|
|
size = 65536;
|
|
return source.slice(offset, offset + size);
|
|
} else {
|
|
return reader.slice(byte);
|
|
}
|
|
}
|
|
function fromValue(value) {
|
|
let queue = [value];
|
|
return {
|
|
next() {
|
|
return Promise.resolve({ done: queue.length === 0, value: queue.pop() });
|
|
},
|
|
return() {
|
|
queue = [];
|
|
return {};
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
}
|
|
};
|
|
}
|
|
function getIterator(iterable) {
|
|
if (iterable[Symbol.asyncIterator]) {
|
|
return iterable[Symbol.asyncIterator]();
|
|
}
|
|
if (iterable[Symbol.iterator]) {
|
|
return iterable[Symbol.iterator]();
|
|
}
|
|
if (iterable.next) {
|
|
return iterable;
|
|
}
|
|
return fromValue(iterable);
|
|
}
|
|
var StreamReader = class {
|
|
constructor(stream) {
|
|
this.stream = getIterator(stream);
|
|
this.buffer = null;
|
|
this.cursor = 0;
|
|
this.undoCursor = 0;
|
|
this.started = false;
|
|
this._ended = false;
|
|
this._discardedBytes = 0;
|
|
}
|
|
eof() {
|
|
return this._ended && this.cursor === this.buffer.length;
|
|
}
|
|
tell() {
|
|
return this._discardedBytes + this.cursor;
|
|
}
|
|
async byte() {
|
|
if (this.eof())
|
|
return;
|
|
if (!this.started)
|
|
await this._init();
|
|
if (this.cursor === this.buffer.length) {
|
|
await this._loadnext();
|
|
if (this._ended)
|
|
return;
|
|
}
|
|
this._moveCursor(1);
|
|
return this.buffer[this.undoCursor];
|
|
}
|
|
async chunk() {
|
|
if (this.eof())
|
|
return;
|
|
if (!this.started)
|
|
await this._init();
|
|
if (this.cursor === this.buffer.length) {
|
|
await this._loadnext();
|
|
if (this._ended)
|
|
return;
|
|
}
|
|
this._moveCursor(this.buffer.length);
|
|
return this.buffer.slice(this.undoCursor, this.cursor);
|
|
}
|
|
async read(n) {
|
|
if (this.eof())
|
|
return;
|
|
if (!this.started)
|
|
await this._init();
|
|
if (this.cursor + n > this.buffer.length) {
|
|
this._trim();
|
|
await this._accumulate(n);
|
|
}
|
|
this._moveCursor(n);
|
|
return this.buffer.slice(this.undoCursor, this.cursor);
|
|
}
|
|
async skip(n) {
|
|
if (this.eof())
|
|
return;
|
|
if (!this.started)
|
|
await this._init();
|
|
if (this.cursor + n > this.buffer.length) {
|
|
this._trim();
|
|
await this._accumulate(n);
|
|
}
|
|
this._moveCursor(n);
|
|
}
|
|
async undo() {
|
|
this.cursor = this.undoCursor;
|
|
}
|
|
async _next() {
|
|
this.started = true;
|
|
let { done, value } = await this.stream.next();
|
|
if (done) {
|
|
this._ended = true;
|
|
}
|
|
if (value) {
|
|
value = Buffer2.from(value);
|
|
}
|
|
return value;
|
|
}
|
|
_trim() {
|
|
this.buffer = this.buffer.slice(this.undoCursor);
|
|
this.cursor -= this.undoCursor;
|
|
this._discardedBytes += this.undoCursor;
|
|
this.undoCursor = 0;
|
|
}
|
|
_moveCursor(n) {
|
|
this.undoCursor = this.cursor;
|
|
this.cursor += n;
|
|
if (this.cursor > this.buffer.length) {
|
|
this.cursor = this.buffer.length;
|
|
}
|
|
}
|
|
async _accumulate(n) {
|
|
if (this._ended)
|
|
return;
|
|
const buffers = [this.buffer];
|
|
while (this.cursor + n > lengthBuffers(buffers)) {
|
|
const nextbuffer = await this._next();
|
|
if (this._ended)
|
|
break;
|
|
buffers.push(nextbuffer);
|
|
}
|
|
this.buffer = Buffer2.concat(buffers);
|
|
}
|
|
async _loadnext() {
|
|
this._discardedBytes += this.buffer.length;
|
|
this.undoCursor = 0;
|
|
this.cursor = 0;
|
|
this.buffer = await this._next();
|
|
}
|
|
async _init() {
|
|
this.buffer = await this._next();
|
|
}
|
|
};
|
|
function lengthBuffers(buffers) {
|
|
return buffers.reduce((acc, buffer2) => acc + buffer2.length, 0);
|
|
}
|
|
async function listpack(stream, onData) {
|
|
const reader = new StreamReader(stream);
|
|
let PACK = await reader.read(4);
|
|
PACK = PACK.toString("utf8");
|
|
if (PACK !== "PACK") {
|
|
throw new InternalError(`Invalid PACK header '${PACK}'`);
|
|
}
|
|
let version2 = await reader.read(4);
|
|
version2 = version2.readUInt32BE(0);
|
|
if (version2 !== 2) {
|
|
throw new InternalError(`Invalid packfile version: ${version2}`);
|
|
}
|
|
let numObjects = await reader.read(4);
|
|
numObjects = numObjects.readUInt32BE(0);
|
|
if (numObjects < 1)
|
|
return;
|
|
while (!reader.eof() && numObjects--) {
|
|
const offset = reader.tell();
|
|
const { type, length, ofs, reference } = await parseHeader(reader);
|
|
const inflator = new import_pako.default.Inflate();
|
|
while (!inflator.result) {
|
|
const chunk = await reader.chunk();
|
|
if (!chunk)
|
|
break;
|
|
inflator.push(chunk, false);
|
|
if (inflator.err) {
|
|
throw new InternalError(`Pako error: ${inflator.msg}`);
|
|
}
|
|
if (inflator.result) {
|
|
if (inflator.result.length !== length) {
|
|
throw new InternalError(`Inflated object size is different from that stated in packfile.`);
|
|
}
|
|
await reader.undo();
|
|
await reader.read(chunk.length - inflator.strm.avail_in);
|
|
const end = reader.tell();
|
|
await onData({
|
|
data: inflator.result,
|
|
type,
|
|
num: numObjects,
|
|
offset,
|
|
end,
|
|
reference,
|
|
ofs
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async function parseHeader(reader) {
|
|
let byte = await reader.byte();
|
|
const type = byte >> 4 & 7;
|
|
let length = byte & 15;
|
|
if (byte & 128) {
|
|
let shift = 4;
|
|
do {
|
|
byte = await reader.byte();
|
|
length |= (byte & 127) << shift;
|
|
shift += 7;
|
|
} while (byte & 128);
|
|
}
|
|
let ofs;
|
|
let reference;
|
|
if (type === 6) {
|
|
let shift = 0;
|
|
ofs = 0;
|
|
const bytes = [];
|
|
do {
|
|
byte = await reader.byte();
|
|
ofs |= (byte & 127) << shift;
|
|
shift += 7;
|
|
bytes.push(byte);
|
|
} while (byte & 128);
|
|
reference = Buffer2.from(bytes);
|
|
}
|
|
if (type === 7) {
|
|
const buf = await reader.read(20);
|
|
reference = buf;
|
|
}
|
|
return { type, length, ofs, reference };
|
|
}
|
|
var supportsDecompressionStream = false;
|
|
async function inflate(buffer2) {
|
|
if (supportsDecompressionStream === null) {
|
|
supportsDecompressionStream = testDecompressionStream();
|
|
}
|
|
return supportsDecompressionStream ? browserInflate(buffer2) : import_pako.default.inflate(buffer2);
|
|
}
|
|
async function browserInflate(buffer2) {
|
|
const ds = new DecompressionStream("deflate");
|
|
const d = new Blob([buffer2]).stream().pipeThrough(ds);
|
|
return new Uint8Array(await new Response(d).arrayBuffer());
|
|
}
|
|
function testDecompressionStream() {
|
|
try {
|
|
const ds = new DecompressionStream("deflate");
|
|
if (ds)
|
|
return true;
|
|
} catch (_) {
|
|
}
|
|
return false;
|
|
}
|
|
function decodeVarInt(reader) {
|
|
const bytes = [];
|
|
let byte = 0;
|
|
let multibyte = 0;
|
|
do {
|
|
byte = reader.readUInt8();
|
|
const lastSeven = byte & 127;
|
|
bytes.push(lastSeven);
|
|
multibyte = byte & 128;
|
|
} while (multibyte);
|
|
return bytes.reduce((a, b) => a + 1 << 7 | b, -1);
|
|
}
|
|
function otherVarIntDecode(reader, startWith) {
|
|
let result = startWith;
|
|
let shift = 4;
|
|
let byte = null;
|
|
do {
|
|
byte = reader.readUInt8();
|
|
result |= (byte & 127) << shift;
|
|
shift += 7;
|
|
} while (byte & 128);
|
|
return result;
|
|
}
|
|
var GitPackIndex = class {
|
|
constructor(stuff) {
|
|
Object.assign(this, stuff);
|
|
this.offsetCache = {};
|
|
}
|
|
static async fromIdx({ idx, getExternalRefDelta }) {
|
|
const reader = new BufferCursor(idx);
|
|
const magic = reader.slice(4).toString("hex");
|
|
if (magic !== "ff744f63") {
|
|
return;
|
|
}
|
|
const version2 = reader.readUInt32BE();
|
|
if (version2 !== 2) {
|
|
throw new InternalError(`Unable to read version ${version2} packfile IDX. (Only version 2 supported)`);
|
|
}
|
|
if (idx.byteLength > 2048 * 1024 * 1024) {
|
|
throw new InternalError(`To keep implementation simple, I haven't implemented the layer 5 feature needed to support packfiles > 2GB in size.`);
|
|
}
|
|
reader.seek(reader.tell() + 4 * 255);
|
|
const size = reader.readUInt32BE();
|
|
const hashes = [];
|
|
for (let i = 0; i < size; i++) {
|
|
const hash2 = reader.slice(20).toString("hex");
|
|
hashes[i] = hash2;
|
|
}
|
|
reader.seek(reader.tell() + 4 * size);
|
|
const offsets = new Map();
|
|
for (let i = 0; i < size; i++) {
|
|
offsets.set(hashes[i], reader.readUInt32BE());
|
|
}
|
|
const packfileSha = reader.slice(20).toString("hex");
|
|
return new GitPackIndex({
|
|
hashes,
|
|
crcs: {},
|
|
offsets,
|
|
packfileSha,
|
|
getExternalRefDelta
|
|
});
|
|
}
|
|
static async fromPack({ pack, getExternalRefDelta, onProgress }) {
|
|
const listpackTypes = {
|
|
1: "commit",
|
|
2: "tree",
|
|
3: "blob",
|
|
4: "tag",
|
|
6: "ofs-delta",
|
|
7: "ref-delta"
|
|
};
|
|
const offsetToObject = {};
|
|
const packfileSha = pack.slice(-20).toString("hex");
|
|
const hashes = [];
|
|
const crcs = {};
|
|
const offsets = new Map();
|
|
let totalObjectCount = null;
|
|
let lastPercent = null;
|
|
await listpack([pack], async ({ data, type, reference, offset, num: num2 }) => {
|
|
if (totalObjectCount === null)
|
|
totalObjectCount = num2;
|
|
const percent = Math.floor((totalObjectCount - num2) * 100 / totalObjectCount);
|
|
if (percent !== lastPercent) {
|
|
if (onProgress) {
|
|
await onProgress({
|
|
phase: "Receiving objects",
|
|
loaded: totalObjectCount - num2,
|
|
total: totalObjectCount
|
|
});
|
|
}
|
|
}
|
|
lastPercent = percent;
|
|
type = listpackTypes[type];
|
|
if (["commit", "tree", "blob", "tag"].includes(type)) {
|
|
offsetToObject[offset] = {
|
|
type,
|
|
offset
|
|
};
|
|
} else if (type === "ofs-delta") {
|
|
offsetToObject[offset] = {
|
|
type,
|
|
offset
|
|
};
|
|
} else if (type === "ref-delta") {
|
|
offsetToObject[offset] = {
|
|
type,
|
|
offset
|
|
};
|
|
}
|
|
});
|
|
const offsetArray = Object.keys(offsetToObject).map(Number);
|
|
for (const [i, start] of offsetArray.entries()) {
|
|
const end = i + 1 === offsetArray.length ? pack.byteLength - 20 : offsetArray[i + 1];
|
|
const o = offsetToObject[start];
|
|
const crc = import_crc_32.default.buf(pack.slice(start, end)) >>> 0;
|
|
o.end = end;
|
|
o.crc = crc;
|
|
}
|
|
const p = new GitPackIndex({
|
|
pack: Promise.resolve(pack),
|
|
packfileSha,
|
|
crcs,
|
|
hashes,
|
|
offsets,
|
|
getExternalRefDelta
|
|
});
|
|
lastPercent = null;
|
|
let count = 0;
|
|
const objectsByDepth = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
for (let offset in offsetToObject) {
|
|
offset = Number(offset);
|
|
const percent = Math.floor(count * 100 / totalObjectCount);
|
|
if (percent !== lastPercent) {
|
|
if (onProgress) {
|
|
await onProgress({
|
|
phase: "Resolving deltas",
|
|
loaded: count,
|
|
total: totalObjectCount
|
|
});
|
|
}
|
|
}
|
|
count++;
|
|
lastPercent = percent;
|
|
const o = offsetToObject[offset];
|
|
if (o.oid)
|
|
continue;
|
|
try {
|
|
p.readDepth = 0;
|
|
p.externalReadDepth = 0;
|
|
const { type, object } = await p.readSlice({ start: offset });
|
|
objectsByDepth[p.readDepth] += 1;
|
|
const oid = await shasum(GitObject.wrap({ type, object }));
|
|
o.oid = oid;
|
|
hashes.push(oid);
|
|
offsets.set(oid, offset);
|
|
crcs[oid] = o.crc;
|
|
} catch (err) {
|
|
continue;
|
|
}
|
|
}
|
|
hashes.sort();
|
|
return p;
|
|
}
|
|
async toBuffer() {
|
|
const buffers = [];
|
|
const write = (str, encoding) => {
|
|
buffers.push(Buffer2.from(str, encoding));
|
|
};
|
|
write("ff744f63", "hex");
|
|
write("00000002", "hex");
|
|
const fanoutBuffer = new BufferCursor(Buffer2.alloc(256 * 4));
|
|
for (let i = 0; i < 256; i++) {
|
|
let count = 0;
|
|
for (const hash2 of this.hashes) {
|
|
if (parseInt(hash2.slice(0, 2), 16) <= i)
|
|
count++;
|
|
}
|
|
fanoutBuffer.writeUInt32BE(count);
|
|
}
|
|
buffers.push(fanoutBuffer.buffer);
|
|
for (const hash2 of this.hashes) {
|
|
write(hash2, "hex");
|
|
}
|
|
const crcsBuffer = new BufferCursor(Buffer2.alloc(this.hashes.length * 4));
|
|
for (const hash2 of this.hashes) {
|
|
crcsBuffer.writeUInt32BE(this.crcs[hash2]);
|
|
}
|
|
buffers.push(crcsBuffer.buffer);
|
|
const offsetsBuffer = new BufferCursor(Buffer2.alloc(this.hashes.length * 4));
|
|
for (const hash2 of this.hashes) {
|
|
offsetsBuffer.writeUInt32BE(this.offsets.get(hash2));
|
|
}
|
|
buffers.push(offsetsBuffer.buffer);
|
|
write(this.packfileSha, "hex");
|
|
const totalBuffer = Buffer2.concat(buffers);
|
|
const sha = await shasum(totalBuffer);
|
|
const shaBuffer = Buffer2.alloc(20);
|
|
shaBuffer.write(sha, "hex");
|
|
return Buffer2.concat([totalBuffer, shaBuffer]);
|
|
}
|
|
async load({ pack }) {
|
|
this.pack = pack;
|
|
}
|
|
async unload() {
|
|
this.pack = null;
|
|
}
|
|
async read({ oid }) {
|
|
if (!this.offsets.get(oid)) {
|
|
if (this.getExternalRefDelta) {
|
|
this.externalReadDepth++;
|
|
return this.getExternalRefDelta(oid);
|
|
} else {
|
|
throw new InternalError(`Could not read object ${oid} from packfile`);
|
|
}
|
|
}
|
|
const start = this.offsets.get(oid);
|
|
return this.readSlice({ start });
|
|
}
|
|
async readSlice({ start }) {
|
|
if (this.offsetCache[start]) {
|
|
return Object.assign({}, this.offsetCache[start]);
|
|
}
|
|
this.readDepth++;
|
|
const types2 = {
|
|
16: "commit",
|
|
32: "tree",
|
|
48: "blob",
|
|
64: "tag",
|
|
96: "ofs_delta",
|
|
112: "ref_delta"
|
|
};
|
|
if (!this.pack) {
|
|
throw new InternalError("Tried to read from a GitPackIndex with no packfile loaded into memory");
|
|
}
|
|
const raw = (await this.pack).slice(start);
|
|
const reader = new BufferCursor(raw);
|
|
const byte = reader.readUInt8();
|
|
const btype = byte & 112;
|
|
let type = types2[btype];
|
|
if (type === void 0) {
|
|
throw new InternalError("Unrecognized type: 0b" + btype.toString(2));
|
|
}
|
|
const lastFour = byte & 15;
|
|
let length = lastFour;
|
|
const multibyte = byte & 128;
|
|
if (multibyte) {
|
|
length = otherVarIntDecode(reader, lastFour);
|
|
}
|
|
let base = null;
|
|
let object = null;
|
|
if (type === "ofs_delta") {
|
|
const offset = decodeVarInt(reader);
|
|
const baseOffset = start - offset;
|
|
({ object: base, type } = await this.readSlice({ start: baseOffset }));
|
|
}
|
|
if (type === "ref_delta") {
|
|
const oid = reader.slice(20).toString("hex");
|
|
({ object: base, type } = await this.read({ oid }));
|
|
}
|
|
const buffer2 = raw.slice(reader.tell());
|
|
object = Buffer2.from(await inflate(buffer2));
|
|
if (object.byteLength !== length) {
|
|
throw new InternalError(`Packfile told us object would have length ${length} but it had length ${object.byteLength}`);
|
|
}
|
|
if (base) {
|
|
object = Buffer2.from(applyDelta(object, base));
|
|
}
|
|
if (this.readDepth > 3) {
|
|
this.offsetCache[start] = { type, object };
|
|
}
|
|
return { type, format: "content", object };
|
|
}
|
|
};
|
|
var PackfileCache = Symbol("PackfileCache");
|
|
async function loadPackIndex({
|
|
fs,
|
|
filename,
|
|
getExternalRefDelta,
|
|
emitter,
|
|
emitterPrefix
|
|
}) {
|
|
const idx = await fs.read(filename);
|
|
return GitPackIndex.fromIdx({ idx, getExternalRefDelta });
|
|
}
|
|
function readPackIndex({
|
|
fs,
|
|
cache,
|
|
filename,
|
|
getExternalRefDelta,
|
|
emitter,
|
|
emitterPrefix
|
|
}) {
|
|
if (!cache[PackfileCache])
|
|
cache[PackfileCache] = new Map();
|
|
let p = cache[PackfileCache].get(filename);
|
|
if (!p) {
|
|
p = loadPackIndex({
|
|
fs,
|
|
filename,
|
|
getExternalRefDelta,
|
|
emitter,
|
|
emitterPrefix
|
|
});
|
|
cache[PackfileCache].set(filename, p);
|
|
}
|
|
return p;
|
|
}
|
|
async function readObjectPacked({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
format = "content",
|
|
getExternalRefDelta
|
|
}) {
|
|
let list = await fs.readdir(join(gitdir, "objects/pack"));
|
|
list = list.filter((x) => x.endsWith(".idx"));
|
|
for (const filename of list) {
|
|
const indexFile = `${gitdir}/objects/pack/${filename}`;
|
|
const p = await readPackIndex({
|
|
fs,
|
|
cache,
|
|
filename: indexFile,
|
|
getExternalRefDelta
|
|
});
|
|
if (p.error)
|
|
throw new InternalError(p.error);
|
|
if (p.offsets.has(oid)) {
|
|
if (!p.pack) {
|
|
const packFile = indexFile.replace(/idx$/, "pack");
|
|
p.pack = fs.read(packFile);
|
|
}
|
|
const result = await p.read({ oid, getExternalRefDelta });
|
|
result.format = "content";
|
|
result.source = `objects/pack/${filename.replace(/idx$/, "pack")}`;
|
|
return result;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
async function _readObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
format = "content"
|
|
}) {
|
|
const getExternalRefDelta = (oid2) => _readObject({ fs, cache, gitdir, oid: oid2 });
|
|
let result;
|
|
if (oid === "4b825dc642cb6eb9a060e54bf8d69288fbee4904") {
|
|
result = { format: "wrapped", object: Buffer2.from(`tree 0\0`) };
|
|
}
|
|
if (!result) {
|
|
result = await readObjectLoose({ fs, gitdir, oid });
|
|
}
|
|
if (!result) {
|
|
result = await readObjectPacked({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
getExternalRefDelta
|
|
});
|
|
}
|
|
if (!result) {
|
|
throw new NotFoundError(oid);
|
|
}
|
|
if (format === "deflated") {
|
|
return result;
|
|
}
|
|
if (result.format === "deflated") {
|
|
result.object = Buffer2.from(await inflate(result.object));
|
|
result.format = "wrapped";
|
|
}
|
|
if (result.format === "wrapped") {
|
|
if (format === "wrapped" && result.format === "wrapped") {
|
|
return result;
|
|
}
|
|
const sha = await shasum(result.object);
|
|
if (sha !== oid) {
|
|
throw new InternalError(`SHA check failed! Expected ${oid}, computed ${sha}`);
|
|
}
|
|
const { object, type } = GitObject.unwrap(result.object);
|
|
result.type = type;
|
|
result.object = object;
|
|
result.format = "content";
|
|
}
|
|
if (result.format === "content") {
|
|
if (format === "content")
|
|
return result;
|
|
return;
|
|
}
|
|
throw new InternalError(`invalid format "${result.format}"`);
|
|
}
|
|
var AlreadyExistsError = class extends BaseError {
|
|
constructor(noun, where, canForce = true) {
|
|
super(`Failed to create ${noun} at ${where} because it already exists.${canForce ? ` (Hint: use 'force: true' parameter to overwrite existing ${noun}.)` : ""}`);
|
|
this.code = this.name = AlreadyExistsError.code;
|
|
this.data = { noun, where, canForce };
|
|
}
|
|
};
|
|
AlreadyExistsError.code = "AlreadyExistsError";
|
|
var AmbiguousError = class extends BaseError {
|
|
constructor(nouns, short, matches) {
|
|
super(`Found multiple ${nouns} matching "${short}" (${matches.join(", ")}). Use a longer abbreviation length to disambiguate them.`);
|
|
this.code = this.name = AmbiguousError.code;
|
|
this.data = { nouns, short, matches };
|
|
}
|
|
};
|
|
AmbiguousError.code = "AmbiguousError";
|
|
var CheckoutConflictError = class extends BaseError {
|
|
constructor(filepaths) {
|
|
super(`Your local changes to the following files would be overwritten by checkout: ${filepaths.join(", ")}`);
|
|
this.code = this.name = CheckoutConflictError.code;
|
|
this.data = { filepaths };
|
|
}
|
|
};
|
|
CheckoutConflictError.code = "CheckoutConflictError";
|
|
var CommitNotFetchedError = class extends BaseError {
|
|
constructor(ref, oid) {
|
|
super(`Failed to checkout "${ref}" because commit ${oid} is not available locally. Do a git fetch to make the branch available locally.`);
|
|
this.code = this.name = CommitNotFetchedError.code;
|
|
this.data = { ref, oid };
|
|
}
|
|
};
|
|
CommitNotFetchedError.code = "CommitNotFetchedError";
|
|
var EmptyServerResponseError = class extends BaseError {
|
|
constructor() {
|
|
super(`Empty response from git server.`);
|
|
this.code = this.name = EmptyServerResponseError.code;
|
|
this.data = {};
|
|
}
|
|
};
|
|
EmptyServerResponseError.code = "EmptyServerResponseError";
|
|
var FastForwardError = class extends BaseError {
|
|
constructor() {
|
|
super(`A simple fast-forward merge was not possible.`);
|
|
this.code = this.name = FastForwardError.code;
|
|
this.data = {};
|
|
}
|
|
};
|
|
FastForwardError.code = "FastForwardError";
|
|
var GitPushError = class extends BaseError {
|
|
constructor(prettyDetails, result) {
|
|
super(`One or more branches were not updated: ${prettyDetails}`);
|
|
this.code = this.name = GitPushError.code;
|
|
this.data = { prettyDetails, result };
|
|
}
|
|
};
|
|
GitPushError.code = "GitPushError";
|
|
var HttpError = class extends BaseError {
|
|
constructor(statusCode, statusMessage, response) {
|
|
super(`HTTP Error: ${statusCode} ${statusMessage}`);
|
|
this.code = this.name = HttpError.code;
|
|
this.data = { statusCode, statusMessage, response };
|
|
}
|
|
};
|
|
HttpError.code = "HttpError";
|
|
var InvalidFilepathError = class extends BaseError {
|
|
constructor(reason) {
|
|
let message = "invalid filepath";
|
|
if (reason === "leading-slash" || reason === "trailing-slash") {
|
|
message = `"filepath" parameter should not include leading or trailing directory separators because these can cause problems on some platforms.`;
|
|
} else if (reason === "directory") {
|
|
message = `"filepath" should not be a directory.`;
|
|
}
|
|
super(message);
|
|
this.code = this.name = InvalidFilepathError.code;
|
|
this.data = { reason };
|
|
}
|
|
};
|
|
InvalidFilepathError.code = "InvalidFilepathError";
|
|
var InvalidRefNameError = class extends BaseError {
|
|
constructor(ref, suggestion) {
|
|
super(`"${ref}" would be an invalid git reference. (Hint: a valid alternative would be "${suggestion}".)`);
|
|
this.code = this.name = InvalidRefNameError.code;
|
|
this.data = { ref, suggestion };
|
|
}
|
|
};
|
|
InvalidRefNameError.code = "InvalidRefNameError";
|
|
var MaxDepthError = class extends BaseError {
|
|
constructor(depth) {
|
|
super(`Maximum search depth of ${depth} exceeded.`);
|
|
this.code = this.name = MaxDepthError.code;
|
|
this.data = { depth };
|
|
}
|
|
};
|
|
MaxDepthError.code = "MaxDepthError";
|
|
var MergeNotSupportedError = class extends BaseError {
|
|
constructor() {
|
|
super(`Merges with conflicts are not supported yet.`);
|
|
this.code = this.name = MergeNotSupportedError.code;
|
|
this.data = {};
|
|
}
|
|
};
|
|
MergeNotSupportedError.code = "MergeNotSupportedError";
|
|
var MergeConflictError = class extends BaseError {
|
|
constructor(filepaths) {
|
|
super(`Automatic merge failed with one or more merge conflicts in the following files: ${filepaths.toString()}. Fix conflicts then commit the result.`);
|
|
this.code = this.name = MergeConflictError.code;
|
|
this.data = { filepaths };
|
|
}
|
|
};
|
|
MergeConflictError.code = "MergeConflictError";
|
|
var MissingNameError = class extends BaseError {
|
|
constructor(role) {
|
|
super(`No name was provided for ${role} in the argument or in the .git/config file.`);
|
|
this.code = this.name = MissingNameError.code;
|
|
this.data = { role };
|
|
}
|
|
};
|
|
MissingNameError.code = "MissingNameError";
|
|
var MissingParameterError = class extends BaseError {
|
|
constructor(parameter) {
|
|
super(`The function requires a "${parameter}" parameter but none was provided.`);
|
|
this.code = this.name = MissingParameterError.code;
|
|
this.data = { parameter };
|
|
}
|
|
};
|
|
MissingParameterError.code = "MissingParameterError";
|
|
var MultipleGitError = class extends BaseError {
|
|
constructor(errors) {
|
|
super(`There are multiple errors that were thrown by the method. Please refer to the "errors" property to see more`);
|
|
this.code = this.name = MultipleGitError.code;
|
|
this.data = { errors };
|
|
this.errors = errors;
|
|
}
|
|
};
|
|
MultipleGitError.code = "MultipleGitError";
|
|
var ParseError = class extends BaseError {
|
|
constructor(expected, actual) {
|
|
super(`Expected "${expected}" but received "${actual}".`);
|
|
this.code = this.name = ParseError.code;
|
|
this.data = { expected, actual };
|
|
}
|
|
};
|
|
ParseError.code = "ParseError";
|
|
var PushRejectedError = class extends BaseError {
|
|
constructor(reason) {
|
|
let message = "";
|
|
if (reason === "not-fast-forward") {
|
|
message = " because it was not a simple fast-forward";
|
|
} else if (reason === "tag-exists") {
|
|
message = " because tag already exists";
|
|
}
|
|
super(`Push rejected${message}. Use "force: true" to override.`);
|
|
this.code = this.name = PushRejectedError.code;
|
|
this.data = { reason };
|
|
}
|
|
};
|
|
PushRejectedError.code = "PushRejectedError";
|
|
var RemoteCapabilityError = class extends BaseError {
|
|
constructor(capability, parameter) {
|
|
super(`Remote does not support the "${capability}" so the "${parameter}" parameter cannot be used.`);
|
|
this.code = this.name = RemoteCapabilityError.code;
|
|
this.data = { capability, parameter };
|
|
}
|
|
};
|
|
RemoteCapabilityError.code = "RemoteCapabilityError";
|
|
var SmartHttpError = class extends BaseError {
|
|
constructor(preview, response) {
|
|
super(`Remote did not reply using the "smart" HTTP protocol. Expected "001e# service=git-upload-pack" but received: ${preview}`);
|
|
this.code = this.name = SmartHttpError.code;
|
|
this.data = { preview, response };
|
|
}
|
|
};
|
|
SmartHttpError.code = "SmartHttpError";
|
|
var UnknownTransportError = class extends BaseError {
|
|
constructor(url, transport, suggestion) {
|
|
super(`Git remote "${url}" uses an unrecognized transport protocol: "${transport}"`);
|
|
this.code = this.name = UnknownTransportError.code;
|
|
this.data = { url, transport, suggestion };
|
|
}
|
|
};
|
|
UnknownTransportError.code = "UnknownTransportError";
|
|
var UrlParseError = class extends BaseError {
|
|
constructor(url) {
|
|
super(`Cannot parse remote URL: "${url}"`);
|
|
this.code = this.name = UrlParseError.code;
|
|
this.data = { url };
|
|
}
|
|
};
|
|
UrlParseError.code = "UrlParseError";
|
|
var UserCanceledError = class extends BaseError {
|
|
constructor() {
|
|
super(`The operation was canceled.`);
|
|
this.code = this.name = UserCanceledError.code;
|
|
this.data = {};
|
|
}
|
|
};
|
|
UserCanceledError.code = "UserCanceledError";
|
|
var Errors = /* @__PURE__ */ Object.freeze({
|
|
__proto__: null,
|
|
AlreadyExistsError,
|
|
AmbiguousError,
|
|
CheckoutConflictError,
|
|
CommitNotFetchedError,
|
|
EmptyServerResponseError,
|
|
FastForwardError,
|
|
GitPushError,
|
|
HttpError,
|
|
InternalError,
|
|
InvalidFilepathError,
|
|
InvalidOidError,
|
|
InvalidRefNameError,
|
|
MaxDepthError,
|
|
MergeNotSupportedError,
|
|
MergeConflictError,
|
|
MissingNameError,
|
|
MissingParameterError,
|
|
MultipleGitError,
|
|
NoRefspecError,
|
|
NotFoundError,
|
|
ObjectTypeError,
|
|
ParseError,
|
|
PushRejectedError,
|
|
RemoteCapabilityError,
|
|
SmartHttpError,
|
|
UnknownTransportError,
|
|
UnsafeFilepathError,
|
|
UrlParseError,
|
|
UserCanceledError
|
|
});
|
|
function formatAuthor({ name, email, timestamp, timezoneOffset }) {
|
|
timezoneOffset = formatTimezoneOffset(timezoneOffset);
|
|
return `${name} <${email}> ${timestamp} ${timezoneOffset}`;
|
|
}
|
|
function formatTimezoneOffset(minutes) {
|
|
const sign = simpleSign(negateExceptForZero(minutes));
|
|
minutes = Math.abs(minutes);
|
|
const hours = Math.floor(minutes / 60);
|
|
minutes -= hours * 60;
|
|
let strHours = String(hours);
|
|
let strMinutes = String(minutes);
|
|
if (strHours.length < 2)
|
|
strHours = "0" + strHours;
|
|
if (strMinutes.length < 2)
|
|
strMinutes = "0" + strMinutes;
|
|
return (sign === -1 ? "-" : "+") + strHours + strMinutes;
|
|
}
|
|
function simpleSign(n) {
|
|
return Math.sign(n) || (Object.is(n, -0) ? -1 : 1);
|
|
}
|
|
function negateExceptForZero(n) {
|
|
return n === 0 ? n : -n;
|
|
}
|
|
function normalizeNewlines(str) {
|
|
str = str.replace(/\r/g, "");
|
|
str = str.replace(/^\n+/, "");
|
|
str = str.replace(/\n+$/, "") + "\n";
|
|
return str;
|
|
}
|
|
function parseAuthor(author) {
|
|
const [, name, email, timestamp, offset] = author.match(/^(.*) <(.*)> (.*) (.*)$/);
|
|
return {
|
|
name,
|
|
email,
|
|
timestamp: Number(timestamp),
|
|
timezoneOffset: parseTimezoneOffset(offset)
|
|
};
|
|
}
|
|
function parseTimezoneOffset(offset) {
|
|
let [, sign, hours, minutes] = offset.match(/(\+|-)(\d\d)(\d\d)/);
|
|
minutes = (sign === "+" ? 1 : -1) * (Number(hours) * 60 + Number(minutes));
|
|
return negateExceptForZero$1(minutes);
|
|
}
|
|
function negateExceptForZero$1(n) {
|
|
return n === 0 ? n : -n;
|
|
}
|
|
var GitAnnotatedTag = class {
|
|
constructor(tag2) {
|
|
if (typeof tag2 === "string") {
|
|
this._tag = tag2;
|
|
} else if (Buffer2.isBuffer(tag2)) {
|
|
this._tag = tag2.toString("utf8");
|
|
} else if (typeof tag2 === "object") {
|
|
this._tag = GitAnnotatedTag.render(tag2);
|
|
} else {
|
|
throw new InternalError("invalid type passed to GitAnnotatedTag constructor");
|
|
}
|
|
}
|
|
static from(tag2) {
|
|
return new GitAnnotatedTag(tag2);
|
|
}
|
|
static render(obj) {
|
|
return `object ${obj.object}
|
|
type ${obj.type}
|
|
tag ${obj.tag}
|
|
tagger ${formatAuthor(obj.tagger)}
|
|
|
|
${obj.message}
|
|
${obj.gpgsig ? obj.gpgsig : ""}`;
|
|
}
|
|
justHeaders() {
|
|
return this._tag.slice(0, this._tag.indexOf("\n\n"));
|
|
}
|
|
message() {
|
|
const tag2 = this.withoutSignature();
|
|
return tag2.slice(tag2.indexOf("\n\n") + 2);
|
|
}
|
|
parse() {
|
|
return Object.assign(this.headers(), {
|
|
message: this.message(),
|
|
gpgsig: this.gpgsig()
|
|
});
|
|
}
|
|
render() {
|
|
return this._tag;
|
|
}
|
|
headers() {
|
|
const headers = this.justHeaders().split("\n");
|
|
const hs = [];
|
|
for (const h of headers) {
|
|
if (h[0] === " ") {
|
|
hs[hs.length - 1] += "\n" + h.slice(1);
|
|
} else {
|
|
hs.push(h);
|
|
}
|
|
}
|
|
const obj = {};
|
|
for (const h of hs) {
|
|
const key2 = h.slice(0, h.indexOf(" "));
|
|
const value = h.slice(h.indexOf(" ") + 1);
|
|
if (Array.isArray(obj[key2])) {
|
|
obj[key2].push(value);
|
|
} else {
|
|
obj[key2] = value;
|
|
}
|
|
}
|
|
if (obj.tagger) {
|
|
obj.tagger = parseAuthor(obj.tagger);
|
|
}
|
|
if (obj.committer) {
|
|
obj.committer = parseAuthor(obj.committer);
|
|
}
|
|
return obj;
|
|
}
|
|
withoutSignature() {
|
|
const tag2 = normalizeNewlines(this._tag);
|
|
if (tag2.indexOf("\n-----BEGIN PGP SIGNATURE-----") === -1)
|
|
return tag2;
|
|
return tag2.slice(0, tag2.lastIndexOf("\n-----BEGIN PGP SIGNATURE-----"));
|
|
}
|
|
gpgsig() {
|
|
if (this._tag.indexOf("\n-----BEGIN PGP SIGNATURE-----") === -1)
|
|
return;
|
|
const signature = this._tag.slice(this._tag.indexOf("-----BEGIN PGP SIGNATURE-----"), this._tag.indexOf("-----END PGP SIGNATURE-----") + "-----END PGP SIGNATURE-----".length);
|
|
return normalizeNewlines(signature);
|
|
}
|
|
payload() {
|
|
return this.withoutSignature() + "\n";
|
|
}
|
|
toObject() {
|
|
return Buffer2.from(this._tag, "utf8");
|
|
}
|
|
static async sign(tag2, sign, secretKey) {
|
|
const payload = tag2.payload();
|
|
let { signature } = await sign({ payload, secretKey });
|
|
signature = normalizeNewlines(signature);
|
|
const signedTag = payload + signature;
|
|
return GitAnnotatedTag.from(signedTag);
|
|
}
|
|
};
|
|
function indent(str) {
|
|
return str.trim().split("\n").map((x) => " " + x).join("\n") + "\n";
|
|
}
|
|
function outdent(str) {
|
|
return str.split("\n").map((x) => x.replace(/^ /, "")).join("\n");
|
|
}
|
|
var GitCommit = class {
|
|
constructor(commit2) {
|
|
if (typeof commit2 === "string") {
|
|
this._commit = commit2;
|
|
} else if (Buffer2.isBuffer(commit2)) {
|
|
this._commit = commit2.toString("utf8");
|
|
} else if (typeof commit2 === "object") {
|
|
this._commit = GitCommit.render(commit2);
|
|
} else {
|
|
throw new InternalError("invalid type passed to GitCommit constructor");
|
|
}
|
|
}
|
|
static fromPayloadSignature({ payload, signature }) {
|
|
const headers = GitCommit.justHeaders(payload);
|
|
const message = GitCommit.justMessage(payload);
|
|
const commit2 = normalizeNewlines(headers + "\ngpgsig" + indent(signature) + "\n" + message);
|
|
return new GitCommit(commit2);
|
|
}
|
|
static from(commit2) {
|
|
return new GitCommit(commit2);
|
|
}
|
|
toObject() {
|
|
return Buffer2.from(this._commit, "utf8");
|
|
}
|
|
headers() {
|
|
return this.parseHeaders();
|
|
}
|
|
message() {
|
|
return GitCommit.justMessage(this._commit);
|
|
}
|
|
parse() {
|
|
return Object.assign({ message: this.message() }, this.headers());
|
|
}
|
|
static justMessage(commit2) {
|
|
return normalizeNewlines(commit2.slice(commit2.indexOf("\n\n") + 2));
|
|
}
|
|
static justHeaders(commit2) {
|
|
return commit2.slice(0, commit2.indexOf("\n\n"));
|
|
}
|
|
parseHeaders() {
|
|
const headers = GitCommit.justHeaders(this._commit).split("\n");
|
|
const hs = [];
|
|
for (const h of headers) {
|
|
if (h[0] === " ") {
|
|
hs[hs.length - 1] += "\n" + h.slice(1);
|
|
} else {
|
|
hs.push(h);
|
|
}
|
|
}
|
|
const obj = {
|
|
parent: []
|
|
};
|
|
for (const h of hs) {
|
|
const key2 = h.slice(0, h.indexOf(" "));
|
|
const value = h.slice(h.indexOf(" ") + 1);
|
|
if (Array.isArray(obj[key2])) {
|
|
obj[key2].push(value);
|
|
} else {
|
|
obj[key2] = value;
|
|
}
|
|
}
|
|
if (obj.author) {
|
|
obj.author = parseAuthor(obj.author);
|
|
}
|
|
if (obj.committer) {
|
|
obj.committer = parseAuthor(obj.committer);
|
|
}
|
|
return obj;
|
|
}
|
|
static renderHeaders(obj) {
|
|
let headers = "";
|
|
if (obj.tree) {
|
|
headers += `tree ${obj.tree}
|
|
`;
|
|
} else {
|
|
headers += `tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904
|
|
`;
|
|
}
|
|
if (obj.parent) {
|
|
if (obj.parent.length === void 0) {
|
|
throw new InternalError(`commit 'parent' property should be an array`);
|
|
}
|
|
for (const p of obj.parent) {
|
|
headers += `parent ${p}
|
|
`;
|
|
}
|
|
}
|
|
const author = obj.author;
|
|
headers += `author ${formatAuthor(author)}
|
|
`;
|
|
const committer = obj.committer || obj.author;
|
|
headers += `committer ${formatAuthor(committer)}
|
|
`;
|
|
if (obj.gpgsig) {
|
|
headers += "gpgsig" + indent(obj.gpgsig);
|
|
}
|
|
return headers;
|
|
}
|
|
static render(obj) {
|
|
return GitCommit.renderHeaders(obj) + "\n" + normalizeNewlines(obj.message);
|
|
}
|
|
render() {
|
|
return this._commit;
|
|
}
|
|
withoutSignature() {
|
|
const commit2 = normalizeNewlines(this._commit);
|
|
if (commit2.indexOf("\ngpgsig") === -1)
|
|
return commit2;
|
|
const headers = commit2.slice(0, commit2.indexOf("\ngpgsig"));
|
|
const message = commit2.slice(commit2.indexOf("-----END PGP SIGNATURE-----\n") + "-----END PGP SIGNATURE-----\n".length);
|
|
return normalizeNewlines(headers + "\n" + message);
|
|
}
|
|
isolateSignature() {
|
|
const signature = this._commit.slice(this._commit.indexOf("-----BEGIN PGP SIGNATURE-----"), this._commit.indexOf("-----END PGP SIGNATURE-----") + "-----END PGP SIGNATURE-----".length);
|
|
return outdent(signature);
|
|
}
|
|
static async sign(commit2, sign, secretKey) {
|
|
const payload = commit2.withoutSignature();
|
|
const message = GitCommit.justMessage(commit2._commit);
|
|
let { signature } = await sign({ payload, secretKey });
|
|
signature = normalizeNewlines(signature);
|
|
const headers = GitCommit.justHeaders(commit2._commit);
|
|
const signedCommit = headers + "\ngpgsig" + indent(signature) + "\n" + message;
|
|
return GitCommit.from(signedCommit);
|
|
}
|
|
};
|
|
async function resolveTree({ fs, cache, gitdir, oid }) {
|
|
if (oid === "4b825dc642cb6eb9a060e54bf8d69288fbee4904") {
|
|
return { tree: GitTree.from([]), oid };
|
|
}
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
if (type === "tag") {
|
|
oid = GitAnnotatedTag.from(object).parse().object;
|
|
return resolveTree({ fs, cache, gitdir, oid });
|
|
}
|
|
if (type === "commit") {
|
|
oid = GitCommit.from(object).parse().tree;
|
|
return resolveTree({ fs, cache, gitdir, oid });
|
|
}
|
|
if (type !== "tree") {
|
|
throw new ObjectTypeError(oid, type, "tree");
|
|
}
|
|
return { tree: GitTree.from(object), oid };
|
|
}
|
|
var GitWalkerRepo = class {
|
|
constructor({ fs, gitdir, ref, cache }) {
|
|
this.fs = fs;
|
|
this.cache = cache;
|
|
this.gitdir = gitdir;
|
|
this.mapPromise = (async () => {
|
|
const map = new Map();
|
|
let oid;
|
|
try {
|
|
oid = await GitRefManager.resolve({ fs, gitdir, ref });
|
|
} catch (e) {
|
|
if (e instanceof NotFoundError) {
|
|
oid = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
|
|
}
|
|
}
|
|
const tree = await resolveTree({ fs, cache: this.cache, gitdir, oid });
|
|
tree.type = "tree";
|
|
tree.mode = "40000";
|
|
map.set(".", tree);
|
|
return map;
|
|
})();
|
|
const walker = this;
|
|
this.ConstructEntry = class TreeEntry {
|
|
constructor(fullpath) {
|
|
this._fullpath = fullpath;
|
|
this._type = false;
|
|
this._mode = false;
|
|
this._stat = false;
|
|
this._content = false;
|
|
this._oid = false;
|
|
}
|
|
async type() {
|
|
return walker.type(this);
|
|
}
|
|
async mode() {
|
|
return walker.mode(this);
|
|
}
|
|
async stat() {
|
|
return walker.stat(this);
|
|
}
|
|
async content() {
|
|
return walker.content(this);
|
|
}
|
|
async oid() {
|
|
return walker.oid(this);
|
|
}
|
|
};
|
|
}
|
|
async readdir(entry) {
|
|
const filepath = entry._fullpath;
|
|
const { fs, cache, gitdir } = this;
|
|
const map = await this.mapPromise;
|
|
const obj = map.get(filepath);
|
|
if (!obj)
|
|
throw new Error(`No obj for ${filepath}`);
|
|
const oid = obj.oid;
|
|
if (!oid)
|
|
throw new Error(`No oid for obj ${JSON.stringify(obj)}`);
|
|
if (obj.type !== "tree") {
|
|
return null;
|
|
}
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
if (type !== obj.type) {
|
|
throw new ObjectTypeError(oid, type, obj.type);
|
|
}
|
|
const tree = GitTree.from(object);
|
|
for (const entry2 of tree) {
|
|
map.set(join(filepath, entry2.path), entry2);
|
|
}
|
|
return tree.entries().map((entry2) => join(filepath, entry2.path));
|
|
}
|
|
async type(entry) {
|
|
if (entry._type === false) {
|
|
const map = await this.mapPromise;
|
|
const { type } = map.get(entry._fullpath);
|
|
entry._type = type;
|
|
}
|
|
return entry._type;
|
|
}
|
|
async mode(entry) {
|
|
if (entry._mode === false) {
|
|
const map = await this.mapPromise;
|
|
const { mode } = map.get(entry._fullpath);
|
|
entry._mode = normalizeMode(parseInt(mode, 8));
|
|
}
|
|
return entry._mode;
|
|
}
|
|
async stat(_entry) {
|
|
}
|
|
async content(entry) {
|
|
if (entry._content === false) {
|
|
const map = await this.mapPromise;
|
|
const { fs, cache, gitdir } = this;
|
|
const obj = map.get(entry._fullpath);
|
|
const oid = obj.oid;
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
if (type !== "blob") {
|
|
entry._content = void 0;
|
|
} else {
|
|
entry._content = new Uint8Array(object);
|
|
}
|
|
}
|
|
return entry._content;
|
|
}
|
|
async oid(entry) {
|
|
if (entry._oid === false) {
|
|
const map = await this.mapPromise;
|
|
const obj = map.get(entry._fullpath);
|
|
entry._oid = obj.oid;
|
|
}
|
|
return entry._oid;
|
|
}
|
|
};
|
|
function TREE({ ref = "HEAD" } = {}) {
|
|
const o = Object.create(null);
|
|
Object.defineProperty(o, GitWalkSymbol, {
|
|
value: function({ fs, gitdir, cache }) {
|
|
return new GitWalkerRepo({ fs, gitdir, ref, cache });
|
|
}
|
|
});
|
|
Object.freeze(o);
|
|
return o;
|
|
}
|
|
var GitWalkerFs = class {
|
|
constructor({ fs, dir, gitdir, cache }) {
|
|
this.fs = fs;
|
|
this.cache = cache;
|
|
this.dir = dir;
|
|
this.gitdir = gitdir;
|
|
const walker = this;
|
|
this.ConstructEntry = class WorkdirEntry {
|
|
constructor(fullpath) {
|
|
this._fullpath = fullpath;
|
|
this._type = false;
|
|
this._mode = false;
|
|
this._stat = false;
|
|
this._content = false;
|
|
this._oid = false;
|
|
}
|
|
async type() {
|
|
return walker.type(this);
|
|
}
|
|
async mode() {
|
|
return walker.mode(this);
|
|
}
|
|
async stat() {
|
|
return walker.stat(this);
|
|
}
|
|
async content() {
|
|
return walker.content(this);
|
|
}
|
|
async oid() {
|
|
return walker.oid(this);
|
|
}
|
|
};
|
|
}
|
|
async readdir(entry) {
|
|
const filepath = entry._fullpath;
|
|
const { fs, dir } = this;
|
|
const names = await fs.readdir(join(dir, filepath));
|
|
if (names === null)
|
|
return null;
|
|
return names.map((name) => join(filepath, name));
|
|
}
|
|
async type(entry) {
|
|
if (entry._type === false) {
|
|
await entry.stat();
|
|
}
|
|
return entry._type;
|
|
}
|
|
async mode(entry) {
|
|
if (entry._mode === false) {
|
|
await entry.stat();
|
|
}
|
|
return entry._mode;
|
|
}
|
|
async stat(entry) {
|
|
if (entry._stat === false) {
|
|
const { fs, dir } = this;
|
|
let stat = await fs.lstat(`${dir}/${entry._fullpath}`);
|
|
if (!stat) {
|
|
throw new Error(`ENOENT: no such file or directory, lstat '${entry._fullpath}'`);
|
|
}
|
|
let type = stat.isDirectory() ? "tree" : "blob";
|
|
if (type === "blob" && !stat.isFile() && !stat.isSymbolicLink()) {
|
|
type = "special";
|
|
}
|
|
entry._type = type;
|
|
stat = normalizeStats(stat);
|
|
entry._mode = stat.mode;
|
|
if (stat.size === -1 && entry._actualSize) {
|
|
stat.size = entry._actualSize;
|
|
}
|
|
entry._stat = stat;
|
|
}
|
|
return entry._stat;
|
|
}
|
|
async content(entry) {
|
|
if (entry._content === false) {
|
|
const { fs, dir } = this;
|
|
if (await entry.type() === "tree") {
|
|
entry._content = void 0;
|
|
} else {
|
|
const content = await fs.read(`${dir}/${entry._fullpath}`);
|
|
entry._actualSize = content.length;
|
|
if (entry._stat && entry._stat.size === -1) {
|
|
entry._stat.size = entry._actualSize;
|
|
}
|
|
entry._content = new Uint8Array(content);
|
|
}
|
|
}
|
|
return entry._content;
|
|
}
|
|
async oid(entry) {
|
|
if (entry._oid === false) {
|
|
const { fs, gitdir, cache } = this;
|
|
let oid;
|
|
await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
const stage = index2.entriesMap.get(entry._fullpath);
|
|
const stats = await entry.stat();
|
|
if (!stage || compareStats(stats, stage)) {
|
|
const content = await entry.content();
|
|
if (content === void 0) {
|
|
oid = void 0;
|
|
} else {
|
|
oid = await shasum(GitObject.wrap({ type: "blob", object: await entry.content() }));
|
|
if (stage && oid === stage.oid && stats.mode === stage.mode && compareStats(stats, stage)) {
|
|
index2.insert({
|
|
filepath: entry._fullpath,
|
|
stats,
|
|
oid
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
oid = stage.oid;
|
|
}
|
|
});
|
|
entry._oid = oid;
|
|
}
|
|
return entry._oid;
|
|
}
|
|
};
|
|
function WORKDIR() {
|
|
const o = Object.create(null);
|
|
Object.defineProperty(o, GitWalkSymbol, {
|
|
value: function({ fs, dir, gitdir, cache }) {
|
|
return new GitWalkerFs({ fs, dir, gitdir, cache });
|
|
}
|
|
});
|
|
Object.freeze(o);
|
|
return o;
|
|
}
|
|
var GitIgnoreManager = class {
|
|
static async isIgnored({ fs, dir, gitdir = join(dir, ".git"), filepath }) {
|
|
if (basename(filepath) === ".git")
|
|
return true;
|
|
if (filepath === ".")
|
|
return false;
|
|
let excludes = "";
|
|
const excludesFile = join(gitdir, "info", "exclude");
|
|
if (await fs.exists(excludesFile)) {
|
|
excludes = await fs.read(excludesFile, "utf8");
|
|
}
|
|
const pairs = [
|
|
{
|
|
gitignore: join(dir, ".gitignore"),
|
|
filepath
|
|
}
|
|
];
|
|
const pieces = filepath.split("/").filter(Boolean);
|
|
for (let i = 1; i < pieces.length; i++) {
|
|
const folder = pieces.slice(0, i).join("/");
|
|
const file = pieces.slice(i).join("/");
|
|
pairs.push({
|
|
gitignore: join(dir, folder, ".gitignore"),
|
|
filepath: file
|
|
});
|
|
}
|
|
let ignoredStatus = false;
|
|
for (const p of pairs) {
|
|
let file;
|
|
try {
|
|
file = await fs.read(p.gitignore, "utf8");
|
|
} catch (err) {
|
|
if (err.code === "NOENT")
|
|
continue;
|
|
}
|
|
const ign = (0, import_ignore.default)().add(excludes);
|
|
ign.add(file);
|
|
const parentdir = dirname(p.filepath);
|
|
if (parentdir !== "." && ign.ignores(parentdir))
|
|
return true;
|
|
if (ignoredStatus) {
|
|
ignoredStatus = !ign.test(p.filepath).unignored;
|
|
} else {
|
|
ignoredStatus = ign.test(p.filepath).ignored;
|
|
}
|
|
}
|
|
return ignoredStatus;
|
|
}
|
|
};
|
|
async function rmRecursive(fs, filepath) {
|
|
const entries = await fs.readdir(filepath);
|
|
if (entries == null) {
|
|
await fs.rm(filepath);
|
|
} else if (entries.length) {
|
|
await Promise.all(entries.map((entry) => {
|
|
const subpath = join(filepath, entry);
|
|
return fs.lstat(subpath).then((stat) => {
|
|
if (!stat)
|
|
return;
|
|
return stat.isDirectory() ? rmRecursive(fs, subpath) : fs.rm(subpath);
|
|
});
|
|
})).then(() => fs.rmdir(filepath));
|
|
} else {
|
|
await fs.rmdir(filepath);
|
|
}
|
|
}
|
|
var FileSystem = class {
|
|
constructor(fs) {
|
|
if (typeof fs._original_unwrapped_fs !== "undefined")
|
|
return fs;
|
|
const promises = Object.getOwnPropertyDescriptor(fs, "promises");
|
|
if (promises && promises.enumerable) {
|
|
this._readFile = fs.promises.readFile.bind(fs.promises);
|
|
this._writeFile = fs.promises.writeFile.bind(fs.promises);
|
|
this._mkdir = fs.promises.mkdir.bind(fs.promises);
|
|
if (fs.promises.rm) {
|
|
this._rm = fs.promises.rm.bind(fs.promises);
|
|
} else if (fs.promises.rmdir.length > 1) {
|
|
this._rm = fs.promises.rmdir.bind(fs.promises);
|
|
} else {
|
|
this._rm = rmRecursive.bind(null, this);
|
|
}
|
|
this._rmdir = fs.promises.rmdir.bind(fs.promises);
|
|
this._unlink = fs.promises.unlink.bind(fs.promises);
|
|
this._stat = fs.promises.stat.bind(fs.promises);
|
|
this._lstat = fs.promises.lstat.bind(fs.promises);
|
|
this._readdir = fs.promises.readdir.bind(fs.promises);
|
|
this._readlink = fs.promises.readlink.bind(fs.promises);
|
|
this._symlink = fs.promises.symlink.bind(fs.promises);
|
|
} else {
|
|
this._readFile = (0, import_pify.default)(fs.readFile.bind(fs));
|
|
this._writeFile = (0, import_pify.default)(fs.writeFile.bind(fs));
|
|
this._mkdir = (0, import_pify.default)(fs.mkdir.bind(fs));
|
|
if (fs.rm) {
|
|
this._rm = (0, import_pify.default)(fs.rm.bind(fs));
|
|
} else if (fs.rmdir.length > 2) {
|
|
this._rm = (0, import_pify.default)(fs.rmdir.bind(fs));
|
|
} else {
|
|
this._rm = rmRecursive.bind(null, this);
|
|
}
|
|
this._rmdir = (0, import_pify.default)(fs.rmdir.bind(fs));
|
|
this._unlink = (0, import_pify.default)(fs.unlink.bind(fs));
|
|
this._stat = (0, import_pify.default)(fs.stat.bind(fs));
|
|
this._lstat = (0, import_pify.default)(fs.lstat.bind(fs));
|
|
this._readdir = (0, import_pify.default)(fs.readdir.bind(fs));
|
|
this._readlink = (0, import_pify.default)(fs.readlink.bind(fs));
|
|
this._symlink = (0, import_pify.default)(fs.symlink.bind(fs));
|
|
}
|
|
this._original_unwrapped_fs = fs;
|
|
}
|
|
async exists(filepath, options = {}) {
|
|
try {
|
|
await this._stat(filepath);
|
|
return true;
|
|
} catch (err) {
|
|
if (err.code === "ENOENT" || err.code === "ENOTDIR") {
|
|
return false;
|
|
} else {
|
|
console.log('Unhandled error in "FileSystem.exists()" function', err);
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
async read(filepath, options = {}) {
|
|
try {
|
|
let buffer2 = await this._readFile(filepath, options);
|
|
if (typeof buffer2 !== "string") {
|
|
buffer2 = Buffer2.from(buffer2);
|
|
}
|
|
return buffer2;
|
|
} catch (err) {
|
|
return null;
|
|
}
|
|
}
|
|
async write(filepath, contents, options = {}) {
|
|
try {
|
|
await this._writeFile(filepath, contents, options);
|
|
return;
|
|
} catch (err) {
|
|
await this.mkdir(dirname(filepath));
|
|
await this._writeFile(filepath, contents, options);
|
|
}
|
|
}
|
|
async mkdir(filepath, _selfCall = false) {
|
|
try {
|
|
await this._mkdir(filepath);
|
|
return;
|
|
} catch (err) {
|
|
if (err === null)
|
|
return;
|
|
if (err.code === "EEXIST")
|
|
return;
|
|
if (_selfCall)
|
|
throw err;
|
|
if (err.code === "ENOENT") {
|
|
const parent = dirname(filepath);
|
|
if (parent === "." || parent === "/" || parent === filepath)
|
|
throw err;
|
|
await this.mkdir(parent);
|
|
await this.mkdir(filepath, true);
|
|
}
|
|
}
|
|
}
|
|
async rm(filepath) {
|
|
try {
|
|
await this._unlink(filepath);
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT")
|
|
throw err;
|
|
}
|
|
}
|
|
async rmdir(filepath, opts) {
|
|
try {
|
|
if (opts && opts.recursive) {
|
|
await this._rm(filepath, opts);
|
|
} else {
|
|
await this._rmdir(filepath);
|
|
}
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT")
|
|
throw err;
|
|
}
|
|
}
|
|
async readdir(filepath) {
|
|
try {
|
|
const names = await this._readdir(filepath);
|
|
names.sort(compareStrings);
|
|
return names;
|
|
} catch (err) {
|
|
if (err.code === "ENOTDIR")
|
|
return null;
|
|
return [];
|
|
}
|
|
}
|
|
async readdirDeep(dir) {
|
|
const subdirs = await this._readdir(dir);
|
|
const files = await Promise.all(subdirs.map(async (subdir) => {
|
|
const res = dir + "/" + subdir;
|
|
return (await this._stat(res)).isDirectory() ? this.readdirDeep(res) : res;
|
|
}));
|
|
return files.reduce((a, f) => a.concat(f), []);
|
|
}
|
|
async lstat(filename) {
|
|
try {
|
|
const stats = await this._lstat(filename);
|
|
return stats;
|
|
} catch (err) {
|
|
if (err.code === "ENOENT") {
|
|
return null;
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
async readlink(filename, opts = { encoding: "buffer" }) {
|
|
try {
|
|
const link = await this._readlink(filename, opts);
|
|
return Buffer2.isBuffer(link) ? link : Buffer2.from(link);
|
|
} catch (err) {
|
|
if (err.code === "ENOENT") {
|
|
return null;
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
async writelink(filename, buffer2) {
|
|
return this._symlink(buffer2.toString("utf8"), filename);
|
|
}
|
|
};
|
|
async function writeObjectLoose({ fs, gitdir, object, format, oid }) {
|
|
if (format !== "deflated") {
|
|
throw new InternalError("GitObjectStoreLoose expects objects to write to be in deflated format");
|
|
}
|
|
const source = `objects/${oid.slice(0, 2)}/${oid.slice(2)}`;
|
|
const filepath = `${gitdir}/${source}`;
|
|
if (!await fs.exists(filepath))
|
|
await fs.write(filepath, object);
|
|
}
|
|
var supportsCompressionStream = null;
|
|
async function deflate(buffer2) {
|
|
if (supportsCompressionStream === null) {
|
|
supportsCompressionStream = testCompressionStream();
|
|
}
|
|
return supportsCompressionStream ? browserDeflate(buffer2) : import_pako.default.deflate(buffer2);
|
|
}
|
|
async function browserDeflate(buffer2) {
|
|
const cs = new CompressionStream("deflate");
|
|
const c = new Blob([buffer2]).stream().pipeThrough(cs);
|
|
return new Uint8Array(await new Response(c).arrayBuffer());
|
|
}
|
|
function testCompressionStream() {
|
|
try {
|
|
const cs = new CompressionStream("deflate");
|
|
new Blob([]).stream();
|
|
if (cs)
|
|
return true;
|
|
} catch (_) {
|
|
}
|
|
return false;
|
|
}
|
|
async function _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type,
|
|
object,
|
|
format = "content",
|
|
oid = void 0,
|
|
dryRun = false
|
|
}) {
|
|
if (format !== "deflated") {
|
|
if (format !== "wrapped") {
|
|
object = GitObject.wrap({ type, object });
|
|
}
|
|
oid = await shasum(object);
|
|
object = Buffer2.from(await deflate(object));
|
|
}
|
|
if (!dryRun) {
|
|
await writeObjectLoose({ fs, gitdir, object, format: "deflated", oid });
|
|
}
|
|
return oid;
|
|
}
|
|
function assertParameter(name, value) {
|
|
if (value === void 0) {
|
|
throw new MissingParameterError(name);
|
|
}
|
|
}
|
|
function posixifyPathBuffer(buffer2) {
|
|
let idx;
|
|
while (~(idx = buffer2.indexOf(92)))
|
|
buffer2[idx] = 47;
|
|
return buffer2;
|
|
}
|
|
async function add({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
filepath,
|
|
cache = {},
|
|
force = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("dir", dir);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("filepath", filepath);
|
|
const fs = new FileSystem(_fs);
|
|
await GitIndexManager.acquire({ fs, gitdir, cache }, async (index2) => {
|
|
return addToIndex({ dir, gitdir, fs, filepath, index: index2, force });
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.add";
|
|
throw err;
|
|
}
|
|
}
|
|
async function addToIndex({ dir, gitdir, fs, filepath, index: index2, force }) {
|
|
filepath = Array.isArray(filepath) ? filepath : [filepath];
|
|
const promises = filepath.map(async (currentFilepath) => {
|
|
if (!force) {
|
|
const ignored = await GitIgnoreManager.isIgnored({
|
|
fs,
|
|
dir,
|
|
gitdir,
|
|
filepath: currentFilepath
|
|
});
|
|
if (ignored)
|
|
return;
|
|
}
|
|
const stats = await fs.lstat(join(dir, currentFilepath));
|
|
if (!stats)
|
|
throw new NotFoundError(currentFilepath);
|
|
if (stats.isDirectory()) {
|
|
const children2 = await fs.readdir(join(dir, currentFilepath));
|
|
const promises2 = children2.map((child) => addToIndex({
|
|
dir,
|
|
gitdir,
|
|
fs,
|
|
filepath: [join(currentFilepath, child)],
|
|
index: index2,
|
|
force
|
|
}));
|
|
await Promise.all(promises2);
|
|
} else {
|
|
const object = stats.isSymbolicLink() ? await fs.readlink(join(dir, currentFilepath)).then(posixifyPathBuffer) : await fs.read(join(dir, currentFilepath));
|
|
if (object === null)
|
|
throw new NotFoundError(currentFilepath);
|
|
const oid = await _writeObject({ fs, gitdir, type: "blob", object });
|
|
index2.insert({ filepath: currentFilepath, stats, oid });
|
|
}
|
|
});
|
|
const settledPromises = await Promise.allSettled(promises);
|
|
const rejectedPromises = settledPromises.filter((settle) => settle.status === "rejected").map((settle) => settle.reason);
|
|
if (rejectedPromises.length > 1) {
|
|
throw new MultipleGitError(rejectedPromises);
|
|
}
|
|
if (rejectedPromises.length === 1) {
|
|
throw rejectedPromises[0];
|
|
}
|
|
const fulfilledPromises = settledPromises.filter((settle) => settle.status === "fulfilled" && settle.value).map((settle) => settle.value);
|
|
return fulfilledPromises;
|
|
}
|
|
async function _commit({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
message,
|
|
author,
|
|
committer,
|
|
signingKey,
|
|
dryRun = false,
|
|
noUpdateBranch = false,
|
|
ref,
|
|
parent,
|
|
tree
|
|
}) {
|
|
if (!ref) {
|
|
ref = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: "HEAD",
|
|
depth: 2
|
|
});
|
|
}
|
|
return GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
const inodes = flatFileListToDirectoryStructure(index2.entries);
|
|
const inode = inodes.get(".");
|
|
if (!tree) {
|
|
tree = await constructTree({ fs, gitdir, inode, dryRun });
|
|
}
|
|
if (!parent) {
|
|
try {
|
|
parent = [
|
|
await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref
|
|
})
|
|
];
|
|
} catch (err) {
|
|
parent = [];
|
|
}
|
|
} else {
|
|
parent = await Promise.all(parent.map((p) => {
|
|
return GitRefManager.resolve({ fs, gitdir, ref: p });
|
|
}));
|
|
}
|
|
let comm = GitCommit.from({
|
|
tree,
|
|
parent,
|
|
author,
|
|
committer,
|
|
message
|
|
});
|
|
if (signingKey) {
|
|
comm = await GitCommit.sign(comm, onSign, signingKey);
|
|
}
|
|
const oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "commit",
|
|
object: comm.toObject(),
|
|
dryRun
|
|
});
|
|
if (!noUpdateBranch && !dryRun) {
|
|
await GitRefManager.writeRef({
|
|
fs,
|
|
gitdir,
|
|
ref,
|
|
value: oid
|
|
});
|
|
}
|
|
return oid;
|
|
});
|
|
}
|
|
async function constructTree({ fs, gitdir, inode, dryRun }) {
|
|
const children2 = inode.children;
|
|
for (const inode2 of children2) {
|
|
if (inode2.type === "tree") {
|
|
inode2.metadata.mode = "040000";
|
|
inode2.metadata.oid = await constructTree({ fs, gitdir, inode: inode2, dryRun });
|
|
}
|
|
}
|
|
const entries = children2.map((inode2) => ({
|
|
mode: inode2.metadata.mode,
|
|
path: inode2.basename,
|
|
oid: inode2.metadata.oid,
|
|
type: inode2.type
|
|
}));
|
|
const tree = GitTree.from(entries);
|
|
const oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "tree",
|
|
object: tree.toObject(),
|
|
dryRun
|
|
});
|
|
return oid;
|
|
}
|
|
async function resolveFilepath({ fs, cache, gitdir, oid, filepath }) {
|
|
if (filepath.startsWith("/")) {
|
|
throw new InvalidFilepathError("leading-slash");
|
|
} else if (filepath.endsWith("/")) {
|
|
throw new InvalidFilepathError("trailing-slash");
|
|
}
|
|
const _oid = oid;
|
|
const result = await resolveTree({ fs, cache, gitdir, oid });
|
|
const tree = result.tree;
|
|
if (filepath === "") {
|
|
oid = result.oid;
|
|
} else {
|
|
const pathArray = filepath.split("/");
|
|
oid = await _resolveFilepath({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
tree,
|
|
pathArray,
|
|
oid: _oid,
|
|
filepath
|
|
});
|
|
}
|
|
return oid;
|
|
}
|
|
async function _resolveFilepath({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
tree,
|
|
pathArray,
|
|
oid,
|
|
filepath
|
|
}) {
|
|
const name = pathArray.shift();
|
|
for (const entry of tree) {
|
|
if (entry.path === name) {
|
|
if (pathArray.length === 0) {
|
|
return entry.oid;
|
|
} else {
|
|
const { type, object } = await _readObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: entry.oid
|
|
});
|
|
if (type !== "tree") {
|
|
throw new ObjectTypeError(oid, type, "blob", filepath);
|
|
}
|
|
tree = GitTree.from(object);
|
|
return _resolveFilepath({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
tree,
|
|
pathArray,
|
|
oid,
|
|
filepath
|
|
});
|
|
}
|
|
}
|
|
}
|
|
throw new NotFoundError(`file or directory found at "${oid}:${filepath}"`);
|
|
}
|
|
async function _readTree({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filepath = void 0
|
|
}) {
|
|
if (filepath !== void 0) {
|
|
oid = await resolveFilepath({ fs, cache, gitdir, oid, filepath });
|
|
}
|
|
const { tree, oid: treeOid } = await resolveTree({ fs, cache, gitdir, oid });
|
|
const result = {
|
|
oid: treeOid,
|
|
tree: tree.entries()
|
|
};
|
|
return result;
|
|
}
|
|
async function _writeTree({ fs, gitdir, tree }) {
|
|
const object = GitTree.from(tree).toObject();
|
|
const oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "tree",
|
|
object,
|
|
format: "content"
|
|
});
|
|
return oid;
|
|
}
|
|
async function _addNote({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref,
|
|
oid,
|
|
note,
|
|
force,
|
|
author,
|
|
committer,
|
|
signingKey
|
|
}) {
|
|
let parent;
|
|
try {
|
|
parent = await GitRefManager.resolve({ gitdir, fs, ref });
|
|
} catch (err) {
|
|
if (!(err instanceof NotFoundError)) {
|
|
throw err;
|
|
}
|
|
}
|
|
const result = await _readTree({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: parent || "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
|
|
});
|
|
let tree = result.tree;
|
|
if (force) {
|
|
tree = tree.filter((entry) => entry.path !== oid);
|
|
} else {
|
|
for (const entry of tree) {
|
|
if (entry.path === oid) {
|
|
throw new AlreadyExistsError("note", oid);
|
|
}
|
|
}
|
|
}
|
|
if (typeof note === "string") {
|
|
note = Buffer2.from(note, "utf8");
|
|
}
|
|
const noteOid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "blob",
|
|
object: note,
|
|
format: "content"
|
|
});
|
|
tree.push({ mode: "100644", path: oid, oid: noteOid, type: "blob" });
|
|
const treeOid = await _writeTree({
|
|
fs,
|
|
gitdir,
|
|
tree
|
|
});
|
|
const commitOid = await _commit({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref,
|
|
tree: treeOid,
|
|
parent: parent && [parent],
|
|
message: `Note added by 'isomorphic-git addNote'
|
|
`,
|
|
author,
|
|
committer,
|
|
signingKey
|
|
});
|
|
return commitOid;
|
|
}
|
|
async function _getConfig({ fs, gitdir, path: path2 }) {
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
return config.get(path2);
|
|
}
|
|
async function normalizeAuthorObject({ fs, gitdir, author = {} }) {
|
|
let { name, email, timestamp, timezoneOffset } = author;
|
|
name = name || await _getConfig({ fs, gitdir, path: "user.name" });
|
|
email = email || await _getConfig({ fs, gitdir, path: "user.email" }) || "";
|
|
if (name === void 0) {
|
|
return void 0;
|
|
}
|
|
timestamp = timestamp != null ? timestamp : Math.floor(Date.now() / 1e3);
|
|
timezoneOffset = timezoneOffset != null ? timezoneOffset : new Date(timestamp * 1e3).getTimezoneOffset();
|
|
return { name, email, timestamp, timezoneOffset };
|
|
}
|
|
async function normalizeCommitterObject({
|
|
fs,
|
|
gitdir,
|
|
author,
|
|
committer
|
|
}) {
|
|
committer = Object.assign({}, committer || author);
|
|
if (author) {
|
|
committer.timestamp = committer.timestamp || author.timestamp;
|
|
committer.timezoneOffset = committer.timezoneOffset || author.timezoneOffset;
|
|
}
|
|
committer = await normalizeAuthorObject({ fs, gitdir, author: committer });
|
|
return committer;
|
|
}
|
|
async function addNote({
|
|
fs: _fs,
|
|
onSign,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref = "refs/notes/commits",
|
|
oid,
|
|
note,
|
|
force,
|
|
author: _author,
|
|
committer: _committer,
|
|
signingKey,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
assertParameter("note", note);
|
|
if (signingKey) {
|
|
assertParameter("onSign", onSign);
|
|
}
|
|
const fs = new FileSystem(_fs);
|
|
const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
|
|
if (!author)
|
|
throw new MissingNameError("author");
|
|
const committer = await normalizeCommitterObject({
|
|
fs,
|
|
gitdir,
|
|
author,
|
|
committer: _committer
|
|
});
|
|
if (!committer)
|
|
throw new MissingNameError("committer");
|
|
return await _addNote({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref,
|
|
oid,
|
|
note,
|
|
force,
|
|
author,
|
|
committer,
|
|
signingKey
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.addNote";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _addRemote({ fs, gitdir, remote, url, force }) {
|
|
if (remote !== import_clean_git_ref.default.clean(remote)) {
|
|
throw new InvalidRefNameError(remote, import_clean_git_ref.default.clean(remote));
|
|
}
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
if (!force) {
|
|
const remoteNames = await config.getSubsections("remote");
|
|
if (remoteNames.includes(remote)) {
|
|
if (url !== await config.get(`remote.${remote}.url`)) {
|
|
throw new AlreadyExistsError("remote", remote);
|
|
}
|
|
}
|
|
}
|
|
await config.set(`remote.${remote}.url`, url);
|
|
await config.set(`remote.${remote}.fetch`, `+refs/heads/*:refs/remotes/${remote}/*`);
|
|
await GitConfigManager.save({ fs, gitdir, config });
|
|
}
|
|
async function addRemote({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
remote,
|
|
url,
|
|
force = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("remote", remote);
|
|
assertParameter("url", url);
|
|
return await _addRemote({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
remote,
|
|
url,
|
|
force
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.addRemote";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _annotatedTag({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref,
|
|
tagger,
|
|
message = ref,
|
|
gpgsig,
|
|
object,
|
|
signingKey,
|
|
force = false
|
|
}) {
|
|
ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`;
|
|
if (!force && await GitRefManager.exists({ fs, gitdir, ref })) {
|
|
throw new AlreadyExistsError("tag", ref);
|
|
}
|
|
const oid = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: object || "HEAD"
|
|
});
|
|
const { type } = await _readObject({ fs, cache, gitdir, oid });
|
|
let tagObject = GitAnnotatedTag.from({
|
|
object: oid,
|
|
type,
|
|
tag: ref.replace("refs/tags/", ""),
|
|
tagger,
|
|
message,
|
|
gpgsig
|
|
});
|
|
if (signingKey) {
|
|
tagObject = await GitAnnotatedTag.sign(tagObject, onSign, signingKey);
|
|
}
|
|
const value = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "tag",
|
|
object: tagObject.toObject()
|
|
});
|
|
await GitRefManager.writeRef({ fs, gitdir, ref, value });
|
|
}
|
|
async function annotatedTag({
|
|
fs: _fs,
|
|
onSign,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
tagger: _tagger,
|
|
message = ref,
|
|
gpgsig,
|
|
object,
|
|
signingKey,
|
|
force = false,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
if (signingKey) {
|
|
assertParameter("onSign", onSign);
|
|
}
|
|
const fs = new FileSystem(_fs);
|
|
const tagger = await normalizeAuthorObject({ fs, gitdir, author: _tagger });
|
|
if (!tagger)
|
|
throw new MissingNameError("tagger");
|
|
return await _annotatedTag({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref,
|
|
tagger,
|
|
message,
|
|
gpgsig,
|
|
object,
|
|
signingKey,
|
|
force
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.annotatedTag";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _branch({
|
|
fs,
|
|
gitdir,
|
|
ref,
|
|
object,
|
|
checkout: checkout2 = false,
|
|
force = false
|
|
}) {
|
|
if (ref !== import_clean_git_ref.default.clean(ref)) {
|
|
throw new InvalidRefNameError(ref, import_clean_git_ref.default.clean(ref));
|
|
}
|
|
const fullref = `refs/heads/${ref}`;
|
|
if (!force) {
|
|
const exist = await GitRefManager.exists({ fs, gitdir, ref: fullref });
|
|
if (exist) {
|
|
throw new AlreadyExistsError("branch", ref, false);
|
|
}
|
|
}
|
|
let oid;
|
|
try {
|
|
oid = await GitRefManager.resolve({ fs, gitdir, ref: object || "HEAD" });
|
|
} catch (e) {
|
|
}
|
|
if (oid) {
|
|
await GitRefManager.writeRef({ fs, gitdir, ref: fullref, value: oid });
|
|
}
|
|
if (checkout2) {
|
|
await GitRefManager.writeSymbolicRef({
|
|
fs,
|
|
gitdir,
|
|
ref: "HEAD",
|
|
value: fullref
|
|
});
|
|
}
|
|
}
|
|
async function branch({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
object,
|
|
checkout: checkout2 = false,
|
|
force = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
return await _branch({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
ref,
|
|
object,
|
|
checkout: checkout2,
|
|
force
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.branch";
|
|
throw err;
|
|
}
|
|
}
|
|
function arrayRange(start, end) {
|
|
const length = end - start;
|
|
return Array.from({ length }, (_, i) => start + i);
|
|
}
|
|
var flat = typeof Array.prototype.flat === "undefined" ? (entries) => entries.reduce((acc, x) => acc.concat(x), []) : (entries) => entries.flat();
|
|
var RunningMinimum = class {
|
|
constructor() {
|
|
this.value = null;
|
|
}
|
|
consider(value) {
|
|
if (value === null || value === void 0)
|
|
return;
|
|
if (this.value === null) {
|
|
this.value = value;
|
|
} else if (value < this.value) {
|
|
this.value = value;
|
|
}
|
|
}
|
|
reset() {
|
|
this.value = null;
|
|
}
|
|
};
|
|
function* unionOfIterators(sets) {
|
|
const min = new RunningMinimum();
|
|
let minimum;
|
|
const heads = [];
|
|
const numsets = sets.length;
|
|
for (let i = 0; i < numsets; i++) {
|
|
heads[i] = sets[i].next().value;
|
|
if (heads[i] !== void 0) {
|
|
min.consider(heads[i]);
|
|
}
|
|
}
|
|
if (min.value === null)
|
|
return;
|
|
while (true) {
|
|
const result = [];
|
|
minimum = min.value;
|
|
min.reset();
|
|
for (let i = 0; i < numsets; i++) {
|
|
if (heads[i] !== void 0 && heads[i] === minimum) {
|
|
result[i] = heads[i];
|
|
heads[i] = sets[i].next().value;
|
|
} else {
|
|
result[i] = null;
|
|
}
|
|
if (heads[i] !== void 0) {
|
|
min.consider(heads[i]);
|
|
}
|
|
}
|
|
yield result;
|
|
if (min.value === null)
|
|
return;
|
|
}
|
|
}
|
|
async function _walk({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
trees,
|
|
map = async (_, entry) => entry,
|
|
reduce = async (parent, children2) => {
|
|
const flatten = flat(children2);
|
|
if (parent !== void 0)
|
|
flatten.unshift(parent);
|
|
return flatten;
|
|
},
|
|
iterate = (walk2, children2) => Promise.all([...children2].map(walk2))
|
|
}) {
|
|
const walkers = trees.map((proxy) => proxy[GitWalkSymbol]({ fs, dir, gitdir, cache }));
|
|
const root = new Array(walkers.length).fill(".");
|
|
const range = arrayRange(0, walkers.length);
|
|
const unionWalkerFromReaddir = async (entries) => {
|
|
range.map((i) => {
|
|
entries[i] = entries[i] && new walkers[i].ConstructEntry(entries[i]);
|
|
});
|
|
const subdirs = await Promise.all(range.map((i) => entries[i] ? walkers[i].readdir(entries[i]) : []));
|
|
const iterators = subdirs.map((array) => array === null ? [] : array).map((array) => array[Symbol.iterator]());
|
|
return {
|
|
entries,
|
|
children: unionOfIterators(iterators)
|
|
};
|
|
};
|
|
const walk2 = async (root2) => {
|
|
const { entries, children: children2 } = await unionWalkerFromReaddir(root2);
|
|
const fullpath = entries.find((entry) => entry && entry._fullpath)._fullpath;
|
|
const parent = await map(fullpath, entries);
|
|
if (parent !== null) {
|
|
let walkedChildren = await iterate(walk2, children2);
|
|
walkedChildren = walkedChildren.filter((x) => x !== void 0);
|
|
return reduce(parent, walkedChildren);
|
|
}
|
|
};
|
|
return walk2(root);
|
|
}
|
|
var worthWalking = (filepath, root) => {
|
|
if (filepath === "." || root == null || root.length === 0 || root === ".") {
|
|
return true;
|
|
}
|
|
if (root.length >= filepath.length) {
|
|
return root.startsWith(filepath);
|
|
} else {
|
|
return filepath.startsWith(root);
|
|
}
|
|
};
|
|
async function _checkout({
|
|
fs,
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
remote,
|
|
ref,
|
|
filepaths,
|
|
noCheckout,
|
|
noUpdateHead,
|
|
dryRun,
|
|
force,
|
|
track = true
|
|
}) {
|
|
let oid;
|
|
try {
|
|
oid = await GitRefManager.resolve({ fs, gitdir, ref });
|
|
} catch (err) {
|
|
if (ref === "HEAD")
|
|
throw err;
|
|
const remoteRef = `${remote}/${ref}`;
|
|
oid = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: remoteRef
|
|
});
|
|
if (track) {
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
await config.set(`branch.${ref}.remote`, remote);
|
|
await config.set(`branch.${ref}.merge`, `refs/heads/${ref}`);
|
|
await GitConfigManager.save({ fs, gitdir, config });
|
|
}
|
|
await GitRefManager.writeRef({
|
|
fs,
|
|
gitdir,
|
|
ref: `refs/heads/${ref}`,
|
|
value: oid
|
|
});
|
|
}
|
|
if (!noCheckout) {
|
|
let ops;
|
|
try {
|
|
ops = await analyze({
|
|
fs,
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
ref,
|
|
force,
|
|
filepaths
|
|
});
|
|
} catch (err) {
|
|
if (err instanceof NotFoundError && err.data.what === oid) {
|
|
throw new CommitNotFetchedError(ref, oid);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
const conflicts2 = ops.filter(([method]) => method === "conflict").map(([method, fullpath]) => fullpath);
|
|
if (conflicts2.length > 0) {
|
|
throw new CheckoutConflictError(conflicts2);
|
|
}
|
|
const errors = ops.filter(([method]) => method === "error").map(([method, fullpath]) => fullpath);
|
|
if (errors.length > 0) {
|
|
throw new InternalError(errors.join(", "));
|
|
}
|
|
if (dryRun) {
|
|
return;
|
|
}
|
|
let count = 0;
|
|
const total = ops.length;
|
|
await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
await Promise.all(ops.filter(([method]) => method === "delete" || method === "delete-index").map(async function([method, fullpath]) {
|
|
const filepath = `${dir}/${fullpath}`;
|
|
if (method === "delete") {
|
|
await fs.rm(filepath);
|
|
}
|
|
index2.delete({ filepath: fullpath });
|
|
if (onProgress) {
|
|
await onProgress({
|
|
phase: "Updating workdir",
|
|
loaded: ++count,
|
|
total
|
|
});
|
|
}
|
|
}));
|
|
});
|
|
await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
for (const [method, fullpath] of ops) {
|
|
if (method === "rmdir" || method === "rmdir-index") {
|
|
const filepath = `${dir}/${fullpath}`;
|
|
try {
|
|
if (method === "rmdir-index") {
|
|
index2.delete({ filepath: fullpath });
|
|
}
|
|
await fs.rmdir(filepath);
|
|
if (onProgress) {
|
|
await onProgress({
|
|
phase: "Updating workdir",
|
|
loaded: ++count,
|
|
total
|
|
});
|
|
}
|
|
} catch (e) {
|
|
if (e.code === "ENOTEMPTY") {
|
|
console.log(`Did not delete ${fullpath} because directory is not empty`);
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
await Promise.all(ops.filter(([method]) => method === "mkdir" || method === "mkdir-index").map(async function([_, fullpath]) {
|
|
const filepath = `${dir}/${fullpath}`;
|
|
await fs.mkdir(filepath);
|
|
if (onProgress) {
|
|
await onProgress({
|
|
phase: "Updating workdir",
|
|
loaded: ++count,
|
|
total
|
|
});
|
|
}
|
|
}));
|
|
await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
await Promise.all(ops.filter(([method]) => method === "create" || method === "create-index" || method === "update" || method === "mkdir-index").map(async function([method, fullpath, oid2, mode, chmod]) {
|
|
const filepath = `${dir}/${fullpath}`;
|
|
try {
|
|
if (method !== "create-index" && method !== "mkdir-index") {
|
|
const { object } = await _readObject({ fs, cache, gitdir, oid: oid2 });
|
|
if (chmod) {
|
|
await fs.rm(filepath);
|
|
}
|
|
if (mode === 33188) {
|
|
await fs.write(filepath, object);
|
|
} else if (mode === 33261) {
|
|
await fs.write(filepath, object, { mode: 511 });
|
|
} else if (mode === 40960) {
|
|
await fs.writelink(filepath, object);
|
|
} else {
|
|
throw new InternalError(`Invalid mode 0o${mode.toString(8)} detected in blob ${oid2}`);
|
|
}
|
|
}
|
|
const stats = await fs.lstat(filepath);
|
|
if (mode === 33261) {
|
|
stats.mode = 493;
|
|
}
|
|
if (method === "mkdir-index") {
|
|
stats.mode = 57344;
|
|
}
|
|
index2.insert({
|
|
filepath: fullpath,
|
|
stats,
|
|
oid: oid2
|
|
});
|
|
if (onProgress) {
|
|
await onProgress({
|
|
phase: "Updating workdir",
|
|
loaded: ++count,
|
|
total
|
|
});
|
|
}
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
if (!noUpdateHead) {
|
|
const fullRef = await GitRefManager.expand({ fs, gitdir, ref });
|
|
if (fullRef.startsWith("refs/heads")) {
|
|
await GitRefManager.writeSymbolicRef({
|
|
fs,
|
|
gitdir,
|
|
ref: "HEAD",
|
|
value: fullRef
|
|
});
|
|
} else {
|
|
await GitRefManager.writeRef({ fs, gitdir, ref: "HEAD", value: oid });
|
|
}
|
|
}
|
|
}
|
|
async function analyze({
|
|
fs,
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
ref,
|
|
force,
|
|
filepaths
|
|
}) {
|
|
let count = 0;
|
|
return _walk({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
trees: [TREE({ ref }), WORKDIR(), STAGE()],
|
|
map: async function(fullpath, [commit2, workdir, stage]) {
|
|
if (fullpath === ".")
|
|
return;
|
|
if (filepaths && !filepaths.some((base) => worthWalking(fullpath, base))) {
|
|
return null;
|
|
}
|
|
if (onProgress) {
|
|
await onProgress({ phase: "Analyzing workdir", loaded: ++count });
|
|
}
|
|
const key2 = [!!stage, !!commit2, !!workdir].map(Number).join("");
|
|
switch (key2) {
|
|
case "000":
|
|
return;
|
|
case "001":
|
|
if (force && filepaths && filepaths.includes(fullpath)) {
|
|
return ["delete", fullpath];
|
|
}
|
|
return;
|
|
case "010": {
|
|
switch (await commit2.type()) {
|
|
case "tree": {
|
|
return ["mkdir", fullpath];
|
|
}
|
|
case "blob": {
|
|
return [
|
|
"create",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode()
|
|
];
|
|
}
|
|
case "commit": {
|
|
return [
|
|
"mkdir-index",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode()
|
|
];
|
|
}
|
|
default: {
|
|
return [
|
|
"error",
|
|
`new entry Unhandled type ${await commit2.type()}`
|
|
];
|
|
}
|
|
}
|
|
}
|
|
case "011": {
|
|
switch (`${await commit2.type()}-${await workdir.type()}`) {
|
|
case "tree-tree": {
|
|
return;
|
|
}
|
|
case "tree-blob":
|
|
case "blob-tree": {
|
|
return ["conflict", fullpath];
|
|
}
|
|
case "blob-blob": {
|
|
if (await commit2.oid() !== await workdir.oid()) {
|
|
if (force) {
|
|
return [
|
|
"update",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode(),
|
|
await commit2.mode() !== await workdir.mode()
|
|
];
|
|
} else {
|
|
return ["conflict", fullpath];
|
|
}
|
|
} else {
|
|
if (await commit2.mode() !== await workdir.mode()) {
|
|
if (force) {
|
|
return [
|
|
"update",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode(),
|
|
true
|
|
];
|
|
} else {
|
|
return ["conflict", fullpath];
|
|
}
|
|
} else {
|
|
return [
|
|
"create-index",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode()
|
|
];
|
|
}
|
|
}
|
|
}
|
|
case "commit-tree": {
|
|
return;
|
|
}
|
|
case "commit-blob": {
|
|
return ["conflict", fullpath];
|
|
}
|
|
default: {
|
|
return ["error", `new entry Unhandled type ${commit2.type}`];
|
|
}
|
|
}
|
|
}
|
|
case "100": {
|
|
return ["delete-index", fullpath];
|
|
}
|
|
case "101": {
|
|
switch (await stage.type()) {
|
|
case "tree": {
|
|
return ["rmdir", fullpath];
|
|
}
|
|
case "blob": {
|
|
if (await stage.oid() !== await workdir.oid()) {
|
|
if (force) {
|
|
return ["delete", fullpath];
|
|
} else {
|
|
return ["conflict", fullpath];
|
|
}
|
|
} else {
|
|
return ["delete", fullpath];
|
|
}
|
|
}
|
|
case "commit": {
|
|
return ["rmdir-index", fullpath];
|
|
}
|
|
default: {
|
|
return [
|
|
"error",
|
|
`delete entry Unhandled type ${await stage.type()}`
|
|
];
|
|
}
|
|
}
|
|
}
|
|
case "110":
|
|
case "111": {
|
|
switch (`${await stage.type()}-${await commit2.type()}`) {
|
|
case "tree-tree": {
|
|
return;
|
|
}
|
|
case "blob-blob": {
|
|
if (await stage.oid() === await commit2.oid() && await stage.mode() === await commit2.mode() && !force) {
|
|
return;
|
|
}
|
|
if (workdir) {
|
|
if (await workdir.oid() !== await stage.oid() && await workdir.oid() !== await commit2.oid()) {
|
|
if (force) {
|
|
return [
|
|
"update",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode(),
|
|
await commit2.mode() !== await workdir.mode()
|
|
];
|
|
} else {
|
|
return ["conflict", fullpath];
|
|
}
|
|
}
|
|
} else if (force) {
|
|
return [
|
|
"update",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode(),
|
|
await commit2.mode() !== await stage.mode()
|
|
];
|
|
}
|
|
if (await commit2.mode() !== await stage.mode()) {
|
|
return [
|
|
"update",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode(),
|
|
true
|
|
];
|
|
}
|
|
if (await commit2.oid() !== await stage.oid()) {
|
|
return [
|
|
"update",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode(),
|
|
false
|
|
];
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
case "tree-blob": {
|
|
return ["update-dir-to-blob", fullpath, await commit2.oid()];
|
|
}
|
|
case "blob-tree": {
|
|
return ["update-blob-to-tree", fullpath];
|
|
}
|
|
case "commit-commit": {
|
|
return [
|
|
"mkdir-index",
|
|
fullpath,
|
|
await commit2.oid(),
|
|
await commit2.mode()
|
|
];
|
|
}
|
|
default: {
|
|
return [
|
|
"error",
|
|
`update entry Unhandled type ${await stage.type()}-${await commit2.type()}`
|
|
];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
reduce: async function(parent, children2) {
|
|
children2 = flat(children2);
|
|
if (!parent) {
|
|
return children2;
|
|
} else if (parent && parent[0] === "rmdir") {
|
|
children2.push(parent);
|
|
return children2;
|
|
} else {
|
|
children2.unshift(parent);
|
|
return children2;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
async function checkout({
|
|
fs,
|
|
onProgress,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
remote = "origin",
|
|
ref: _ref,
|
|
filepaths,
|
|
noCheckout = false,
|
|
noUpdateHead = _ref === void 0,
|
|
dryRun = false,
|
|
force = false,
|
|
track = true,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("dir", dir);
|
|
assertParameter("gitdir", gitdir);
|
|
const ref = _ref || "HEAD";
|
|
return await _checkout({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
remote,
|
|
ref,
|
|
filepaths,
|
|
noCheckout,
|
|
noUpdateHead,
|
|
dryRun,
|
|
force,
|
|
track
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.checkout";
|
|
throw err;
|
|
}
|
|
}
|
|
var abbreviateRx = new RegExp("^refs/(heads/|tags/|remotes/)?(.*)");
|
|
function abbreviateRef(ref) {
|
|
const match = abbreviateRx.exec(ref);
|
|
if (match) {
|
|
if (match[1] === "remotes/" && ref.endsWith("/HEAD")) {
|
|
return match[2].slice(0, -5);
|
|
} else {
|
|
return match[2];
|
|
}
|
|
}
|
|
return ref;
|
|
}
|
|
async function _currentBranch({
|
|
fs,
|
|
gitdir,
|
|
fullname = false,
|
|
test = false
|
|
}) {
|
|
const ref = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: "HEAD",
|
|
depth: 2
|
|
});
|
|
if (test) {
|
|
try {
|
|
await GitRefManager.resolve({ fs, gitdir, ref });
|
|
} catch (_) {
|
|
return;
|
|
}
|
|
}
|
|
if (!ref.startsWith("refs/"))
|
|
return;
|
|
return fullname ? ref : abbreviateRef(ref);
|
|
}
|
|
function translateSSHtoHTTP(url) {
|
|
url = url.replace(/^git@([^:]+):/, "https://$1/");
|
|
url = url.replace(/^ssh:\/\//, "https://");
|
|
return url;
|
|
}
|
|
function calculateBasicAuthHeader({ username = "", password = "" }) {
|
|
return `Basic ${Buffer2.from(`${username}:${password}`).toString("base64")}`;
|
|
}
|
|
async function forAwait(iterable, cb) {
|
|
const iter = getIterator(iterable);
|
|
while (true) {
|
|
const { value, done } = await iter.next();
|
|
if (value)
|
|
await cb(value);
|
|
if (done)
|
|
break;
|
|
}
|
|
if (iter.return)
|
|
iter.return();
|
|
}
|
|
async function collect(iterable) {
|
|
let size = 0;
|
|
const buffers = [];
|
|
await forAwait(iterable, (value) => {
|
|
buffers.push(value);
|
|
size += value.byteLength;
|
|
});
|
|
const result = new Uint8Array(size);
|
|
let nextIndex = 0;
|
|
for (const buffer2 of buffers) {
|
|
result.set(buffer2, nextIndex);
|
|
nextIndex += buffer2.byteLength;
|
|
}
|
|
return result;
|
|
}
|
|
function extractAuthFromUrl(url) {
|
|
let userpass = url.match(/^https?:\/\/([^/]+)@/);
|
|
if (userpass == null)
|
|
return { url, auth: {} };
|
|
userpass = userpass[1];
|
|
const [username, password] = userpass.split(":");
|
|
url = url.replace(`${userpass}@`, "");
|
|
return { url, auth: { username, password } };
|
|
}
|
|
function padHex(b, n) {
|
|
const s = n.toString(16);
|
|
return "0".repeat(b - s.length) + s;
|
|
}
|
|
var GitPktLine = class {
|
|
static flush() {
|
|
return Buffer2.from("0000", "utf8");
|
|
}
|
|
static delim() {
|
|
return Buffer2.from("0001", "utf8");
|
|
}
|
|
static encode(line) {
|
|
if (typeof line === "string") {
|
|
line = Buffer2.from(line);
|
|
}
|
|
const length = line.length + 4;
|
|
const hexlength = padHex(4, length);
|
|
return Buffer2.concat([Buffer2.from(hexlength, "utf8"), line]);
|
|
}
|
|
static streamReader(stream) {
|
|
const reader = new StreamReader(stream);
|
|
return async function read() {
|
|
try {
|
|
let length = await reader.read(4);
|
|
if (length == null)
|
|
return true;
|
|
length = parseInt(length.toString("utf8"), 16);
|
|
if (length === 0)
|
|
return null;
|
|
if (length === 1)
|
|
return null;
|
|
const buffer2 = await reader.read(length - 4);
|
|
if (buffer2 == null)
|
|
return true;
|
|
return buffer2;
|
|
} catch (err) {
|
|
console.log("error", err);
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
};
|
|
async function parseCapabilitiesV2(read) {
|
|
const capabilities2 = {};
|
|
let line;
|
|
while (true) {
|
|
line = await read();
|
|
if (line === true)
|
|
break;
|
|
if (line === null)
|
|
continue;
|
|
line = line.toString("utf8").replace(/\n$/, "");
|
|
const i = line.indexOf("=");
|
|
if (i > -1) {
|
|
const key2 = line.slice(0, i);
|
|
const value = line.slice(i + 1);
|
|
capabilities2[key2] = value;
|
|
} else {
|
|
capabilities2[line] = true;
|
|
}
|
|
}
|
|
return { protocolVersion: 2, capabilities2 };
|
|
}
|
|
async function parseRefsAdResponse(stream, { service }) {
|
|
const capabilities = new Set();
|
|
const refs = new Map();
|
|
const symrefs = new Map();
|
|
const read = GitPktLine.streamReader(stream);
|
|
let lineOne = await read();
|
|
while (lineOne === null)
|
|
lineOne = await read();
|
|
if (lineOne === true)
|
|
throw new EmptyServerResponseError();
|
|
if (lineOne.includes("version 2")) {
|
|
return parseCapabilitiesV2(read);
|
|
}
|
|
if (lineOne.toString("utf8").replace(/\n$/, "") !== `# service=${service}`) {
|
|
throw new ParseError(`# service=${service}\\n`, lineOne.toString("utf8"));
|
|
}
|
|
let lineTwo = await read();
|
|
while (lineTwo === null)
|
|
lineTwo = await read();
|
|
if (lineTwo === true)
|
|
return { capabilities, refs, symrefs };
|
|
lineTwo = lineTwo.toString("utf8");
|
|
if (lineTwo.includes("version 2")) {
|
|
return parseCapabilitiesV2(read);
|
|
}
|
|
const [firstRef, capabilitiesLine] = splitAndAssert(lineTwo, "\0", "\\x00");
|
|
capabilitiesLine.split(" ").map((x) => capabilities.add(x));
|
|
const [ref, name] = splitAndAssert(firstRef, " ", " ");
|
|
refs.set(name, ref);
|
|
while (true) {
|
|
const line = await read();
|
|
if (line === true)
|
|
break;
|
|
if (line !== null) {
|
|
const [ref2, name2] = splitAndAssert(line.toString("utf8"), " ", " ");
|
|
refs.set(name2, ref2);
|
|
}
|
|
}
|
|
for (const cap of capabilities) {
|
|
if (cap.startsWith("symref=")) {
|
|
const m = cap.match(/symref=([^:]+):(.*)/);
|
|
if (m.length === 3) {
|
|
symrefs.set(m[1], m[2]);
|
|
}
|
|
}
|
|
}
|
|
return { protocolVersion: 1, capabilities, refs, symrefs };
|
|
}
|
|
function splitAndAssert(line, sep2, expected) {
|
|
const split = line.trim().split(sep2);
|
|
if (split.length !== 2) {
|
|
throw new ParseError(`Two strings separated by '${expected}'`, line.toString("utf8"));
|
|
}
|
|
return split;
|
|
}
|
|
var corsProxify = (corsProxy, url) => corsProxy.endsWith("?") ? `${corsProxy}${url}` : `${corsProxy}/${url.replace(/^https?:\/\//, "")}`;
|
|
var updateHeaders = (headers, auth) => {
|
|
if (auth.username || auth.password) {
|
|
headers.Authorization = calculateBasicAuthHeader(auth);
|
|
}
|
|
if (auth.headers) {
|
|
Object.assign(headers, auth.headers);
|
|
}
|
|
};
|
|
var stringifyBody = async (res) => {
|
|
try {
|
|
const data = Buffer2.from(await collect(res.body));
|
|
const response = data.toString("utf8");
|
|
const preview = response.length < 256 ? response : response.slice(0, 256) + "...";
|
|
return { preview, response, data };
|
|
} catch (e) {
|
|
return {};
|
|
}
|
|
};
|
|
var GitRemoteHTTP = class {
|
|
static async capabilities() {
|
|
return ["discover", "connect"];
|
|
}
|
|
static async discover({
|
|
http,
|
|
onProgress,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
service,
|
|
url: _origUrl,
|
|
headers,
|
|
protocolVersion
|
|
}) {
|
|
let { url, auth } = extractAuthFromUrl(_origUrl);
|
|
const proxifiedURL = corsProxy ? corsProxify(corsProxy, url) : url;
|
|
if (auth.username || auth.password) {
|
|
headers.Authorization = calculateBasicAuthHeader(auth);
|
|
}
|
|
if (protocolVersion === 2) {
|
|
headers["Git-Protocol"] = "version=2";
|
|
}
|
|
let res;
|
|
let tryAgain;
|
|
let providedAuthBefore = false;
|
|
do {
|
|
res = await http.request({
|
|
onProgress,
|
|
method: "GET",
|
|
url: `${proxifiedURL}/info/refs?service=${service}`,
|
|
headers
|
|
});
|
|
tryAgain = false;
|
|
if (res.statusCode === 401 || res.statusCode === 203) {
|
|
const getAuth = providedAuthBefore ? onAuthFailure : onAuth;
|
|
if (getAuth) {
|
|
auth = await getAuth(url, {
|
|
...auth,
|
|
headers: { ...headers }
|
|
});
|
|
if (auth && auth.cancel) {
|
|
throw new UserCanceledError();
|
|
} else if (auth) {
|
|
updateHeaders(headers, auth);
|
|
providedAuthBefore = true;
|
|
tryAgain = true;
|
|
}
|
|
}
|
|
} else if (res.statusCode === 200 && providedAuthBefore && onAuthSuccess) {
|
|
await onAuthSuccess(url, auth);
|
|
}
|
|
} while (tryAgain);
|
|
if (res.statusCode !== 200) {
|
|
const { response } = await stringifyBody(res);
|
|
throw new HttpError(res.statusCode, res.statusMessage, response);
|
|
}
|
|
if (res.headers["content-type"] === `application/x-${service}-advertisement`) {
|
|
const remoteHTTP = await parseRefsAdResponse(res.body, { service });
|
|
remoteHTTP.auth = auth;
|
|
return remoteHTTP;
|
|
} else {
|
|
const { preview, response, data } = await stringifyBody(res);
|
|
try {
|
|
const remoteHTTP = await parseRefsAdResponse([data], { service });
|
|
remoteHTTP.auth = auth;
|
|
return remoteHTTP;
|
|
} catch (e) {
|
|
throw new SmartHttpError(preview, response);
|
|
}
|
|
}
|
|
}
|
|
static async connect({
|
|
http,
|
|
onProgress,
|
|
corsProxy,
|
|
service,
|
|
url,
|
|
auth,
|
|
body,
|
|
headers
|
|
}) {
|
|
const urlAuth = extractAuthFromUrl(url);
|
|
if (urlAuth)
|
|
url = urlAuth.url;
|
|
if (corsProxy)
|
|
url = corsProxify(corsProxy, url);
|
|
headers["content-type"] = `application/x-${service}-request`;
|
|
headers.accept = `application/x-${service}-result`;
|
|
updateHeaders(headers, auth);
|
|
const res = await http.request({
|
|
onProgress,
|
|
method: "POST",
|
|
url: `${url}/${service}`,
|
|
body,
|
|
headers
|
|
});
|
|
if (res.statusCode !== 200) {
|
|
const { response } = stringifyBody(res);
|
|
throw new HttpError(res.statusCode, res.statusMessage, response);
|
|
}
|
|
return res;
|
|
}
|
|
};
|
|
function parseRemoteUrl({ url }) {
|
|
if (url.startsWith("git@")) {
|
|
return {
|
|
transport: "ssh",
|
|
address: url
|
|
};
|
|
}
|
|
const matches = url.match(/(\w+)(:\/\/|::)(.*)/);
|
|
if (matches === null)
|
|
return;
|
|
if (matches[2] === "://") {
|
|
return {
|
|
transport: matches[1],
|
|
address: matches[0]
|
|
};
|
|
}
|
|
if (matches[2] === "::") {
|
|
return {
|
|
transport: matches[1],
|
|
address: matches[3]
|
|
};
|
|
}
|
|
}
|
|
var GitRemoteManager = class {
|
|
static getRemoteHelperFor({ url }) {
|
|
const remoteHelpers = new Map();
|
|
remoteHelpers.set("http", GitRemoteHTTP);
|
|
remoteHelpers.set("https", GitRemoteHTTP);
|
|
const parts = parseRemoteUrl({ url });
|
|
if (!parts) {
|
|
throw new UrlParseError(url);
|
|
}
|
|
if (remoteHelpers.has(parts.transport)) {
|
|
return remoteHelpers.get(parts.transport);
|
|
}
|
|
throw new UnknownTransportError(url, parts.transport, parts.transport === "ssh" ? translateSSHtoHTTP(url) : void 0);
|
|
}
|
|
};
|
|
var lock$1 = null;
|
|
var GitShallowManager = class {
|
|
static async read({ fs, gitdir }) {
|
|
if (lock$1 === null)
|
|
lock$1 = new import_async_lock.default();
|
|
const filepath = join(gitdir, "shallow");
|
|
const oids = new Set();
|
|
await lock$1.acquire(filepath, async function() {
|
|
const text2 = await fs.read(filepath, { encoding: "utf8" });
|
|
if (text2 === null)
|
|
return oids;
|
|
if (text2.trim() === "")
|
|
return oids;
|
|
text2.trim().split("\n").map((oid) => oids.add(oid));
|
|
});
|
|
return oids;
|
|
}
|
|
static async write({ fs, gitdir, oids }) {
|
|
if (lock$1 === null)
|
|
lock$1 = new import_async_lock.default();
|
|
const filepath = join(gitdir, "shallow");
|
|
if (oids.size > 0) {
|
|
const text2 = [...oids].join("\n") + "\n";
|
|
await lock$1.acquire(filepath, async function() {
|
|
await fs.write(filepath, text2, {
|
|
encoding: "utf8"
|
|
});
|
|
});
|
|
} else {
|
|
await lock$1.acquire(filepath, async function() {
|
|
await fs.rm(filepath);
|
|
});
|
|
}
|
|
}
|
|
};
|
|
async function hasObjectLoose({ fs, gitdir, oid }) {
|
|
const source = `objects/${oid.slice(0, 2)}/${oid.slice(2)}`;
|
|
return fs.exists(`${gitdir}/${source}`);
|
|
}
|
|
async function hasObjectPacked({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
getExternalRefDelta
|
|
}) {
|
|
let list = await fs.readdir(join(gitdir, "objects/pack"));
|
|
list = list.filter((x) => x.endsWith(".idx"));
|
|
for (const filename of list) {
|
|
const indexFile = `${gitdir}/objects/pack/${filename}`;
|
|
const p = await readPackIndex({
|
|
fs,
|
|
cache,
|
|
filename: indexFile,
|
|
getExternalRefDelta
|
|
});
|
|
if (p.error)
|
|
throw new InternalError(p.error);
|
|
if (p.offsets.has(oid)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
async function hasObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
format = "content"
|
|
}) {
|
|
const getExternalRefDelta = (oid2) => _readObject({ fs, cache, gitdir, oid: oid2 });
|
|
let result = await hasObjectLoose({ fs, gitdir, oid });
|
|
if (!result) {
|
|
result = await hasObjectPacked({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
getExternalRefDelta
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
function emptyPackfile(pack) {
|
|
const pheader = "5041434b";
|
|
const version2 = "00000002";
|
|
const obCount = "00000000";
|
|
const header = pheader + version2 + obCount;
|
|
return pack.slice(0, 12).toString("hex") === header;
|
|
}
|
|
function filterCapabilities(server, client) {
|
|
const serverNames = server.map((cap) => cap.split("=", 1)[0]);
|
|
return client.filter((cap) => {
|
|
const name = cap.split("=", 1)[0];
|
|
return serverNames.includes(name);
|
|
});
|
|
}
|
|
var pkg = {
|
|
name: "isomorphic-git",
|
|
version: "1.21.0",
|
|
agent: "git/isomorphic-git@1.21.0"
|
|
};
|
|
var FIFO = class {
|
|
constructor() {
|
|
this._queue = [];
|
|
}
|
|
write(chunk) {
|
|
if (this._ended) {
|
|
throw Error("You cannot write to a FIFO that has already been ended!");
|
|
}
|
|
if (this._waiting) {
|
|
const resolve = this._waiting;
|
|
this._waiting = null;
|
|
resolve({ value: chunk });
|
|
} else {
|
|
this._queue.push(chunk);
|
|
}
|
|
}
|
|
end() {
|
|
this._ended = true;
|
|
if (this._waiting) {
|
|
const resolve = this._waiting;
|
|
this._waiting = null;
|
|
resolve({ done: true });
|
|
}
|
|
}
|
|
destroy(err) {
|
|
this._ended = true;
|
|
this.error = err;
|
|
}
|
|
async next() {
|
|
if (this._queue.length > 0) {
|
|
return { value: this._queue.shift() };
|
|
}
|
|
if (this._ended) {
|
|
return { done: true };
|
|
}
|
|
if (this._waiting) {
|
|
throw Error("You cannot call read until the previous call to read has returned!");
|
|
}
|
|
return new Promise((resolve) => {
|
|
this._waiting = resolve;
|
|
});
|
|
}
|
|
};
|
|
function findSplit(str) {
|
|
const r = str.indexOf("\r");
|
|
const n = str.indexOf("\n");
|
|
if (r === -1 && n === -1)
|
|
return -1;
|
|
if (r === -1)
|
|
return n + 1;
|
|
if (n === -1)
|
|
return r + 1;
|
|
if (n === r + 1)
|
|
return n + 1;
|
|
return Math.min(r, n) + 1;
|
|
}
|
|
function splitLines(input) {
|
|
const output = new FIFO();
|
|
let tmp = "";
|
|
(async () => {
|
|
await forAwait(input, (chunk) => {
|
|
chunk = chunk.toString("utf8");
|
|
tmp += chunk;
|
|
while (true) {
|
|
const i = findSplit(tmp);
|
|
if (i === -1)
|
|
break;
|
|
output.write(tmp.slice(0, i));
|
|
tmp = tmp.slice(i);
|
|
}
|
|
});
|
|
if (tmp.length > 0) {
|
|
output.write(tmp);
|
|
}
|
|
output.end();
|
|
})();
|
|
return output;
|
|
}
|
|
var GitSideBand = class {
|
|
static demux(input) {
|
|
const read = GitPktLine.streamReader(input);
|
|
const packetlines = new FIFO();
|
|
const packfile = new FIFO();
|
|
const progress = new FIFO();
|
|
const nextBit = async function() {
|
|
const line = await read();
|
|
if (line === null)
|
|
return nextBit();
|
|
if (line === true) {
|
|
packetlines.end();
|
|
progress.end();
|
|
packfile.end();
|
|
return;
|
|
}
|
|
switch (line[0]) {
|
|
case 1: {
|
|
packfile.write(line.slice(1));
|
|
break;
|
|
}
|
|
case 2: {
|
|
progress.write(line.slice(1));
|
|
break;
|
|
}
|
|
case 3: {
|
|
const error = line.slice(1);
|
|
progress.write(error);
|
|
packfile.destroy(new Error(error.toString("utf8")));
|
|
return;
|
|
}
|
|
default: {
|
|
packetlines.write(line.slice(0));
|
|
}
|
|
}
|
|
nextBit();
|
|
};
|
|
nextBit();
|
|
return {
|
|
packetlines,
|
|
packfile,
|
|
progress
|
|
};
|
|
}
|
|
};
|
|
async function parseUploadPackResponse(stream) {
|
|
const { packetlines, packfile, progress } = GitSideBand.demux(stream);
|
|
const shallows = [];
|
|
const unshallows = [];
|
|
const acks = [];
|
|
let nak = false;
|
|
let done = false;
|
|
return new Promise((resolve, reject) => {
|
|
forAwait(packetlines, (data) => {
|
|
const line = data.toString("utf8").trim();
|
|
if (line.startsWith("shallow")) {
|
|
const oid = line.slice(-41).trim();
|
|
if (oid.length !== 40) {
|
|
reject(new InvalidOidError(oid));
|
|
}
|
|
shallows.push(oid);
|
|
} else if (line.startsWith("unshallow")) {
|
|
const oid = line.slice(-41).trim();
|
|
if (oid.length !== 40) {
|
|
reject(new InvalidOidError(oid));
|
|
}
|
|
unshallows.push(oid);
|
|
} else if (line.startsWith("ACK")) {
|
|
const [, oid, status2] = line.split(" ");
|
|
acks.push({ oid, status: status2 });
|
|
if (!status2)
|
|
done = true;
|
|
} else if (line.startsWith("NAK")) {
|
|
nak = true;
|
|
done = true;
|
|
}
|
|
if (done) {
|
|
resolve({ shallows, unshallows, acks, nak, packfile, progress });
|
|
}
|
|
});
|
|
});
|
|
}
|
|
function writeUploadPackRequest({
|
|
capabilities = [],
|
|
wants = [],
|
|
haves = [],
|
|
shallows = [],
|
|
depth = null,
|
|
since = null,
|
|
exclude = []
|
|
}) {
|
|
const packstream = [];
|
|
wants = [...new Set(wants)];
|
|
let firstLineCapabilities = ` ${capabilities.join(" ")}`;
|
|
for (const oid of wants) {
|
|
packstream.push(GitPktLine.encode(`want ${oid}${firstLineCapabilities}
|
|
`));
|
|
firstLineCapabilities = "";
|
|
}
|
|
for (const oid of shallows) {
|
|
packstream.push(GitPktLine.encode(`shallow ${oid}
|
|
`));
|
|
}
|
|
if (depth !== null) {
|
|
packstream.push(GitPktLine.encode(`deepen ${depth}
|
|
`));
|
|
}
|
|
if (since !== null) {
|
|
packstream.push(GitPktLine.encode(`deepen-since ${Math.floor(since.valueOf() / 1e3)}
|
|
`));
|
|
}
|
|
for (const oid of exclude) {
|
|
packstream.push(GitPktLine.encode(`deepen-not ${oid}
|
|
`));
|
|
}
|
|
packstream.push(GitPktLine.flush());
|
|
for (const oid of haves) {
|
|
packstream.push(GitPktLine.encode(`have ${oid}
|
|
`));
|
|
}
|
|
packstream.push(GitPktLine.encode(`done
|
|
`));
|
|
return packstream;
|
|
}
|
|
async function _fetch({
|
|
fs,
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
gitdir,
|
|
ref: _ref,
|
|
remoteRef: _remoteRef,
|
|
remote: _remote,
|
|
url: _url,
|
|
corsProxy,
|
|
depth = null,
|
|
since = null,
|
|
exclude = [],
|
|
relative = false,
|
|
tags = false,
|
|
singleBranch = false,
|
|
headers = {},
|
|
prune = false,
|
|
pruneTags = false
|
|
}) {
|
|
const ref = _ref || await _currentBranch({ fs, gitdir, test: true });
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
const remote = _remote || ref && await config.get(`branch.${ref}.remote`) || "origin";
|
|
const url = _url || await config.get(`remote.${remote}.url`);
|
|
if (typeof url === "undefined") {
|
|
throw new MissingParameterError("remote OR url");
|
|
}
|
|
const remoteRef = _remoteRef || ref && await config.get(`branch.${ref}.merge`) || _ref || "HEAD";
|
|
if (corsProxy === void 0) {
|
|
corsProxy = await config.get("http.corsProxy");
|
|
}
|
|
const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url });
|
|
const remoteHTTP = await GitRemoteHTTP2.discover({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
service: "git-upload-pack",
|
|
url,
|
|
headers,
|
|
protocolVersion: 1
|
|
});
|
|
const auth = remoteHTTP.auth;
|
|
const remoteRefs = remoteHTTP.refs;
|
|
if (remoteRefs.size === 0) {
|
|
return {
|
|
defaultBranch: null,
|
|
fetchHead: null,
|
|
fetchHeadDescription: null
|
|
};
|
|
}
|
|
if (depth !== null && !remoteHTTP.capabilities.has("shallow")) {
|
|
throw new RemoteCapabilityError("shallow", "depth");
|
|
}
|
|
if (since !== null && !remoteHTTP.capabilities.has("deepen-since")) {
|
|
throw new RemoteCapabilityError("deepen-since", "since");
|
|
}
|
|
if (exclude.length > 0 && !remoteHTTP.capabilities.has("deepen-not")) {
|
|
throw new RemoteCapabilityError("deepen-not", "exclude");
|
|
}
|
|
if (relative === true && !remoteHTTP.capabilities.has("deepen-relative")) {
|
|
throw new RemoteCapabilityError("deepen-relative", "relative");
|
|
}
|
|
const { oid, fullref } = GitRefManager.resolveAgainstMap({
|
|
ref: remoteRef,
|
|
map: remoteRefs
|
|
});
|
|
for (const remoteRef2 of remoteRefs.keys()) {
|
|
if (remoteRef2 === fullref || remoteRef2 === "HEAD" || remoteRef2.startsWith("refs/heads/") || tags && remoteRef2.startsWith("refs/tags/")) {
|
|
continue;
|
|
}
|
|
remoteRefs.delete(remoteRef2);
|
|
}
|
|
const capabilities = filterCapabilities([...remoteHTTP.capabilities], [
|
|
"multi_ack_detailed",
|
|
"no-done",
|
|
"side-band-64k",
|
|
"ofs-delta",
|
|
`agent=${pkg.agent}`
|
|
]);
|
|
if (relative)
|
|
capabilities.push("deepen-relative");
|
|
const wants = singleBranch ? [oid] : remoteRefs.values();
|
|
const haveRefs = singleBranch ? [ref] : await GitRefManager.listRefs({
|
|
fs,
|
|
gitdir,
|
|
filepath: `refs`
|
|
});
|
|
let haves = [];
|
|
for (let ref2 of haveRefs) {
|
|
try {
|
|
ref2 = await GitRefManager.expand({ fs, gitdir, ref: ref2 });
|
|
const oid2 = await GitRefManager.resolve({ fs, gitdir, ref: ref2 });
|
|
if (await hasObject({ fs, cache, gitdir, oid: oid2 })) {
|
|
haves.push(oid2);
|
|
}
|
|
} catch (err) {
|
|
}
|
|
}
|
|
haves = [...new Set(haves)];
|
|
const oids = await GitShallowManager.read({ fs, gitdir });
|
|
const shallows = remoteHTTP.capabilities.has("shallow") ? [...oids] : [];
|
|
const packstream = writeUploadPackRequest({
|
|
capabilities,
|
|
wants,
|
|
haves,
|
|
shallows,
|
|
depth,
|
|
since,
|
|
exclude
|
|
});
|
|
const packbuffer = Buffer2.from(await collect(packstream));
|
|
const raw = await GitRemoteHTTP2.connect({
|
|
http,
|
|
onProgress,
|
|
corsProxy,
|
|
service: "git-upload-pack",
|
|
url,
|
|
auth,
|
|
body: [packbuffer],
|
|
headers
|
|
});
|
|
const response = await parseUploadPackResponse(raw.body);
|
|
if (raw.headers) {
|
|
response.headers = raw.headers;
|
|
}
|
|
for (const oid2 of response.shallows) {
|
|
if (!oids.has(oid2)) {
|
|
try {
|
|
const { object } = await _readObject({ fs, cache, gitdir, oid: oid2 });
|
|
const commit2 = new GitCommit(object);
|
|
const hasParents = await Promise.all(commit2.headers().parent.map((oid3) => hasObject({ fs, cache, gitdir, oid: oid3 })));
|
|
const haveAllParents = hasParents.length === 0 || hasParents.every((has) => has);
|
|
if (!haveAllParents) {
|
|
oids.add(oid2);
|
|
}
|
|
} catch (err) {
|
|
oids.add(oid2);
|
|
}
|
|
}
|
|
}
|
|
for (const oid2 of response.unshallows) {
|
|
oids.delete(oid2);
|
|
}
|
|
await GitShallowManager.write({ fs, gitdir, oids });
|
|
if (singleBranch) {
|
|
const refs = new Map([[fullref, oid]]);
|
|
const symrefs = new Map();
|
|
let bail = 10;
|
|
let key2 = fullref;
|
|
while (bail--) {
|
|
const value = remoteHTTP.symrefs.get(key2);
|
|
if (value === void 0)
|
|
break;
|
|
symrefs.set(key2, value);
|
|
key2 = value;
|
|
}
|
|
const realRef = remoteRefs.get(key2);
|
|
if (realRef) {
|
|
refs.set(key2, realRef);
|
|
}
|
|
const { pruned } = await GitRefManager.updateRemoteRefs({
|
|
fs,
|
|
gitdir,
|
|
remote,
|
|
refs,
|
|
symrefs,
|
|
tags,
|
|
prune
|
|
});
|
|
if (prune) {
|
|
response.pruned = pruned;
|
|
}
|
|
} else {
|
|
const { pruned } = await GitRefManager.updateRemoteRefs({
|
|
fs,
|
|
gitdir,
|
|
remote,
|
|
refs: remoteRefs,
|
|
symrefs: remoteHTTP.symrefs,
|
|
tags,
|
|
prune,
|
|
pruneTags
|
|
});
|
|
if (prune) {
|
|
response.pruned = pruned;
|
|
}
|
|
}
|
|
response.HEAD = remoteHTTP.symrefs.get("HEAD");
|
|
if (response.HEAD === void 0) {
|
|
const { oid: oid2 } = GitRefManager.resolveAgainstMap({
|
|
ref: "HEAD",
|
|
map: remoteRefs
|
|
});
|
|
for (const [key2, value] of remoteRefs.entries()) {
|
|
if (key2 !== "HEAD" && value === oid2) {
|
|
response.HEAD = key2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const noun = fullref.startsWith("refs/tags") ? "tag" : "branch";
|
|
response.FETCH_HEAD = {
|
|
oid,
|
|
description: `${noun} '${abbreviateRef(fullref)}' of ${url}`
|
|
};
|
|
if (onProgress || onMessage) {
|
|
const lines = splitLines(response.progress);
|
|
forAwait(lines, async (line) => {
|
|
if (onMessage)
|
|
await onMessage(line);
|
|
if (onProgress) {
|
|
const matches = line.match(/([^:]*).*\((\d+?)\/(\d+?)\)/);
|
|
if (matches) {
|
|
await onProgress({
|
|
phase: matches[1].trim(),
|
|
loaded: parseInt(matches[2], 10),
|
|
total: parseInt(matches[3], 10)
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
const packfile = Buffer2.from(await collect(response.packfile));
|
|
const packfileSha = packfile.slice(-20).toString("hex");
|
|
const res = {
|
|
defaultBranch: response.HEAD,
|
|
fetchHead: response.FETCH_HEAD.oid,
|
|
fetchHeadDescription: response.FETCH_HEAD.description
|
|
};
|
|
if (response.headers) {
|
|
res.headers = response.headers;
|
|
}
|
|
if (prune) {
|
|
res.pruned = response.pruned;
|
|
}
|
|
if (packfileSha !== "" && !emptyPackfile(packfile)) {
|
|
res.packfile = `objects/pack/pack-${packfileSha}.pack`;
|
|
const fullpath = join(gitdir, res.packfile);
|
|
await fs.write(fullpath, packfile);
|
|
const getExternalRefDelta = (oid2) => _readObject({ fs, cache, gitdir, oid: oid2 });
|
|
const idx = await GitPackIndex.fromPack({
|
|
pack: packfile,
|
|
getExternalRefDelta,
|
|
onProgress
|
|
});
|
|
await fs.write(fullpath.replace(/\.pack$/, ".idx"), await idx.toBuffer());
|
|
}
|
|
return res;
|
|
}
|
|
async function _init({
|
|
fs,
|
|
bare = false,
|
|
dir,
|
|
gitdir = bare ? dir : join(dir, ".git"),
|
|
defaultBranch = "master"
|
|
}) {
|
|
if (await fs.exists(gitdir + "/config"))
|
|
return;
|
|
let folders = [
|
|
"hooks",
|
|
"info",
|
|
"objects/info",
|
|
"objects/pack",
|
|
"refs/heads",
|
|
"refs/tags"
|
|
];
|
|
folders = folders.map((dir2) => gitdir + "/" + dir2);
|
|
for (const folder of folders) {
|
|
await fs.mkdir(folder);
|
|
}
|
|
await fs.write(gitdir + "/config", `[core]
|
|
repositoryformatversion = 0
|
|
filemode = false
|
|
bare = ${bare}
|
|
` + (bare ? "" : " logallrefupdates = true\n") + " symlinks = false\n ignorecase = true\n");
|
|
await fs.write(gitdir + "/HEAD", `ref: refs/heads/${defaultBranch}
|
|
`);
|
|
}
|
|
async function _clone({
|
|
fs,
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir,
|
|
url,
|
|
corsProxy,
|
|
ref,
|
|
remote,
|
|
depth,
|
|
since,
|
|
exclude,
|
|
relative,
|
|
singleBranch,
|
|
noCheckout,
|
|
noTags,
|
|
headers
|
|
}) {
|
|
try {
|
|
await _init({ fs, gitdir });
|
|
await _addRemote({ fs, gitdir, remote, url, force: false });
|
|
if (corsProxy) {
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
await config.set(`http.corsProxy`, corsProxy);
|
|
await GitConfigManager.save({ fs, gitdir, config });
|
|
}
|
|
const { defaultBranch, fetchHead } = await _fetch({
|
|
fs,
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
gitdir,
|
|
ref,
|
|
remote,
|
|
corsProxy,
|
|
depth,
|
|
since,
|
|
exclude,
|
|
relative,
|
|
singleBranch,
|
|
headers,
|
|
tags: !noTags
|
|
});
|
|
if (fetchHead === null)
|
|
return;
|
|
ref = ref || defaultBranch;
|
|
ref = ref.replace("refs/heads/", "");
|
|
await _checkout({
|
|
fs,
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
ref,
|
|
remote,
|
|
noCheckout
|
|
});
|
|
} catch (err) {
|
|
await fs.rmdir(gitdir, { recursive: true, maxRetries: 10 }).catch(() => void 0);
|
|
throw err;
|
|
}
|
|
}
|
|
async function clone({
|
|
fs,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
url,
|
|
corsProxy = void 0,
|
|
ref = void 0,
|
|
remote = "origin",
|
|
depth = void 0,
|
|
since = void 0,
|
|
exclude = [],
|
|
relative = false,
|
|
singleBranch = false,
|
|
noCheckout = false,
|
|
noTags = false,
|
|
headers = {},
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("http", http);
|
|
assertParameter("gitdir", gitdir);
|
|
if (!noCheckout) {
|
|
assertParameter("dir", dir);
|
|
}
|
|
assertParameter("url", url);
|
|
return await _clone({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir,
|
|
url,
|
|
corsProxy,
|
|
ref,
|
|
remote,
|
|
depth,
|
|
since,
|
|
exclude,
|
|
relative,
|
|
singleBranch,
|
|
noCheckout,
|
|
noTags,
|
|
headers
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.clone";
|
|
throw err;
|
|
}
|
|
}
|
|
async function commit({
|
|
fs: _fs,
|
|
onSign,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
message,
|
|
author: _author,
|
|
committer: _committer,
|
|
signingKey,
|
|
dryRun = false,
|
|
noUpdateBranch = false,
|
|
ref,
|
|
parent,
|
|
tree,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("message", message);
|
|
if (signingKey) {
|
|
assertParameter("onSign", onSign);
|
|
}
|
|
const fs = new FileSystem(_fs);
|
|
const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
|
|
if (!author)
|
|
throw new MissingNameError("author");
|
|
const committer = await normalizeCommitterObject({
|
|
fs,
|
|
gitdir,
|
|
author,
|
|
committer: _committer
|
|
});
|
|
if (!committer)
|
|
throw new MissingNameError("committer");
|
|
return await _commit({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
message,
|
|
author,
|
|
committer,
|
|
signingKey,
|
|
dryRun,
|
|
noUpdateBranch,
|
|
ref,
|
|
parent,
|
|
tree
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.commit";
|
|
throw err;
|
|
}
|
|
}
|
|
async function currentBranch({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
fullname = false,
|
|
test = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
return await _currentBranch({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
fullname,
|
|
test
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.currentBranch";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _deleteBranch({ fs, gitdir, ref }) {
|
|
const exist = await GitRefManager.exists({ fs, gitdir, ref });
|
|
if (!exist) {
|
|
throw new NotFoundError(ref);
|
|
}
|
|
const fullRef = await GitRefManager.expand({ fs, gitdir, ref });
|
|
const currentRef = await _currentBranch({ fs, gitdir, fullname: true });
|
|
if (fullRef === currentRef) {
|
|
const value = await GitRefManager.resolve({ fs, gitdir, ref: fullRef });
|
|
await GitRefManager.writeRef({ fs, gitdir, ref: "HEAD", value });
|
|
}
|
|
await GitRefManager.deleteRef({ fs, gitdir, ref: fullRef });
|
|
}
|
|
async function deleteBranch({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("ref", ref);
|
|
return await _deleteBranch({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
ref
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.deleteBranch";
|
|
throw err;
|
|
}
|
|
}
|
|
async function deleteRef({ fs, dir, gitdir = join(dir, ".git"), ref }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("ref", ref);
|
|
await GitRefManager.deleteRef({ fs: new FileSystem(fs), gitdir, ref });
|
|
} catch (err) {
|
|
err.caller = "git.deleteRef";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _deleteRemote({ fs, gitdir, remote }) {
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
await config.deleteSection("remote", remote);
|
|
await GitConfigManager.save({ fs, gitdir, config });
|
|
}
|
|
async function deleteRemote({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
remote
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("remote", remote);
|
|
return await _deleteRemote({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
remote
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.deleteRemote";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _deleteTag({ fs, gitdir, ref }) {
|
|
ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`;
|
|
await GitRefManager.deleteRef({ fs, gitdir, ref });
|
|
}
|
|
async function deleteTag({ fs, dir, gitdir = join(dir, ".git"), ref }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("ref", ref);
|
|
return await _deleteTag({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
ref
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.deleteTag";
|
|
throw err;
|
|
}
|
|
}
|
|
async function expandOidLoose({ fs, gitdir, oid: short }) {
|
|
const prefix = short.slice(0, 2);
|
|
const objectsSuffixes = await fs.readdir(`${gitdir}/objects/${prefix}`);
|
|
return objectsSuffixes.map((suffix) => `${prefix}${suffix}`).filter((_oid) => _oid.startsWith(short));
|
|
}
|
|
async function expandOidPacked({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: short,
|
|
getExternalRefDelta
|
|
}) {
|
|
const results = [];
|
|
let list = await fs.readdir(join(gitdir, "objects/pack"));
|
|
list = list.filter((x) => x.endsWith(".idx"));
|
|
for (const filename of list) {
|
|
const indexFile = `${gitdir}/objects/pack/${filename}`;
|
|
const p = await readPackIndex({
|
|
fs,
|
|
cache,
|
|
filename: indexFile,
|
|
getExternalRefDelta
|
|
});
|
|
if (p.error)
|
|
throw new InternalError(p.error);
|
|
for (const oid of p.offsets.keys()) {
|
|
if (oid.startsWith(short))
|
|
results.push(oid);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
async function _expandOid({ fs, cache, gitdir, oid: short }) {
|
|
const getExternalRefDelta = (oid) => _readObject({ fs, cache, gitdir, oid });
|
|
const results1 = await expandOidLoose({ fs, gitdir, oid: short });
|
|
const results2 = await expandOidPacked({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: short,
|
|
getExternalRefDelta
|
|
});
|
|
const results = results1.concat(results2);
|
|
if (results.length === 1) {
|
|
return results[0];
|
|
}
|
|
if (results.length > 1) {
|
|
throw new AmbiguousError("oids", short, results);
|
|
}
|
|
throw new NotFoundError(`an object matching "${short}"`);
|
|
}
|
|
async function expandOid({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oid,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
return await _expandOid({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oid
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.expandOid";
|
|
throw err;
|
|
}
|
|
}
|
|
async function expandRef({ fs, dir, gitdir = join(dir, ".git"), ref }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
return await GitRefManager.expand({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
ref
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.expandRef";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _findMergeBase({ fs, cache, gitdir, oids }) {
|
|
const visits = {};
|
|
const passes = oids.length;
|
|
let heads = oids.map((oid, index2) => ({ index: index2, oid }));
|
|
while (heads.length) {
|
|
const result = new Set();
|
|
for (const { oid, index: index2 } of heads) {
|
|
if (!visits[oid])
|
|
visits[oid] = new Set();
|
|
visits[oid].add(index2);
|
|
if (visits[oid].size === passes) {
|
|
result.add(oid);
|
|
}
|
|
}
|
|
if (result.size > 0) {
|
|
return [...result];
|
|
}
|
|
const newheads = new Map();
|
|
for (const { oid, index: index2 } of heads) {
|
|
try {
|
|
const { object } = await _readObject({ fs, cache, gitdir, oid });
|
|
const commit2 = GitCommit.from(object);
|
|
const { parent } = commit2.parseHeaders();
|
|
for (const oid2 of parent) {
|
|
if (!visits[oid2] || !visits[oid2].has(index2)) {
|
|
newheads.set(oid2 + ":" + index2, { oid: oid2, index: index2 });
|
|
}
|
|
}
|
|
} catch (err) {
|
|
}
|
|
}
|
|
heads = Array.from(newheads.values());
|
|
}
|
|
return [];
|
|
}
|
|
var LINEBREAKS = /^.*(\r?\n|$)/gm;
|
|
function mergeFile({ branches, contents }) {
|
|
const ourName = branches[1];
|
|
const theirName = branches[2];
|
|
const baseContent = contents[0];
|
|
const ourContent = contents[1];
|
|
const theirContent = contents[2];
|
|
const ours = ourContent.match(LINEBREAKS);
|
|
const base = baseContent.match(LINEBREAKS);
|
|
const theirs = theirContent.match(LINEBREAKS);
|
|
const result = (0, import_diff3.default)(ours, base, theirs);
|
|
const markerSize = 7;
|
|
let mergedText = "";
|
|
let cleanMerge = true;
|
|
for (const item of result) {
|
|
if (item.ok) {
|
|
mergedText += item.ok.join("");
|
|
}
|
|
if (item.conflict) {
|
|
cleanMerge = false;
|
|
mergedText += `${"<".repeat(markerSize)} ${ourName}
|
|
`;
|
|
mergedText += item.conflict.a.join("");
|
|
mergedText += `${"=".repeat(markerSize)}
|
|
`;
|
|
mergedText += item.conflict.b.join("");
|
|
mergedText += `${">".repeat(markerSize)} ${theirName}
|
|
`;
|
|
}
|
|
}
|
|
return { cleanMerge, mergedText };
|
|
}
|
|
async function mergeTree({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ourOid,
|
|
baseOid,
|
|
theirOid,
|
|
ourName = "ours",
|
|
baseName = "base",
|
|
theirName = "theirs",
|
|
dryRun = false,
|
|
abortOnConflict = true,
|
|
mergeDriver
|
|
}) {
|
|
const ourTree = TREE({ ref: ourOid });
|
|
const baseTree = TREE({ ref: baseOid });
|
|
const theirTree = TREE({ ref: theirOid });
|
|
const unmergedFiles = [];
|
|
let cleanMerge = true;
|
|
const results = await _walk({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
trees: [ourTree, baseTree, theirTree],
|
|
map: async function(filepath, [ours, base, theirs]) {
|
|
const path2 = basename(filepath);
|
|
const ourChange = await modified(ours, base);
|
|
const theirChange = await modified(theirs, base);
|
|
switch (`${ourChange}-${theirChange}`) {
|
|
case "false-false": {
|
|
return {
|
|
mode: await base.mode(),
|
|
path: path2,
|
|
oid: await base.oid(),
|
|
type: await base.type()
|
|
};
|
|
}
|
|
case "false-true": {
|
|
return theirs ? {
|
|
mode: await theirs.mode(),
|
|
path: path2,
|
|
oid: await theirs.oid(),
|
|
type: await theirs.type()
|
|
} : void 0;
|
|
}
|
|
case "true-false": {
|
|
return ours ? {
|
|
mode: await ours.mode(),
|
|
path: path2,
|
|
oid: await ours.oid(),
|
|
type: await ours.type()
|
|
} : void 0;
|
|
}
|
|
case "true-true": {
|
|
if (ours && base && theirs && await ours.type() === "blob" && await base.type() === "blob" && await theirs.type() === "blob") {
|
|
return mergeBlobs({
|
|
fs,
|
|
gitdir,
|
|
path: path2,
|
|
ours,
|
|
base,
|
|
theirs,
|
|
ourName,
|
|
baseName,
|
|
theirName,
|
|
mergeDriver
|
|
}).then((r) => {
|
|
cleanMerge = cleanMerge && r.cleanMerge;
|
|
unmergedFiles.push(filepath);
|
|
return r.mergeResult;
|
|
});
|
|
}
|
|
throw new MergeNotSupportedError();
|
|
}
|
|
}
|
|
},
|
|
reduce: async (parent, children2) => {
|
|
const entries = children2.filter(Boolean);
|
|
if (!parent)
|
|
return;
|
|
if (parent && parent.type === "tree" && entries.length === 0)
|
|
return;
|
|
if (entries.length > 0) {
|
|
const tree = new GitTree(entries);
|
|
const object = tree.toObject();
|
|
const oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "tree",
|
|
object,
|
|
dryRun
|
|
});
|
|
parent.oid = oid;
|
|
}
|
|
return parent;
|
|
}
|
|
});
|
|
if (!cleanMerge) {
|
|
if (dir && !abortOnConflict) {
|
|
await _walk({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
trees: [TREE({ ref: results.oid })],
|
|
map: async function(filepath, [entry]) {
|
|
const path2 = `${dir}/${filepath}`;
|
|
if (await entry.type() === "blob") {
|
|
const mode = await entry.mode();
|
|
const content = new TextDecoder().decode(await entry.content());
|
|
await fs.write(path2, content, { mode });
|
|
}
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
throw new MergeConflictError(unmergedFiles);
|
|
}
|
|
return results.oid;
|
|
}
|
|
async function modified(entry, base) {
|
|
if (!entry && !base)
|
|
return false;
|
|
if (entry && !base)
|
|
return true;
|
|
if (!entry && base)
|
|
return true;
|
|
if (await entry.type() === "tree" && await base.type() === "tree") {
|
|
return false;
|
|
}
|
|
if (await entry.type() === await base.type() && await entry.mode() === await base.mode() && await entry.oid() === await base.oid()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
async function mergeBlobs({
|
|
fs,
|
|
gitdir,
|
|
path: path2,
|
|
ours,
|
|
base,
|
|
theirs,
|
|
ourName,
|
|
theirName,
|
|
baseName,
|
|
dryRun,
|
|
mergeDriver = mergeFile
|
|
}) {
|
|
const type = "blob";
|
|
const mode = await base.mode() === await ours.mode() ? await theirs.mode() : await ours.mode();
|
|
if (await ours.oid() === await theirs.oid()) {
|
|
return {
|
|
cleanMerge: true,
|
|
mergeResult: { mode, path: path2, oid: await ours.oid(), type }
|
|
};
|
|
}
|
|
if (await ours.oid() === await base.oid()) {
|
|
return {
|
|
cleanMerge: true,
|
|
mergeResult: { mode, path: path2, oid: await theirs.oid(), type }
|
|
};
|
|
}
|
|
if (await theirs.oid() === await base.oid()) {
|
|
return {
|
|
cleanMerge: true,
|
|
mergeResult: { mode, path: path2, oid: await ours.oid(), type }
|
|
};
|
|
}
|
|
const ourContent = Buffer2.from(await ours.content()).toString("utf8");
|
|
const baseContent = Buffer2.from(await base.content()).toString("utf8");
|
|
const theirContent = Buffer2.from(await theirs.content()).toString("utf8");
|
|
const { mergedText, cleanMerge } = await mergeDriver({
|
|
branches: [baseName, ourName, theirName],
|
|
contents: [baseContent, ourContent, theirContent],
|
|
path: path2
|
|
});
|
|
const oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "blob",
|
|
object: Buffer2.from(mergedText, "utf8"),
|
|
dryRun
|
|
});
|
|
return { cleanMerge, mergeResult: { mode, path: path2, oid, type } };
|
|
}
|
|
async function _merge({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
ours,
|
|
theirs,
|
|
fastForward: fastForward2 = true,
|
|
fastForwardOnly = false,
|
|
dryRun = false,
|
|
noUpdateBranch = false,
|
|
abortOnConflict = true,
|
|
message,
|
|
author,
|
|
committer,
|
|
signingKey,
|
|
onSign,
|
|
mergeDriver
|
|
}) {
|
|
if (ours === void 0) {
|
|
ours = await _currentBranch({ fs, gitdir, fullname: true });
|
|
}
|
|
ours = await GitRefManager.expand({
|
|
fs,
|
|
gitdir,
|
|
ref: ours
|
|
});
|
|
theirs = await GitRefManager.expand({
|
|
fs,
|
|
gitdir,
|
|
ref: theirs
|
|
});
|
|
const ourOid = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: ours
|
|
});
|
|
const theirOid = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: theirs
|
|
});
|
|
const baseOids = await _findMergeBase({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oids: [ourOid, theirOid]
|
|
});
|
|
if (baseOids.length !== 1) {
|
|
throw new MergeNotSupportedError();
|
|
}
|
|
const baseOid = baseOids[0];
|
|
if (baseOid === theirOid) {
|
|
return {
|
|
oid: ourOid,
|
|
alreadyMerged: true
|
|
};
|
|
}
|
|
if (fastForward2 && baseOid === ourOid) {
|
|
if (!dryRun && !noUpdateBranch) {
|
|
await GitRefManager.writeRef({ fs, gitdir, ref: ours, value: theirOid });
|
|
}
|
|
return {
|
|
oid: theirOid,
|
|
fastForward: true
|
|
};
|
|
} else {
|
|
if (fastForwardOnly) {
|
|
throw new FastForwardError();
|
|
}
|
|
const tree = await mergeTree({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
ourOid,
|
|
theirOid,
|
|
baseOid,
|
|
ourName: abbreviateRef(ours),
|
|
baseName: "base",
|
|
theirName: abbreviateRef(theirs),
|
|
dryRun,
|
|
abortOnConflict,
|
|
mergeDriver
|
|
});
|
|
if (!message) {
|
|
message = `Merge branch '${abbreviateRef(theirs)}' into ${abbreviateRef(ours)}`;
|
|
}
|
|
const oid = await _commit({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
message,
|
|
ref: ours,
|
|
tree,
|
|
parent: [ourOid, theirOid],
|
|
author,
|
|
committer,
|
|
signingKey,
|
|
onSign,
|
|
dryRun,
|
|
noUpdateBranch
|
|
});
|
|
return {
|
|
oid,
|
|
tree,
|
|
mergeCommit: true
|
|
};
|
|
}
|
|
}
|
|
async function _pull({
|
|
fs,
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir,
|
|
ref,
|
|
url,
|
|
remote,
|
|
remoteRef,
|
|
prune,
|
|
pruneTags,
|
|
fastForward: fastForward2,
|
|
fastForwardOnly,
|
|
corsProxy,
|
|
singleBranch,
|
|
headers,
|
|
author,
|
|
committer,
|
|
signingKey
|
|
}) {
|
|
try {
|
|
if (!ref) {
|
|
const head = await _currentBranch({ fs, gitdir });
|
|
if (!head) {
|
|
throw new MissingParameterError("ref");
|
|
}
|
|
ref = head;
|
|
}
|
|
const { fetchHead, fetchHeadDescription } = await _fetch({
|
|
fs,
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
gitdir,
|
|
corsProxy,
|
|
ref,
|
|
url,
|
|
remote,
|
|
remoteRef,
|
|
singleBranch,
|
|
headers,
|
|
prune,
|
|
pruneTags
|
|
});
|
|
await _merge({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
ours: ref,
|
|
theirs: fetchHead,
|
|
fastForward: fastForward2,
|
|
fastForwardOnly,
|
|
message: `Merge ${fetchHeadDescription}`,
|
|
author,
|
|
committer,
|
|
signingKey,
|
|
dryRun: false,
|
|
noUpdateBranch: false
|
|
});
|
|
await _checkout({
|
|
fs,
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
ref,
|
|
remote,
|
|
noCheckout: false
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.pull";
|
|
throw err;
|
|
}
|
|
}
|
|
async function fastForward({
|
|
fs,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
url,
|
|
remote,
|
|
remoteRef,
|
|
corsProxy,
|
|
singleBranch,
|
|
headers = {},
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("http", http);
|
|
assertParameter("gitdir", gitdir);
|
|
const thisWillNotBeUsed = {
|
|
name: "",
|
|
email: "",
|
|
timestamp: Date.now(),
|
|
timezoneOffset: 0
|
|
};
|
|
return await _pull({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir,
|
|
ref,
|
|
url,
|
|
remote,
|
|
remoteRef,
|
|
fastForwardOnly: true,
|
|
corsProxy,
|
|
singleBranch,
|
|
headers,
|
|
author: thisWillNotBeUsed,
|
|
committer: thisWillNotBeUsed
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.fastForward";
|
|
throw err;
|
|
}
|
|
}
|
|
async function fetch({
|
|
fs,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
remote,
|
|
remoteRef,
|
|
url,
|
|
corsProxy,
|
|
depth = null,
|
|
since = null,
|
|
exclude = [],
|
|
relative = false,
|
|
tags = false,
|
|
singleBranch = false,
|
|
headers = {},
|
|
prune = false,
|
|
pruneTags = false,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("http", http);
|
|
assertParameter("gitdir", gitdir);
|
|
return await _fetch({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
gitdir,
|
|
ref,
|
|
remote,
|
|
remoteRef,
|
|
url,
|
|
corsProxy,
|
|
depth,
|
|
since,
|
|
exclude,
|
|
relative,
|
|
tags,
|
|
singleBranch,
|
|
headers,
|
|
prune,
|
|
pruneTags
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.fetch";
|
|
throw err;
|
|
}
|
|
}
|
|
async function findMergeBase({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oids,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oids", oids);
|
|
return await _findMergeBase({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oids
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.findMergeBase";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _findRoot({ fs, filepath }) {
|
|
if (await fs.exists(join(filepath, ".git"))) {
|
|
return filepath;
|
|
} else {
|
|
const parent = dirname(filepath);
|
|
if (parent === filepath) {
|
|
throw new NotFoundError(`git root for ${filepath}`);
|
|
}
|
|
return _findRoot({ fs, filepath: parent });
|
|
}
|
|
}
|
|
async function findRoot({ fs, filepath }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("filepath", filepath);
|
|
return await _findRoot({ fs: new FileSystem(fs), filepath });
|
|
} catch (err) {
|
|
err.caller = "git.findRoot";
|
|
throw err;
|
|
}
|
|
}
|
|
async function getConfig({ fs, dir, gitdir = join(dir, ".git"), path: path2 }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("path", path2);
|
|
return await _getConfig({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
path: path2
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.getConfig";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _getConfigAll({ fs, gitdir, path: path2 }) {
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
return config.getall(path2);
|
|
}
|
|
async function getConfigAll({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
path: path2
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("path", path2);
|
|
return await _getConfigAll({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
path: path2
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.getConfigAll";
|
|
throw err;
|
|
}
|
|
}
|
|
async function getRemoteInfo({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
url,
|
|
headers = {},
|
|
forPush = false
|
|
}) {
|
|
try {
|
|
assertParameter("http", http);
|
|
assertParameter("url", url);
|
|
const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url });
|
|
const remote = await GitRemoteHTTP2.discover({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
service: forPush ? "git-receive-pack" : "git-upload-pack",
|
|
url,
|
|
headers,
|
|
protocolVersion: 1
|
|
});
|
|
const result = {
|
|
capabilities: [...remote.capabilities]
|
|
};
|
|
for (const [ref, oid] of remote.refs) {
|
|
const parts = ref.split("/");
|
|
const last2 = parts.pop();
|
|
let o = result;
|
|
for (const part of parts) {
|
|
o[part] = o[part] || {};
|
|
o = o[part];
|
|
}
|
|
o[last2] = oid;
|
|
}
|
|
for (const [symref, ref] of remote.symrefs) {
|
|
const parts = symref.split("/");
|
|
const last2 = parts.pop();
|
|
let o = result;
|
|
for (const part of parts) {
|
|
o[part] = o[part] || {};
|
|
o = o[part];
|
|
}
|
|
o[last2] = ref;
|
|
}
|
|
return result;
|
|
} catch (err) {
|
|
err.caller = "git.getRemoteInfo";
|
|
throw err;
|
|
}
|
|
}
|
|
function formatInfoRefs(remote, prefix, symrefs, peelTags) {
|
|
const refs = [];
|
|
for (const [key2, value] of remote.refs) {
|
|
if (prefix && !key2.startsWith(prefix))
|
|
continue;
|
|
if (key2.endsWith("^{}")) {
|
|
if (peelTags) {
|
|
const _key = key2.replace("^{}", "");
|
|
const last2 = refs[refs.length - 1];
|
|
const r = last2.ref === _key ? last2 : refs.find((x) => x.ref === _key);
|
|
if (r === void 0) {
|
|
throw new Error("I did not expect this to happen");
|
|
}
|
|
r.peeled = value;
|
|
}
|
|
continue;
|
|
}
|
|
const ref = { ref: key2, oid: value };
|
|
if (symrefs) {
|
|
if (remote.symrefs.has(key2)) {
|
|
ref.target = remote.symrefs.get(key2);
|
|
}
|
|
}
|
|
refs.push(ref);
|
|
}
|
|
return refs;
|
|
}
|
|
async function getRemoteInfo2({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
url,
|
|
headers = {},
|
|
forPush = false,
|
|
protocolVersion = 2
|
|
}) {
|
|
try {
|
|
assertParameter("http", http);
|
|
assertParameter("url", url);
|
|
const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url });
|
|
const remote = await GitRemoteHTTP2.discover({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
service: forPush ? "git-receive-pack" : "git-upload-pack",
|
|
url,
|
|
headers,
|
|
protocolVersion
|
|
});
|
|
if (remote.protocolVersion === 2) {
|
|
return {
|
|
protocolVersion: remote.protocolVersion,
|
|
capabilities: remote.capabilities2
|
|
};
|
|
}
|
|
const capabilities = {};
|
|
for (const cap of remote.capabilities) {
|
|
const [key2, value] = cap.split("=");
|
|
if (value) {
|
|
capabilities[key2] = value;
|
|
} else {
|
|
capabilities[key2] = true;
|
|
}
|
|
}
|
|
return {
|
|
protocolVersion: 1,
|
|
capabilities,
|
|
refs: formatInfoRefs(remote, void 0, true, true)
|
|
};
|
|
} catch (err) {
|
|
err.caller = "git.getRemoteInfo2";
|
|
throw err;
|
|
}
|
|
}
|
|
async function hashObject({
|
|
type,
|
|
object,
|
|
format = "content",
|
|
oid = void 0
|
|
}) {
|
|
if (format !== "deflated") {
|
|
if (format !== "wrapped") {
|
|
object = GitObject.wrap({ type, object });
|
|
}
|
|
oid = await shasum(object);
|
|
}
|
|
return { oid, object };
|
|
}
|
|
async function hashBlob({ object }) {
|
|
try {
|
|
assertParameter("object", object);
|
|
if (typeof object === "string") {
|
|
object = Buffer2.from(object, "utf8");
|
|
} else {
|
|
object = Buffer2.from(object);
|
|
}
|
|
const type = "blob";
|
|
const { oid, object: _object } = await hashObject({
|
|
type: "blob",
|
|
format: "content",
|
|
object
|
|
});
|
|
return { oid, type, object: new Uint8Array(_object), format: "wrapped" };
|
|
} catch (err) {
|
|
err.caller = "git.hashBlob";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _indexPack({
|
|
fs,
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
filepath
|
|
}) {
|
|
try {
|
|
filepath = join(dir, filepath);
|
|
const pack = await fs.read(filepath);
|
|
const getExternalRefDelta = (oid) => _readObject({ fs, cache, gitdir, oid });
|
|
const idx = await GitPackIndex.fromPack({
|
|
pack,
|
|
getExternalRefDelta,
|
|
onProgress
|
|
});
|
|
await fs.write(filepath.replace(/\.pack$/, ".idx"), await idx.toBuffer());
|
|
return {
|
|
oids: [...idx.hashes]
|
|
};
|
|
} catch (err) {
|
|
err.caller = "git.indexPack";
|
|
throw err;
|
|
}
|
|
}
|
|
async function indexPack({
|
|
fs,
|
|
onProgress,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
filepath,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("dir", dir);
|
|
assertParameter("gitdir", dir);
|
|
assertParameter("filepath", filepath);
|
|
return await _indexPack({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
onProgress,
|
|
dir,
|
|
gitdir,
|
|
filepath
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.indexPack";
|
|
throw err;
|
|
}
|
|
}
|
|
async function init({
|
|
fs,
|
|
bare = false,
|
|
dir,
|
|
gitdir = bare ? dir : join(dir, ".git"),
|
|
defaultBranch = "master"
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
if (!bare) {
|
|
assertParameter("dir", dir);
|
|
}
|
|
return await _init({
|
|
fs: new FileSystem(fs),
|
|
bare,
|
|
dir,
|
|
gitdir,
|
|
defaultBranch
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.init";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _isDescendent({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
ancestor,
|
|
depth
|
|
}) {
|
|
const shallows = await GitShallowManager.read({ fs, gitdir });
|
|
if (!oid) {
|
|
throw new MissingParameterError("oid");
|
|
}
|
|
if (!ancestor) {
|
|
throw new MissingParameterError("ancestor");
|
|
}
|
|
if (oid === ancestor)
|
|
return false;
|
|
const queue = [oid];
|
|
const visited = new Set();
|
|
let searchdepth = 0;
|
|
while (queue.length) {
|
|
if (searchdepth++ === depth) {
|
|
throw new MaxDepthError(depth);
|
|
}
|
|
const oid2 = queue.shift();
|
|
const { type, object } = await _readObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: oid2
|
|
});
|
|
if (type !== "commit") {
|
|
throw new ObjectTypeError(oid2, type, "commit");
|
|
}
|
|
const commit2 = GitCommit.from(object).parse();
|
|
for (const parent of commit2.parent) {
|
|
if (parent === ancestor)
|
|
return true;
|
|
}
|
|
if (!shallows.has(oid2)) {
|
|
for (const parent of commit2.parent) {
|
|
if (!visited.has(parent)) {
|
|
queue.push(parent);
|
|
visited.add(parent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
async function isDescendent({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oid,
|
|
ancestor,
|
|
depth = -1,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
assertParameter("ancestor", ancestor);
|
|
return await _isDescendent({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
ancestor,
|
|
depth
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.isDescendent";
|
|
throw err;
|
|
}
|
|
}
|
|
async function isIgnored({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
filepath
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("dir", dir);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("filepath", filepath);
|
|
return GitIgnoreManager.isIgnored({
|
|
fs: new FileSystem(fs),
|
|
dir,
|
|
gitdir,
|
|
filepath
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.isIgnored";
|
|
throw err;
|
|
}
|
|
}
|
|
async function listBranches({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
remote
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
return GitRefManager.listBranches({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
remote
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.listBranches";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _listFiles({ fs, gitdir, ref, cache }) {
|
|
if (ref) {
|
|
const oid = await GitRefManager.resolve({ gitdir, fs, ref });
|
|
const filenames = [];
|
|
await accumulateFilesFromOid({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filenames,
|
|
prefix: ""
|
|
});
|
|
return filenames;
|
|
} else {
|
|
return GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
return index2.entries.map((x) => x.path);
|
|
});
|
|
}
|
|
}
|
|
async function accumulateFilesFromOid({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filenames,
|
|
prefix
|
|
}) {
|
|
const { tree } = await _readTree({ fs, cache, gitdir, oid });
|
|
for (const entry of tree) {
|
|
if (entry.type === "tree") {
|
|
await accumulateFilesFromOid({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: entry.oid,
|
|
filenames,
|
|
prefix: join(prefix, entry.path)
|
|
});
|
|
} else {
|
|
filenames.push(join(prefix, entry.path));
|
|
}
|
|
}
|
|
}
|
|
async function listFiles({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
return await _listFiles({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
ref
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.listFiles";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _listNotes({ fs, cache, gitdir, ref }) {
|
|
let parent;
|
|
try {
|
|
parent = await GitRefManager.resolve({ gitdir, fs, ref });
|
|
} catch (err) {
|
|
if (err instanceof NotFoundError) {
|
|
return [];
|
|
}
|
|
}
|
|
const result = await _readTree({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: parent
|
|
});
|
|
const notes = result.tree.map((entry) => ({
|
|
target: entry.path,
|
|
note: entry.oid
|
|
}));
|
|
return notes;
|
|
}
|
|
async function listNotes({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref = "refs/notes/commits",
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
return await _listNotes({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
ref
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.listNotes";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _listRemotes({ fs, gitdir }) {
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
const remoteNames = await config.getSubsections("remote");
|
|
const remotes = Promise.all(remoteNames.map(async (remote) => {
|
|
const url = await config.get(`remote.${remote}.url`);
|
|
return { remote, url };
|
|
}));
|
|
return remotes;
|
|
}
|
|
async function listRemotes({ fs, dir, gitdir = join(dir, ".git") }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
return await _listRemotes({
|
|
fs: new FileSystem(fs),
|
|
gitdir
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.listRemotes";
|
|
throw err;
|
|
}
|
|
}
|
|
async function parseListRefsResponse(stream) {
|
|
const read = GitPktLine.streamReader(stream);
|
|
const refs = [];
|
|
let line;
|
|
while (true) {
|
|
line = await read();
|
|
if (line === true)
|
|
break;
|
|
if (line === null)
|
|
continue;
|
|
line = line.toString("utf8").replace(/\n$/, "");
|
|
const [oid, ref, ...attrs] = line.split(" ");
|
|
const r = { ref, oid };
|
|
for (const attr2 of attrs) {
|
|
const [name, value] = attr2.split(":");
|
|
if (name === "symref-target") {
|
|
r.target = value;
|
|
} else if (name === "peeled") {
|
|
r.peeled = value;
|
|
}
|
|
}
|
|
refs.push(r);
|
|
}
|
|
return refs;
|
|
}
|
|
async function writeListRefsRequest({ prefix, symrefs, peelTags }) {
|
|
const packstream = [];
|
|
packstream.push(GitPktLine.encode("command=ls-refs\n"));
|
|
packstream.push(GitPktLine.encode(`agent=${pkg.agent}
|
|
`));
|
|
if (peelTags || symrefs || prefix) {
|
|
packstream.push(GitPktLine.delim());
|
|
}
|
|
if (peelTags)
|
|
packstream.push(GitPktLine.encode("peel"));
|
|
if (symrefs)
|
|
packstream.push(GitPktLine.encode("symrefs"));
|
|
if (prefix)
|
|
packstream.push(GitPktLine.encode(`ref-prefix ${prefix}`));
|
|
packstream.push(GitPktLine.flush());
|
|
return packstream;
|
|
}
|
|
async function listServerRefs({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
url,
|
|
headers = {},
|
|
forPush = false,
|
|
protocolVersion = 2,
|
|
prefix,
|
|
symrefs,
|
|
peelTags
|
|
}) {
|
|
try {
|
|
assertParameter("http", http);
|
|
assertParameter("url", url);
|
|
const remote = await GitRemoteHTTP.discover({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
service: forPush ? "git-receive-pack" : "git-upload-pack",
|
|
url,
|
|
headers,
|
|
protocolVersion
|
|
});
|
|
if (remote.protocolVersion === 1) {
|
|
return formatInfoRefs(remote, prefix, symrefs, peelTags);
|
|
}
|
|
const body = await writeListRefsRequest({ prefix, symrefs, peelTags });
|
|
const res = await GitRemoteHTTP.connect({
|
|
http,
|
|
auth: remote.auth,
|
|
headers,
|
|
corsProxy,
|
|
service: forPush ? "git-receive-pack" : "git-upload-pack",
|
|
url,
|
|
body
|
|
});
|
|
return parseListRefsResponse(res.body);
|
|
} catch (err) {
|
|
err.caller = "git.listServerRefs";
|
|
throw err;
|
|
}
|
|
}
|
|
async function listTags({ fs, dir, gitdir = join(dir, ".git") }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
return GitRefManager.listTags({ fs: new FileSystem(fs), gitdir });
|
|
} catch (err) {
|
|
err.caller = "git.listTags";
|
|
throw err;
|
|
}
|
|
}
|
|
async function resolveCommit({ fs, cache, gitdir, oid }) {
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
if (type === "tag") {
|
|
oid = GitAnnotatedTag.from(object).parse().object;
|
|
return resolveCommit({ fs, cache, gitdir, oid });
|
|
}
|
|
if (type !== "commit") {
|
|
throw new ObjectTypeError(oid, type, "commit");
|
|
}
|
|
return { commit: GitCommit.from(object), oid };
|
|
}
|
|
async function _readCommit({ fs, cache, gitdir, oid }) {
|
|
const { commit: commit2, oid: commitOid } = await resolveCommit({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid
|
|
});
|
|
const result = {
|
|
oid: commitOid,
|
|
commit: commit2.parse(),
|
|
payload: commit2.withoutSignature()
|
|
};
|
|
return result;
|
|
}
|
|
function compareAge(a, b) {
|
|
return a.committer.timestamp - b.committer.timestamp;
|
|
}
|
|
var EMPTY_OID = "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391";
|
|
async function resolveFileIdInTree({ fs, cache, gitdir, oid, fileId }) {
|
|
if (fileId === EMPTY_OID)
|
|
return;
|
|
const _oid = oid;
|
|
let filepath;
|
|
const result = await resolveTree({ fs, cache, gitdir, oid });
|
|
const tree = result.tree;
|
|
if (fileId === result.oid) {
|
|
filepath = result.path;
|
|
} else {
|
|
filepath = await _resolveFileId({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
tree,
|
|
fileId,
|
|
oid: _oid
|
|
});
|
|
if (Array.isArray(filepath)) {
|
|
if (filepath.length === 0)
|
|
filepath = void 0;
|
|
else if (filepath.length === 1)
|
|
filepath = filepath[0];
|
|
}
|
|
}
|
|
return filepath;
|
|
}
|
|
async function _resolveFileId({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
tree,
|
|
fileId,
|
|
oid,
|
|
filepaths = [],
|
|
parentPath = ""
|
|
}) {
|
|
const walks = tree.entries().map(function(entry) {
|
|
let result;
|
|
if (entry.oid === fileId) {
|
|
result = join(parentPath, entry.path);
|
|
filepaths.push(result);
|
|
} else if (entry.type === "tree") {
|
|
result = _readObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: entry.oid
|
|
}).then(function({ object }) {
|
|
return _resolveFileId({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
tree: GitTree.from(object),
|
|
fileId,
|
|
oid,
|
|
filepaths,
|
|
parentPath: join(parentPath, entry.path)
|
|
});
|
|
});
|
|
}
|
|
return result;
|
|
});
|
|
await Promise.all(walks);
|
|
return filepaths;
|
|
}
|
|
async function _log({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
filepath,
|
|
ref,
|
|
depth,
|
|
since,
|
|
force,
|
|
follow
|
|
}) {
|
|
const sinceTimestamp = typeof since === "undefined" ? void 0 : Math.floor(since.valueOf() / 1e3);
|
|
const commits = [];
|
|
const shallowCommits = await GitShallowManager.read({ fs, gitdir });
|
|
const oid = await GitRefManager.resolve({ fs, gitdir, ref });
|
|
const tips = [await _readCommit({ fs, cache, gitdir, oid })];
|
|
let lastFileOid;
|
|
let lastCommit;
|
|
let isOk;
|
|
function endCommit(commit2) {
|
|
if (isOk && filepath)
|
|
commits.push(commit2);
|
|
}
|
|
while (tips.length > 0) {
|
|
const commit2 = tips.pop();
|
|
if (sinceTimestamp !== void 0 && commit2.commit.committer.timestamp <= sinceTimestamp) {
|
|
break;
|
|
}
|
|
if (filepath) {
|
|
let vFileOid;
|
|
try {
|
|
vFileOid = await resolveFilepath({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: commit2.commit.tree,
|
|
filepath
|
|
});
|
|
if (lastCommit && lastFileOid !== vFileOid) {
|
|
commits.push(lastCommit);
|
|
}
|
|
lastFileOid = vFileOid;
|
|
lastCommit = commit2;
|
|
isOk = true;
|
|
} catch (e) {
|
|
if (e instanceof NotFoundError) {
|
|
let found = follow && lastFileOid;
|
|
if (found) {
|
|
found = await resolveFileIdInTree({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: commit2.commit.tree,
|
|
fileId: lastFileOid
|
|
});
|
|
if (found) {
|
|
if (Array.isArray(found)) {
|
|
if (lastCommit) {
|
|
const lastFound = await resolveFileIdInTree({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: lastCommit.commit.tree,
|
|
fileId: lastFileOid
|
|
});
|
|
if (Array.isArray(lastFound)) {
|
|
found = found.filter((p) => lastFound.indexOf(p) === -1);
|
|
if (found.length === 1) {
|
|
found = found[0];
|
|
filepath = found;
|
|
if (lastCommit)
|
|
commits.push(lastCommit);
|
|
} else {
|
|
found = false;
|
|
if (lastCommit)
|
|
commits.push(lastCommit);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
filepath = found;
|
|
if (lastCommit)
|
|
commits.push(lastCommit);
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
if (isOk && lastFileOid) {
|
|
commits.push(lastCommit);
|
|
if (!force)
|
|
break;
|
|
}
|
|
if (!force && !follow)
|
|
throw e;
|
|
}
|
|
lastCommit = commit2;
|
|
isOk = false;
|
|
} else
|
|
throw e;
|
|
}
|
|
} else {
|
|
commits.push(commit2);
|
|
}
|
|
if (depth !== void 0 && commits.length === depth) {
|
|
endCommit(commit2);
|
|
break;
|
|
}
|
|
if (!shallowCommits.has(commit2.oid)) {
|
|
for (const oid2 of commit2.commit.parent) {
|
|
const commit3 = await _readCommit({ fs, cache, gitdir, oid: oid2 });
|
|
if (!tips.map((commit4) => commit4.oid).includes(commit3.oid)) {
|
|
tips.push(commit3);
|
|
}
|
|
}
|
|
}
|
|
if (tips.length === 0) {
|
|
endCommit(commit2);
|
|
}
|
|
tips.sort((a, b) => compareAge(a.commit, b.commit));
|
|
}
|
|
return commits;
|
|
}
|
|
async function log({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
filepath,
|
|
ref = "HEAD",
|
|
depth,
|
|
since,
|
|
force,
|
|
follow,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
return await _log({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
filepath,
|
|
ref,
|
|
depth,
|
|
since,
|
|
force,
|
|
follow
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.log";
|
|
throw err;
|
|
}
|
|
}
|
|
async function merge({
|
|
fs: _fs,
|
|
onSign,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ours,
|
|
theirs,
|
|
fastForward: fastForward2 = true,
|
|
fastForwardOnly = false,
|
|
dryRun = false,
|
|
noUpdateBranch = false,
|
|
abortOnConflict = true,
|
|
message,
|
|
author: _author,
|
|
committer: _committer,
|
|
signingKey,
|
|
cache = {},
|
|
mergeDriver
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
if (signingKey) {
|
|
assertParameter("onSign", onSign);
|
|
}
|
|
const fs = new FileSystem(_fs);
|
|
const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
|
|
if (!author && (!fastForwardOnly || !fastForward2)) {
|
|
throw new MissingNameError("author");
|
|
}
|
|
const committer = await normalizeCommitterObject({
|
|
fs,
|
|
gitdir,
|
|
author,
|
|
committer: _committer
|
|
});
|
|
if (!committer && (!fastForwardOnly || !fastForward2)) {
|
|
throw new MissingNameError("committer");
|
|
}
|
|
return await _merge({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
ours,
|
|
theirs,
|
|
fastForward: fastForward2,
|
|
fastForwardOnly,
|
|
dryRun,
|
|
noUpdateBranch,
|
|
abortOnConflict,
|
|
message,
|
|
author,
|
|
committer,
|
|
signingKey,
|
|
onSign,
|
|
mergeDriver
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.merge";
|
|
throw err;
|
|
}
|
|
}
|
|
var types = {
|
|
commit: 16,
|
|
tree: 32,
|
|
blob: 48,
|
|
tag: 64,
|
|
ofs_delta: 96,
|
|
ref_delta: 112
|
|
};
|
|
async function _pack({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oids
|
|
}) {
|
|
const hash2 = new import_sha1.default();
|
|
const outputStream = [];
|
|
function write(chunk, enc) {
|
|
const buff = Buffer2.from(chunk, enc);
|
|
outputStream.push(buff);
|
|
hash2.update(buff);
|
|
}
|
|
async function writeObject2({ stype, object }) {
|
|
const type = types[stype];
|
|
let length = object.length;
|
|
let multibyte = length > 15 ? 128 : 0;
|
|
const lastFour = length & 15;
|
|
length = length >>> 4;
|
|
let byte = (multibyte | type | lastFour).toString(16);
|
|
write(byte, "hex");
|
|
while (multibyte) {
|
|
multibyte = length > 127 ? 128 : 0;
|
|
byte = multibyte | length & 127;
|
|
write(padHex(2, byte), "hex");
|
|
length = length >>> 7;
|
|
}
|
|
write(Buffer2.from(await deflate(object)));
|
|
}
|
|
write("PACK");
|
|
write("00000002", "hex");
|
|
write(padHex(8, oids.length), "hex");
|
|
for (const oid of oids) {
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
await writeObject2({ write, object, stype: type });
|
|
}
|
|
const digest = hash2.digest();
|
|
outputStream.push(digest);
|
|
return outputStream;
|
|
}
|
|
async function _packObjects({ fs, cache, gitdir, oids, write }) {
|
|
const buffers = await _pack({ fs, cache, gitdir, oids });
|
|
const packfile = Buffer2.from(await collect(buffers));
|
|
const packfileSha = packfile.slice(-20).toString("hex");
|
|
const filename = `pack-${packfileSha}.pack`;
|
|
if (write) {
|
|
await fs.write(join(gitdir, `objects/pack/${filename}`), packfile);
|
|
return { filename };
|
|
}
|
|
return {
|
|
filename,
|
|
packfile: new Uint8Array(packfile)
|
|
};
|
|
}
|
|
async function packObjects({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oids,
|
|
write = false,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oids", oids);
|
|
return await _packObjects({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oids,
|
|
write
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.packObjects";
|
|
throw err;
|
|
}
|
|
}
|
|
async function pull({
|
|
fs: _fs,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
url,
|
|
remote,
|
|
remoteRef,
|
|
prune = false,
|
|
pruneTags = false,
|
|
fastForward: fastForward2 = true,
|
|
fastForwardOnly = false,
|
|
corsProxy,
|
|
singleBranch,
|
|
headers = {},
|
|
author: _author,
|
|
committer: _committer,
|
|
signingKey,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
const fs = new FileSystem(_fs);
|
|
const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
|
|
if (!author)
|
|
throw new MissingNameError("author");
|
|
const committer = await normalizeCommitterObject({
|
|
fs,
|
|
gitdir,
|
|
author,
|
|
committer: _committer
|
|
});
|
|
if (!committer)
|
|
throw new MissingNameError("committer");
|
|
return await _pull({
|
|
fs,
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir,
|
|
ref,
|
|
url,
|
|
remote,
|
|
remoteRef,
|
|
fastForward: fastForward2,
|
|
fastForwardOnly,
|
|
corsProxy,
|
|
singleBranch,
|
|
headers,
|
|
author,
|
|
committer,
|
|
signingKey,
|
|
prune,
|
|
pruneTags
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.pull";
|
|
throw err;
|
|
}
|
|
}
|
|
async function listCommitsAndTags({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
start,
|
|
finish
|
|
}) {
|
|
const shallows = await GitShallowManager.read({ fs, gitdir });
|
|
const startingSet = new Set();
|
|
const finishingSet = new Set();
|
|
for (const ref of start) {
|
|
startingSet.add(await GitRefManager.resolve({ fs, gitdir, ref }));
|
|
}
|
|
for (const ref of finish) {
|
|
try {
|
|
const oid = await GitRefManager.resolve({ fs, gitdir, ref });
|
|
finishingSet.add(oid);
|
|
} catch (err) {
|
|
}
|
|
}
|
|
const visited = new Set();
|
|
async function walk2(oid) {
|
|
visited.add(oid);
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
if (type === "tag") {
|
|
const tag2 = GitAnnotatedTag.from(object);
|
|
const commit2 = tag2.headers().object;
|
|
return walk2(commit2);
|
|
}
|
|
if (type !== "commit") {
|
|
throw new ObjectTypeError(oid, type, "commit");
|
|
}
|
|
if (!shallows.has(oid)) {
|
|
const commit2 = GitCommit.from(object);
|
|
const parents = commit2.headers().parent;
|
|
for (oid of parents) {
|
|
if (!finishingSet.has(oid) && !visited.has(oid)) {
|
|
await walk2(oid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (const oid of startingSet) {
|
|
await walk2(oid);
|
|
}
|
|
return visited;
|
|
}
|
|
async function listObjects({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oids
|
|
}) {
|
|
const visited = new Set();
|
|
async function walk2(oid) {
|
|
if (visited.has(oid))
|
|
return;
|
|
visited.add(oid);
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
if (type === "tag") {
|
|
const tag2 = GitAnnotatedTag.from(object);
|
|
const obj = tag2.headers().object;
|
|
await walk2(obj);
|
|
} else if (type === "commit") {
|
|
const commit2 = GitCommit.from(object);
|
|
const tree = commit2.headers().tree;
|
|
await walk2(tree);
|
|
} else if (type === "tree") {
|
|
const tree = GitTree.from(object);
|
|
for (const entry of tree) {
|
|
if (entry.type === "blob") {
|
|
visited.add(entry.oid);
|
|
}
|
|
if (entry.type === "tree") {
|
|
await walk2(entry.oid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (const oid of oids) {
|
|
await walk2(oid);
|
|
}
|
|
return visited;
|
|
}
|
|
async function parseReceivePackResponse(packfile) {
|
|
const result = {};
|
|
let response = "";
|
|
const read = GitPktLine.streamReader(packfile);
|
|
let line = await read();
|
|
while (line !== true) {
|
|
if (line !== null)
|
|
response += line.toString("utf8") + "\n";
|
|
line = await read();
|
|
}
|
|
const lines = response.toString("utf8").split("\n");
|
|
line = lines.shift();
|
|
if (!line.startsWith("unpack ")) {
|
|
throw new ParseError('unpack ok" or "unpack [error message]', line);
|
|
}
|
|
result.ok = line === "unpack ok";
|
|
if (!result.ok) {
|
|
result.error = line.slice("unpack ".length);
|
|
}
|
|
result.refs = {};
|
|
for (const line2 of lines) {
|
|
if (line2.trim() === "")
|
|
continue;
|
|
const status2 = line2.slice(0, 2);
|
|
const refAndMessage = line2.slice(3);
|
|
let space2 = refAndMessage.indexOf(" ");
|
|
if (space2 === -1)
|
|
space2 = refAndMessage.length;
|
|
const ref = refAndMessage.slice(0, space2);
|
|
const error = refAndMessage.slice(space2 + 1);
|
|
result.refs[ref] = {
|
|
ok: status2 === "ok",
|
|
error
|
|
};
|
|
}
|
|
return result;
|
|
}
|
|
async function writeReceivePackRequest({
|
|
capabilities = [],
|
|
triplets = []
|
|
}) {
|
|
const packstream = [];
|
|
let capsFirstLine = `\0 ${capabilities.join(" ")}`;
|
|
for (const trip of triplets) {
|
|
packstream.push(GitPktLine.encode(`${trip.oldoid} ${trip.oid} ${trip.fullRef}${capsFirstLine}
|
|
`));
|
|
capsFirstLine = "";
|
|
}
|
|
packstream.push(GitPktLine.flush());
|
|
return packstream;
|
|
}
|
|
async function _push({
|
|
fs,
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
gitdir,
|
|
ref: _ref,
|
|
remoteRef: _remoteRef,
|
|
remote,
|
|
url: _url,
|
|
force = false,
|
|
delete: _delete = false,
|
|
corsProxy,
|
|
headers = {}
|
|
}) {
|
|
const ref = _ref || await _currentBranch({ fs, gitdir });
|
|
if (typeof ref === "undefined") {
|
|
throw new MissingParameterError("ref");
|
|
}
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
remote = remote || await config.get(`branch.${ref}.pushRemote`) || await config.get("remote.pushDefault") || await config.get(`branch.${ref}.remote`) || "origin";
|
|
const url = _url || await config.get(`remote.${remote}.pushurl`) || await config.get(`remote.${remote}.url`);
|
|
if (typeof url === "undefined") {
|
|
throw new MissingParameterError("remote OR url");
|
|
}
|
|
const remoteRef = _remoteRef || await config.get(`branch.${ref}.merge`);
|
|
if (typeof url === "undefined") {
|
|
throw new MissingParameterError("remoteRef");
|
|
}
|
|
if (corsProxy === void 0) {
|
|
corsProxy = await config.get("http.corsProxy");
|
|
}
|
|
const fullRef = await GitRefManager.expand({ fs, gitdir, ref });
|
|
const oid = _delete ? "0000000000000000000000000000000000000000" : await GitRefManager.resolve({ fs, gitdir, ref: fullRef });
|
|
const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url });
|
|
const httpRemote = await GitRemoteHTTP2.discover({
|
|
http,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
corsProxy,
|
|
service: "git-receive-pack",
|
|
url,
|
|
headers,
|
|
protocolVersion: 1
|
|
});
|
|
const auth = httpRemote.auth;
|
|
let fullRemoteRef;
|
|
if (!remoteRef) {
|
|
fullRemoteRef = fullRef;
|
|
} else {
|
|
try {
|
|
fullRemoteRef = await GitRefManager.expandAgainstMap({
|
|
ref: remoteRef,
|
|
map: httpRemote.refs
|
|
});
|
|
} catch (err) {
|
|
if (err instanceof NotFoundError) {
|
|
fullRemoteRef = remoteRef.startsWith("refs/") ? remoteRef : `refs/heads/${remoteRef}`;
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
const oldoid = httpRemote.refs.get(fullRemoteRef) || "0000000000000000000000000000000000000000";
|
|
const thinPack = !httpRemote.capabilities.has("no-thin");
|
|
let objects = new Set();
|
|
if (!_delete) {
|
|
const finish = [...httpRemote.refs.values()];
|
|
let skipObjects = new Set();
|
|
if (oldoid !== "0000000000000000000000000000000000000000") {
|
|
const mergebase = await _findMergeBase({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oids: [oid, oldoid]
|
|
});
|
|
for (const oid2 of mergebase)
|
|
finish.push(oid2);
|
|
if (thinPack) {
|
|
skipObjects = await listObjects({ fs, cache, gitdir, oids: mergebase });
|
|
}
|
|
}
|
|
if (!finish.includes(oid)) {
|
|
const commits = await listCommitsAndTags({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
start: [oid],
|
|
finish
|
|
});
|
|
objects = await listObjects({ fs, cache, gitdir, oids: commits });
|
|
}
|
|
if (thinPack) {
|
|
try {
|
|
const ref2 = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: `refs/remotes/${remote}/HEAD`,
|
|
depth: 2
|
|
});
|
|
const { oid: oid2 } = await GitRefManager.resolveAgainstMap({
|
|
ref: ref2.replace(`refs/remotes/${remote}/`, ""),
|
|
fullref: ref2,
|
|
map: httpRemote.refs
|
|
});
|
|
const oids = [oid2];
|
|
for (const oid3 of await listObjects({ fs, cache, gitdir, oids })) {
|
|
skipObjects.add(oid3);
|
|
}
|
|
} catch (e) {
|
|
}
|
|
for (const oid2 of skipObjects) {
|
|
objects.delete(oid2);
|
|
}
|
|
}
|
|
if (oid === oldoid)
|
|
force = true;
|
|
if (!force) {
|
|
if (fullRef.startsWith("refs/tags") && oldoid !== "0000000000000000000000000000000000000000") {
|
|
throw new PushRejectedError("tag-exists");
|
|
}
|
|
if (oid !== "0000000000000000000000000000000000000000" && oldoid !== "0000000000000000000000000000000000000000" && !await _isDescendent({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
ancestor: oldoid,
|
|
depth: -1
|
|
})) {
|
|
throw new PushRejectedError("not-fast-forward");
|
|
}
|
|
}
|
|
}
|
|
const capabilities = filterCapabilities([...httpRemote.capabilities], ["report-status", "side-band-64k", `agent=${pkg.agent}`]);
|
|
const packstream1 = await writeReceivePackRequest({
|
|
capabilities,
|
|
triplets: [{ oldoid, oid, fullRef: fullRemoteRef }]
|
|
});
|
|
const packstream2 = _delete ? [] : await _pack({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oids: [...objects]
|
|
});
|
|
const res = await GitRemoteHTTP2.connect({
|
|
http,
|
|
onProgress,
|
|
corsProxy,
|
|
service: "git-receive-pack",
|
|
url,
|
|
auth,
|
|
headers,
|
|
body: [...packstream1, ...packstream2]
|
|
});
|
|
const { packfile, progress } = await GitSideBand.demux(res.body);
|
|
if (onMessage) {
|
|
const lines = splitLines(progress);
|
|
forAwait(lines, async (line) => {
|
|
await onMessage(line);
|
|
});
|
|
}
|
|
const result = await parseReceivePackResponse(packfile);
|
|
if (res.headers) {
|
|
result.headers = res.headers;
|
|
}
|
|
if (remote && result.ok && result.refs[fullRemoteRef].ok) {
|
|
const ref2 = `refs/remotes/${remote}/${fullRemoteRef.replace("refs/heads", "")}`;
|
|
if (_delete) {
|
|
await GitRefManager.deleteRef({ fs, gitdir, ref: ref2 });
|
|
} else {
|
|
await GitRefManager.writeRef({ fs, gitdir, ref: ref2, value: oid });
|
|
}
|
|
}
|
|
if (result.ok && Object.values(result.refs).every((result2) => result2.ok)) {
|
|
return result;
|
|
} else {
|
|
const prettyDetails = Object.entries(result.refs).filter(([k, v]) => !v.ok).map(([k, v]) => `
|
|
- ${k}: ${v.error}`).join("");
|
|
throw new GitPushError(prettyDetails, result);
|
|
}
|
|
}
|
|
async function push({
|
|
fs,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
remoteRef,
|
|
remote = "origin",
|
|
url,
|
|
force = false,
|
|
delete: _delete = false,
|
|
corsProxy,
|
|
headers = {},
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("http", http);
|
|
assertParameter("gitdir", gitdir);
|
|
return await _push({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
http,
|
|
onProgress,
|
|
onMessage,
|
|
onAuth,
|
|
onAuthSuccess,
|
|
onAuthFailure,
|
|
gitdir,
|
|
ref,
|
|
remoteRef,
|
|
remote,
|
|
url,
|
|
force,
|
|
delete: _delete,
|
|
corsProxy,
|
|
headers
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.push";
|
|
throw err;
|
|
}
|
|
}
|
|
async function resolveBlob({ fs, cache, gitdir, oid }) {
|
|
const { type, object } = await _readObject({ fs, cache, gitdir, oid });
|
|
if (type === "tag") {
|
|
oid = GitAnnotatedTag.from(object).parse().object;
|
|
return resolveBlob({ fs, cache, gitdir, oid });
|
|
}
|
|
if (type !== "blob") {
|
|
throw new ObjectTypeError(oid, type, "blob");
|
|
}
|
|
return { oid, blob: new Uint8Array(object) };
|
|
}
|
|
async function _readBlob({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filepath = void 0
|
|
}) {
|
|
if (filepath !== void 0) {
|
|
oid = await resolveFilepath({ fs, cache, gitdir, oid, filepath });
|
|
}
|
|
const blob = await resolveBlob({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid
|
|
});
|
|
return blob;
|
|
}
|
|
async function readBlob({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oid,
|
|
filepath,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
return await _readBlob({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filepath
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.readBlob";
|
|
throw err;
|
|
}
|
|
}
|
|
async function readCommit({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oid,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
return await _readCommit({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oid
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.readCommit";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _readNote({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
ref = "refs/notes/commits",
|
|
oid
|
|
}) {
|
|
const parent = await GitRefManager.resolve({ gitdir, fs, ref });
|
|
const { blob } = await _readBlob({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: parent,
|
|
filepath: oid
|
|
});
|
|
return blob;
|
|
}
|
|
async function readNote({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref = "refs/notes/commits",
|
|
oid,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
assertParameter("oid", oid);
|
|
return await _readNote({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
ref,
|
|
oid
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.readNote";
|
|
throw err;
|
|
}
|
|
}
|
|
async function readObject({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oid,
|
|
format = "parsed",
|
|
filepath = void 0,
|
|
encoding = void 0,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
const fs = new FileSystem(_fs);
|
|
if (filepath !== void 0) {
|
|
oid = await resolveFilepath({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filepath
|
|
});
|
|
}
|
|
const _format = format === "parsed" ? "content" : format;
|
|
const result = await _readObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
format: _format
|
|
});
|
|
result.oid = oid;
|
|
if (format === "parsed") {
|
|
result.format = "parsed";
|
|
switch (result.type) {
|
|
case "commit":
|
|
result.object = GitCommit.from(result.object).parse();
|
|
break;
|
|
case "tree":
|
|
result.object = GitTree.from(result.object).entries();
|
|
break;
|
|
case "blob":
|
|
if (encoding) {
|
|
result.object = result.object.toString(encoding);
|
|
} else {
|
|
result.object = new Uint8Array(result.object);
|
|
result.format = "content";
|
|
}
|
|
break;
|
|
case "tag":
|
|
result.object = GitAnnotatedTag.from(result.object).parse();
|
|
break;
|
|
default:
|
|
throw new ObjectTypeError(result.oid, result.type, "blob|commit|tag|tree");
|
|
}
|
|
} else if (result.format === "deflated" || result.format === "wrapped") {
|
|
result.type = result.format;
|
|
}
|
|
return result;
|
|
} catch (err) {
|
|
err.caller = "git.readObject";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _readTag({ fs, cache, gitdir, oid }) {
|
|
const { type, object } = await _readObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
format: "content"
|
|
});
|
|
if (type !== "tag") {
|
|
throw new ObjectTypeError(oid, type, "tag");
|
|
}
|
|
const tag2 = GitAnnotatedTag.from(object);
|
|
const result = {
|
|
oid,
|
|
tag: tag2.parse(),
|
|
payload: tag2.payload()
|
|
};
|
|
return result;
|
|
}
|
|
async function readTag({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oid,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
return await _readTag({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oid
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.readTag";
|
|
throw err;
|
|
}
|
|
}
|
|
async function readTree({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
oid,
|
|
filepath = void 0,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
return await _readTree({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filepath
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.readTree";
|
|
throw err;
|
|
}
|
|
}
|
|
async function remove({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
filepath,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("filepath", filepath);
|
|
await GitIndexManager.acquire({ fs: new FileSystem(_fs), gitdir, cache }, async function(index2) {
|
|
index2.delete({ filepath });
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.remove";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _removeNote({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref = "refs/notes/commits",
|
|
oid,
|
|
author,
|
|
committer,
|
|
signingKey
|
|
}) {
|
|
let parent;
|
|
try {
|
|
parent = await GitRefManager.resolve({ gitdir, fs, ref });
|
|
} catch (err) {
|
|
if (!(err instanceof NotFoundError)) {
|
|
throw err;
|
|
}
|
|
}
|
|
const result = await _readTree({
|
|
fs,
|
|
gitdir,
|
|
oid: parent || "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
|
|
});
|
|
let tree = result.tree;
|
|
tree = tree.filter((entry) => entry.path !== oid);
|
|
const treeOid = await _writeTree({
|
|
fs,
|
|
gitdir,
|
|
tree
|
|
});
|
|
const commitOid = await _commit({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref,
|
|
tree: treeOid,
|
|
parent: parent && [parent],
|
|
message: `Note removed by 'isomorphic-git removeNote'
|
|
`,
|
|
author,
|
|
committer,
|
|
signingKey
|
|
});
|
|
return commitOid;
|
|
}
|
|
async function removeNote({
|
|
fs: _fs,
|
|
onSign,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref = "refs/notes/commits",
|
|
oid,
|
|
author: _author,
|
|
committer: _committer,
|
|
signingKey,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("oid", oid);
|
|
const fs = new FileSystem(_fs);
|
|
const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
|
|
if (!author)
|
|
throw new MissingNameError("author");
|
|
const committer = await normalizeCommitterObject({
|
|
fs,
|
|
gitdir,
|
|
author,
|
|
committer: _committer
|
|
});
|
|
if (!committer)
|
|
throw new MissingNameError("committer");
|
|
return await _removeNote({
|
|
fs,
|
|
cache,
|
|
onSign,
|
|
gitdir,
|
|
ref,
|
|
oid,
|
|
author,
|
|
committer,
|
|
signingKey
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.removeNote";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _renameBranch({
|
|
fs,
|
|
gitdir,
|
|
oldref,
|
|
ref,
|
|
checkout: checkout2 = false
|
|
}) {
|
|
if (ref !== import_clean_git_ref.default.clean(ref)) {
|
|
throw new InvalidRefNameError(ref, import_clean_git_ref.default.clean(ref));
|
|
}
|
|
if (oldref !== import_clean_git_ref.default.clean(oldref)) {
|
|
throw new InvalidRefNameError(oldref, import_clean_git_ref.default.clean(oldref));
|
|
}
|
|
const fulloldref = `refs/heads/${oldref}`;
|
|
const fullnewref = `refs/heads/${ref}`;
|
|
const newexist = await GitRefManager.exists({ fs, gitdir, ref: fullnewref });
|
|
if (newexist) {
|
|
throw new AlreadyExistsError("branch", ref, false);
|
|
}
|
|
const value = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: fulloldref,
|
|
depth: 1
|
|
});
|
|
await GitRefManager.writeRef({ fs, gitdir, ref: fullnewref, value });
|
|
await GitRefManager.deleteRef({ fs, gitdir, ref: fulloldref });
|
|
if (checkout2) {
|
|
await GitRefManager.writeSymbolicRef({
|
|
fs,
|
|
gitdir,
|
|
ref: "HEAD",
|
|
value: fullnewref
|
|
});
|
|
}
|
|
}
|
|
async function renameBranch({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
oldref,
|
|
checkout: checkout2 = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
assertParameter("oldref", oldref);
|
|
return await _renameBranch({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
ref,
|
|
oldref,
|
|
checkout: checkout2
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.renameBranch";
|
|
throw err;
|
|
}
|
|
}
|
|
async function hashObject$1({ gitdir, type, object }) {
|
|
return shasum(GitObject.wrap({ type, object }));
|
|
}
|
|
async function resetIndex({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
filepath,
|
|
ref,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("filepath", filepath);
|
|
const fs = new FileSystem(_fs);
|
|
let oid;
|
|
let workdirOid;
|
|
try {
|
|
oid = await GitRefManager.resolve({ fs, gitdir, ref: ref || "HEAD" });
|
|
} catch (e) {
|
|
if (ref) {
|
|
throw e;
|
|
}
|
|
}
|
|
if (oid) {
|
|
try {
|
|
oid = await resolveFilepath({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid,
|
|
filepath
|
|
});
|
|
} catch (e) {
|
|
oid = null;
|
|
}
|
|
}
|
|
let stats = {
|
|
ctime: new Date(0),
|
|
mtime: new Date(0),
|
|
dev: 0,
|
|
ino: 0,
|
|
mode: 0,
|
|
uid: 0,
|
|
gid: 0,
|
|
size: 0
|
|
};
|
|
const object = dir && await fs.read(join(dir, filepath));
|
|
if (object) {
|
|
workdirOid = await hashObject$1({
|
|
gitdir,
|
|
type: "blob",
|
|
object
|
|
});
|
|
if (oid === workdirOid) {
|
|
stats = await fs.lstat(join(dir, filepath));
|
|
}
|
|
}
|
|
await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
index2.delete({ filepath });
|
|
if (oid) {
|
|
index2.insert({ filepath, stats, oid });
|
|
}
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.reset";
|
|
throw err;
|
|
}
|
|
}
|
|
async function resolveRef({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
depth
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
const oid = await GitRefManager.resolve({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
ref,
|
|
depth
|
|
});
|
|
return oid;
|
|
} catch (err) {
|
|
err.caller = "git.resolveRef";
|
|
throw err;
|
|
}
|
|
}
|
|
async function setConfig({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
path: path2,
|
|
value,
|
|
append: append3 = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("path", path2);
|
|
const fs = new FileSystem(_fs);
|
|
const config = await GitConfigManager.get({ fs, gitdir });
|
|
if (append3) {
|
|
await config.append(path2, value);
|
|
} else {
|
|
await config.set(path2, value);
|
|
}
|
|
await GitConfigManager.save({ fs, gitdir, config });
|
|
} catch (err) {
|
|
err.caller = "git.setConfig";
|
|
throw err;
|
|
}
|
|
}
|
|
async function status({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
filepath,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("filepath", filepath);
|
|
const fs = new FileSystem(_fs);
|
|
const ignored = await GitIgnoreManager.isIgnored({
|
|
fs,
|
|
gitdir,
|
|
dir,
|
|
filepath
|
|
});
|
|
if (ignored) {
|
|
return "ignored";
|
|
}
|
|
const headTree = await getHeadTree({ fs, cache, gitdir });
|
|
const treeOid = await getOidAtPath({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
tree: headTree,
|
|
path: filepath
|
|
});
|
|
const indexEntry = await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
for (const entry of index2) {
|
|
if (entry.path === filepath)
|
|
return entry;
|
|
}
|
|
return null;
|
|
});
|
|
const stats = await fs.lstat(join(dir, filepath));
|
|
const H = treeOid !== null;
|
|
const I = indexEntry !== null;
|
|
const W = stats !== null;
|
|
const getWorkdirOid = async () => {
|
|
if (I && !compareStats(indexEntry, stats)) {
|
|
return indexEntry.oid;
|
|
} else {
|
|
const object = await fs.read(join(dir, filepath));
|
|
const workdirOid = await hashObject$1({
|
|
gitdir,
|
|
type: "blob",
|
|
object
|
|
});
|
|
if (I && indexEntry.oid === workdirOid) {
|
|
if (stats.size !== -1) {
|
|
GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
index2.insert({ filepath, stats, oid: workdirOid });
|
|
});
|
|
}
|
|
}
|
|
return workdirOid;
|
|
}
|
|
};
|
|
if (!H && !W && !I)
|
|
return "absent";
|
|
if (!H && !W && I)
|
|
return "*absent";
|
|
if (!H && W && !I)
|
|
return "*added";
|
|
if (!H && W && I) {
|
|
const workdirOid = await getWorkdirOid();
|
|
return workdirOid === indexEntry.oid ? "added" : "*added";
|
|
}
|
|
if (H && !W && !I)
|
|
return "deleted";
|
|
if (H && !W && I) {
|
|
return treeOid === indexEntry.oid ? "*deleted" : "*deleted";
|
|
}
|
|
if (H && W && !I) {
|
|
const workdirOid = await getWorkdirOid();
|
|
return workdirOid === treeOid ? "*undeleted" : "*undeletemodified";
|
|
}
|
|
if (H && W && I) {
|
|
const workdirOid = await getWorkdirOid();
|
|
if (workdirOid === treeOid) {
|
|
return workdirOid === indexEntry.oid ? "unmodified" : "*unmodified";
|
|
} else {
|
|
return workdirOid === indexEntry.oid ? "modified" : "*modified";
|
|
}
|
|
}
|
|
} catch (err) {
|
|
err.caller = "git.status";
|
|
throw err;
|
|
}
|
|
}
|
|
async function getOidAtPath({ fs, cache, gitdir, tree, path: path2 }) {
|
|
if (typeof path2 === "string")
|
|
path2 = path2.split("/");
|
|
const dirname2 = path2.shift();
|
|
for (const entry of tree) {
|
|
if (entry.path === dirname2) {
|
|
if (path2.length === 0) {
|
|
return entry.oid;
|
|
}
|
|
const { type, object } = await _readObject({
|
|
fs,
|
|
cache,
|
|
gitdir,
|
|
oid: entry.oid
|
|
});
|
|
if (type === "tree") {
|
|
const tree2 = GitTree.from(object);
|
|
return getOidAtPath({ fs, cache, gitdir, tree: tree2, path: path2 });
|
|
}
|
|
if (type === "blob") {
|
|
throw new ObjectTypeError(entry.oid, type, "blob", path2.join("/"));
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
async function getHeadTree({ fs, cache, gitdir }) {
|
|
let oid;
|
|
try {
|
|
oid = await GitRefManager.resolve({ fs, gitdir, ref: "HEAD" });
|
|
} catch (e) {
|
|
if (e instanceof NotFoundError) {
|
|
return [];
|
|
}
|
|
}
|
|
const { tree } = await _readTree({ fs, cache, gitdir, oid });
|
|
return tree;
|
|
}
|
|
async function statusMatrix({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref = "HEAD",
|
|
filepaths = ["."],
|
|
filter,
|
|
cache = {},
|
|
ignored: shouldIgnore = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
const fs = new FileSystem(_fs);
|
|
return await _walk({
|
|
fs,
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
trees: [TREE({ ref }), WORKDIR(), STAGE()],
|
|
map: async function(filepath, [head, workdir, stage]) {
|
|
if (!head && !stage && workdir) {
|
|
if (!shouldIgnore) {
|
|
const isIgnored2 = await GitIgnoreManager.isIgnored({
|
|
fs,
|
|
dir,
|
|
filepath
|
|
});
|
|
if (isIgnored2) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
if (!filepaths.some((base) => worthWalking(filepath, base))) {
|
|
return null;
|
|
}
|
|
if (filter) {
|
|
if (!filter(filepath))
|
|
return;
|
|
}
|
|
const [headType, workdirType, stageType] = await Promise.all([
|
|
head && head.type(),
|
|
workdir && workdir.type(),
|
|
stage && stage.type()
|
|
]);
|
|
const isBlob = [headType, workdirType, stageType].includes("blob");
|
|
if ((headType === "tree" || headType === "special") && !isBlob)
|
|
return;
|
|
if (headType === "commit")
|
|
return null;
|
|
if ((workdirType === "tree" || workdirType === "special") && !isBlob)
|
|
return;
|
|
if (stageType === "commit")
|
|
return null;
|
|
if ((stageType === "tree" || stageType === "special") && !isBlob)
|
|
return;
|
|
const headOid = headType === "blob" ? await head.oid() : void 0;
|
|
const stageOid = stageType === "blob" ? await stage.oid() : void 0;
|
|
let workdirOid;
|
|
if (headType !== "blob" && workdirType === "blob" && stageType !== "blob") {
|
|
workdirOid = "42";
|
|
} else if (workdirType === "blob") {
|
|
workdirOid = await workdir.oid();
|
|
}
|
|
const entry = [void 0, headOid, workdirOid, stageOid];
|
|
const result = entry.map((value) => entry.indexOf(value));
|
|
result.shift();
|
|
return [filepath, ...result];
|
|
}
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.statusMatrix";
|
|
throw err;
|
|
}
|
|
}
|
|
async function tag({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
object,
|
|
force = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
const fs = new FileSystem(_fs);
|
|
if (ref === void 0) {
|
|
throw new MissingParameterError("ref");
|
|
}
|
|
ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`;
|
|
const value = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: object || "HEAD"
|
|
});
|
|
if (!force && await GitRefManager.exists({ fs, gitdir, ref })) {
|
|
throw new AlreadyExistsError("tag", ref);
|
|
}
|
|
await GitRefManager.writeRef({ fs, gitdir, ref, value });
|
|
} catch (err) {
|
|
err.caller = "git.tag";
|
|
throw err;
|
|
}
|
|
}
|
|
async function updateIndex({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
cache = {},
|
|
filepath,
|
|
oid,
|
|
mode,
|
|
add: add2,
|
|
remove: remove3,
|
|
force
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("filepath", filepath);
|
|
const fs = new FileSystem(_fs);
|
|
if (remove3) {
|
|
return await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
let fileStats2;
|
|
if (!force) {
|
|
fileStats2 = await fs.lstat(join(dir, filepath));
|
|
if (fileStats2) {
|
|
if (fileStats2.isDirectory()) {
|
|
throw new InvalidFilepathError("directory");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (index2.has({ filepath })) {
|
|
index2.delete({
|
|
filepath
|
|
});
|
|
}
|
|
});
|
|
}
|
|
let fileStats;
|
|
if (!oid) {
|
|
fileStats = await fs.lstat(join(dir, filepath));
|
|
if (!fileStats) {
|
|
throw new NotFoundError(`file at "${filepath}" on disk and "remove" not set`);
|
|
}
|
|
if (fileStats.isDirectory()) {
|
|
throw new InvalidFilepathError("directory");
|
|
}
|
|
}
|
|
return await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) {
|
|
if (!add2 && !index2.has({ filepath })) {
|
|
throw new NotFoundError(`file at "${filepath}" in index and "add" not set`);
|
|
}
|
|
let stats = {
|
|
ctime: new Date(0),
|
|
mtime: new Date(0),
|
|
dev: 0,
|
|
ino: 0,
|
|
mode,
|
|
uid: 0,
|
|
gid: 0,
|
|
size: 0
|
|
};
|
|
if (!oid) {
|
|
stats = fileStats;
|
|
const object = stats.isSymbolicLink() ? await fs.readlink(join(dir, filepath)) : await fs.read(join(dir, filepath));
|
|
oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "blob",
|
|
format: "content",
|
|
object
|
|
});
|
|
}
|
|
index2.insert({
|
|
filepath,
|
|
oid,
|
|
stats
|
|
});
|
|
return oid;
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.updateIndex";
|
|
throw err;
|
|
}
|
|
}
|
|
function version() {
|
|
try {
|
|
return pkg.version;
|
|
} catch (err) {
|
|
err.caller = "git.version";
|
|
throw err;
|
|
}
|
|
}
|
|
async function walk({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
trees,
|
|
map,
|
|
reduce,
|
|
iterate,
|
|
cache = {}
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("trees", trees);
|
|
return await _walk({
|
|
fs: new FileSystem(fs),
|
|
cache,
|
|
dir,
|
|
gitdir,
|
|
trees,
|
|
map,
|
|
reduce,
|
|
iterate
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.walk";
|
|
throw err;
|
|
}
|
|
}
|
|
async function writeBlob({ fs, dir, gitdir = join(dir, ".git"), blob }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("blob", blob);
|
|
return await _writeObject({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
type: "blob",
|
|
object: blob,
|
|
format: "content"
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.writeBlob";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _writeCommit({ fs, gitdir, commit: commit2 }) {
|
|
const object = GitCommit.from(commit2).toObject();
|
|
const oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "commit",
|
|
object,
|
|
format: "content"
|
|
});
|
|
return oid;
|
|
}
|
|
async function writeCommit({
|
|
fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
commit: commit2
|
|
}) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("commit", commit2);
|
|
return await _writeCommit({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
commit: commit2
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.writeCommit";
|
|
throw err;
|
|
}
|
|
}
|
|
async function writeObject({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
type,
|
|
object,
|
|
format = "parsed",
|
|
oid,
|
|
encoding = void 0
|
|
}) {
|
|
try {
|
|
const fs = new FileSystem(_fs);
|
|
if (format === "parsed") {
|
|
switch (type) {
|
|
case "commit":
|
|
object = GitCommit.from(object).toObject();
|
|
break;
|
|
case "tree":
|
|
object = GitTree.from(object).toObject();
|
|
break;
|
|
case "blob":
|
|
object = Buffer2.from(object, encoding);
|
|
break;
|
|
case "tag":
|
|
object = GitAnnotatedTag.from(object).toObject();
|
|
break;
|
|
default:
|
|
throw new ObjectTypeError(oid || "", type, "blob|commit|tag|tree");
|
|
}
|
|
format = "content";
|
|
}
|
|
oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type,
|
|
object,
|
|
oid,
|
|
format
|
|
});
|
|
return oid;
|
|
} catch (err) {
|
|
err.caller = "git.writeObject";
|
|
throw err;
|
|
}
|
|
}
|
|
async function writeRef({
|
|
fs: _fs,
|
|
dir,
|
|
gitdir = join(dir, ".git"),
|
|
ref,
|
|
value,
|
|
force = false,
|
|
symbolic = false
|
|
}) {
|
|
try {
|
|
assertParameter("fs", _fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("ref", ref);
|
|
assertParameter("value", value);
|
|
const fs = new FileSystem(_fs);
|
|
if (ref !== import_clean_git_ref.default.clean(ref)) {
|
|
throw new InvalidRefNameError(ref, import_clean_git_ref.default.clean(ref));
|
|
}
|
|
if (!force && await GitRefManager.exists({ fs, gitdir, ref })) {
|
|
throw new AlreadyExistsError("ref", ref);
|
|
}
|
|
if (symbolic) {
|
|
await GitRefManager.writeSymbolicRef({
|
|
fs,
|
|
gitdir,
|
|
ref,
|
|
value
|
|
});
|
|
} else {
|
|
value = await GitRefManager.resolve({
|
|
fs,
|
|
gitdir,
|
|
ref: value
|
|
});
|
|
await GitRefManager.writeRef({
|
|
fs,
|
|
gitdir,
|
|
ref,
|
|
value
|
|
});
|
|
}
|
|
} catch (err) {
|
|
err.caller = "git.writeRef";
|
|
throw err;
|
|
}
|
|
}
|
|
async function _writeTag({ fs, gitdir, tag: tag2 }) {
|
|
const object = GitAnnotatedTag.from(tag2).toObject();
|
|
const oid = await _writeObject({
|
|
fs,
|
|
gitdir,
|
|
type: "tag",
|
|
object,
|
|
format: "content"
|
|
});
|
|
return oid;
|
|
}
|
|
async function writeTag({ fs, dir, gitdir = join(dir, ".git"), tag: tag2 }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("tag", tag2);
|
|
return await _writeTag({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
tag: tag2
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.writeTag";
|
|
throw err;
|
|
}
|
|
}
|
|
async function writeTree({ fs, dir, gitdir = join(dir, ".git"), tree }) {
|
|
try {
|
|
assertParameter("fs", fs);
|
|
assertParameter("gitdir", gitdir);
|
|
assertParameter("tree", tree);
|
|
return await _writeTree({
|
|
fs: new FileSystem(fs),
|
|
gitdir,
|
|
tree
|
|
});
|
|
} catch (err) {
|
|
err.caller = "git.writeTree";
|
|
throw err;
|
|
}
|
|
}
|
|
var index = {
|
|
Errors,
|
|
STAGE,
|
|
TREE,
|
|
WORKDIR,
|
|
add,
|
|
addNote,
|
|
addRemote,
|
|
annotatedTag,
|
|
branch,
|
|
checkout,
|
|
clone,
|
|
commit,
|
|
getConfig,
|
|
getConfigAll,
|
|
setConfig,
|
|
currentBranch,
|
|
deleteBranch,
|
|
deleteRef,
|
|
deleteRemote,
|
|
deleteTag,
|
|
expandOid,
|
|
expandRef,
|
|
fastForward,
|
|
fetch,
|
|
findMergeBase,
|
|
findRoot,
|
|
getRemoteInfo,
|
|
getRemoteInfo2,
|
|
hashBlob,
|
|
indexPack,
|
|
init,
|
|
isDescendent,
|
|
isIgnored,
|
|
listBranches,
|
|
listFiles,
|
|
listNotes,
|
|
listRemotes,
|
|
listServerRefs,
|
|
listTags,
|
|
log,
|
|
merge,
|
|
packObjects,
|
|
pull,
|
|
push,
|
|
readBlob,
|
|
readCommit,
|
|
readNote,
|
|
readObject,
|
|
readTag,
|
|
readTree,
|
|
remove,
|
|
removeNote,
|
|
renameBranch,
|
|
resetIndex,
|
|
updateIndex,
|
|
resolveRef,
|
|
status,
|
|
statusMatrix,
|
|
tag,
|
|
version,
|
|
walk,
|
|
writeBlob,
|
|
writeCommit,
|
|
writeObject,
|
|
writeRef,
|
|
writeTag,
|
|
writeTree
|
|
};
|
|
var isomorphic_git_default = index;
|
|
|
|
// src/main.ts
|
|
var import_obsidian23 = __toModule(require("obsidian"));
|
|
|
|
// src/promiseQueue.ts
|
|
init_polyfill_buffer();
|
|
var PromiseQueue = class {
|
|
constructor() {
|
|
this.tasks = [];
|
|
}
|
|
addTask(task) {
|
|
this.tasks.push(task);
|
|
if (this.tasks.length === 1) {
|
|
this.handleTask();
|
|
}
|
|
}
|
|
async handleTask() {
|
|
if (this.tasks.length > 0) {
|
|
this.tasks[0]().finally(() => {
|
|
this.tasks.shift();
|
|
this.handleTask();
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/settings.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian7 = __toModule(require("obsidian"));
|
|
|
|
// src/isomorphicGit.ts
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/diff/lib/index.mjs
|
|
init_polyfill_buffer();
|
|
function Diff() {
|
|
}
|
|
Diff.prototype = {
|
|
diff: function diff(oldString, newString) {
|
|
var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
|
|
var callback = options.callback;
|
|
if (typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
this.options = options;
|
|
var self3 = this;
|
|
function done(value) {
|
|
if (callback) {
|
|
setTimeout(function() {
|
|
callback(void 0, value);
|
|
}, 0);
|
|
return true;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
oldString = this.castInput(oldString);
|
|
newString = this.castInput(newString);
|
|
oldString = this.removeEmpty(this.tokenize(oldString));
|
|
newString = this.removeEmpty(this.tokenize(newString));
|
|
var newLen = newString.length, oldLen = oldString.length;
|
|
var editLength = 1;
|
|
var maxEditLength = newLen + oldLen;
|
|
if (options.maxEditLength) {
|
|
maxEditLength = Math.min(maxEditLength, options.maxEditLength);
|
|
}
|
|
var bestPath = [{
|
|
newPos: -1,
|
|
components: []
|
|
}];
|
|
var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
|
|
if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
|
|
return done([{
|
|
value: this.join(newString),
|
|
count: newString.length
|
|
}]);
|
|
}
|
|
function execEditLength() {
|
|
for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
|
|
var basePath = void 0;
|
|
var addPath = bestPath[diagonalPath - 1], removePath = bestPath[diagonalPath + 1], _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
|
|
if (addPath) {
|
|
bestPath[diagonalPath - 1] = void 0;
|
|
}
|
|
var canAdd = addPath && addPath.newPos + 1 < newLen, canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
|
|
if (!canAdd && !canRemove) {
|
|
bestPath[diagonalPath] = void 0;
|
|
continue;
|
|
}
|
|
if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
|
|
basePath = clonePath(removePath);
|
|
self3.pushComponent(basePath.components, void 0, true);
|
|
} else {
|
|
basePath = addPath;
|
|
basePath.newPos++;
|
|
self3.pushComponent(basePath.components, true, void 0);
|
|
}
|
|
_oldPos = self3.extractCommon(basePath, newString, oldString, diagonalPath);
|
|
if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
|
|
return done(buildValues(self3, basePath.components, newString, oldString, self3.useLongestToken));
|
|
} else {
|
|
bestPath[diagonalPath] = basePath;
|
|
}
|
|
}
|
|
editLength++;
|
|
}
|
|
if (callback) {
|
|
(function exec() {
|
|
setTimeout(function() {
|
|
if (editLength > maxEditLength) {
|
|
return callback();
|
|
}
|
|
if (!execEditLength()) {
|
|
exec();
|
|
}
|
|
}, 0);
|
|
})();
|
|
} else {
|
|
while (editLength <= maxEditLength) {
|
|
var ret = execEditLength();
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
pushComponent: function pushComponent(components, added, removed) {
|
|
var last2 = components[components.length - 1];
|
|
if (last2 && last2.added === added && last2.removed === removed) {
|
|
components[components.length - 1] = {
|
|
count: last2.count + 1,
|
|
added,
|
|
removed
|
|
};
|
|
} else {
|
|
components.push({
|
|
count: 1,
|
|
added,
|
|
removed
|
|
});
|
|
}
|
|
},
|
|
extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
|
|
var newLen = newString.length, oldLen = oldString.length, newPos = basePath.newPos, oldPos = newPos - diagonalPath, commonCount = 0;
|
|
while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
|
|
newPos++;
|
|
oldPos++;
|
|
commonCount++;
|
|
}
|
|
if (commonCount) {
|
|
basePath.components.push({
|
|
count: commonCount
|
|
});
|
|
}
|
|
basePath.newPos = newPos;
|
|
return oldPos;
|
|
},
|
|
equals: function equals(left, right) {
|
|
if (this.options.comparator) {
|
|
return this.options.comparator(left, right);
|
|
} else {
|
|
return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
|
|
}
|
|
},
|
|
removeEmpty: function removeEmpty(array) {
|
|
var ret = [];
|
|
for (var i = 0; i < array.length; i++) {
|
|
if (array[i]) {
|
|
ret.push(array[i]);
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
castInput: function castInput(value) {
|
|
return value;
|
|
},
|
|
tokenize: function tokenize(value) {
|
|
return value.split("");
|
|
},
|
|
join: function join2(chars) {
|
|
return chars.join("");
|
|
}
|
|
};
|
|
function buildValues(diff2, components, newString, oldString, useLongestToken) {
|
|
var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
|
|
for (; componentPos < componentLen; componentPos++) {
|
|
var component = components[componentPos];
|
|
if (!component.removed) {
|
|
if (!component.added && useLongestToken) {
|
|
var value = newString.slice(newPos, newPos + component.count);
|
|
value = value.map(function(value2, i) {
|
|
var oldValue = oldString[oldPos + i];
|
|
return oldValue.length > value2.length ? oldValue : value2;
|
|
});
|
|
component.value = diff2.join(value);
|
|
} else {
|
|
component.value = diff2.join(newString.slice(newPos, newPos + component.count));
|
|
}
|
|
newPos += component.count;
|
|
if (!component.added) {
|
|
oldPos += component.count;
|
|
}
|
|
} else {
|
|
component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
|
|
oldPos += component.count;
|
|
if (componentPos && components[componentPos - 1].added) {
|
|
var tmp = components[componentPos - 1];
|
|
components[componentPos - 1] = components[componentPos];
|
|
components[componentPos] = tmp;
|
|
}
|
|
}
|
|
}
|
|
var lastComponent = components[componentLen - 1];
|
|
if (componentLen > 1 && typeof lastComponent.value === "string" && (lastComponent.added || lastComponent.removed) && diff2.equals("", lastComponent.value)) {
|
|
components[componentLen - 2].value += lastComponent.value;
|
|
components.pop();
|
|
}
|
|
return components;
|
|
}
|
|
function clonePath(path2) {
|
|
return {
|
|
newPos: path2.newPos,
|
|
components: path2.components.slice(0)
|
|
};
|
|
}
|
|
var characterDiff = new Diff();
|
|
function diffChars(oldStr, newStr, options) {
|
|
return characterDiff.diff(oldStr, newStr, options);
|
|
}
|
|
var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
|
|
var reWhitespace = /\S/;
|
|
var wordDiff = new Diff();
|
|
wordDiff.equals = function(left, right) {
|
|
if (this.options.ignoreCase) {
|
|
left = left.toLowerCase();
|
|
right = right.toLowerCase();
|
|
}
|
|
return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
|
|
};
|
|
wordDiff.tokenize = function(value) {
|
|
var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
|
|
for (var i = 0; i < tokens.length - 1; i++) {
|
|
if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
|
|
tokens[i] += tokens[i + 2];
|
|
tokens.splice(i + 1, 2);
|
|
i--;
|
|
}
|
|
}
|
|
return tokens;
|
|
};
|
|
function diffWordsWithSpace(oldStr, newStr, options) {
|
|
return wordDiff.diff(oldStr, newStr, options);
|
|
}
|
|
var lineDiff = new Diff();
|
|
lineDiff.tokenize = function(value) {
|
|
var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
|
|
if (!linesAndNewlines[linesAndNewlines.length - 1]) {
|
|
linesAndNewlines.pop();
|
|
}
|
|
for (var i = 0; i < linesAndNewlines.length; i++) {
|
|
var line = linesAndNewlines[i];
|
|
if (i % 2 && !this.options.newlineIsToken) {
|
|
retLines[retLines.length - 1] += line;
|
|
} else {
|
|
if (this.options.ignoreWhitespace) {
|
|
line = line.trim();
|
|
}
|
|
retLines.push(line);
|
|
}
|
|
}
|
|
return retLines;
|
|
};
|
|
function diffLines(oldStr, newStr, callback) {
|
|
return lineDiff.diff(oldStr, newStr, callback);
|
|
}
|
|
var sentenceDiff = new Diff();
|
|
sentenceDiff.tokenize = function(value) {
|
|
return value.split(/(\S.+?[.!?])(?=\s+|$)/);
|
|
};
|
|
var cssDiff = new Diff();
|
|
cssDiff.tokenize = function(value) {
|
|
return value.split(/([{}:;,]|\s+)/);
|
|
};
|
|
function _typeof(obj) {
|
|
"@babel/helpers - typeof";
|
|
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
|
_typeof = function(obj2) {
|
|
return typeof obj2;
|
|
};
|
|
} else {
|
|
_typeof = function(obj2) {
|
|
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
|
|
};
|
|
}
|
|
return _typeof(obj);
|
|
}
|
|
function _toConsumableArray(arr) {
|
|
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
|
|
}
|
|
function _arrayWithoutHoles(arr) {
|
|
if (Array.isArray(arr))
|
|
return _arrayLikeToArray(arr);
|
|
}
|
|
function _iterableToArray(iter) {
|
|
if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
|
|
return Array.from(iter);
|
|
}
|
|
function _unsupportedIterableToArray(o, minLen) {
|
|
if (!o)
|
|
return;
|
|
if (typeof o === "string")
|
|
return _arrayLikeToArray(o, minLen);
|
|
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
if (n === "Object" && o.constructor)
|
|
n = o.constructor.name;
|
|
if (n === "Map" || n === "Set")
|
|
return Array.from(o);
|
|
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
|
|
return _arrayLikeToArray(o, minLen);
|
|
}
|
|
function _arrayLikeToArray(arr, len) {
|
|
if (len == null || len > arr.length)
|
|
len = arr.length;
|
|
for (var i = 0, arr2 = new Array(len); i < len; i++)
|
|
arr2[i] = arr[i];
|
|
return arr2;
|
|
}
|
|
function _nonIterableSpread() {
|
|
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
var objectPrototypeToString = Object.prototype.toString;
|
|
var jsonDiff = new Diff();
|
|
jsonDiff.useLongestToken = true;
|
|
jsonDiff.tokenize = lineDiff.tokenize;
|
|
jsonDiff.castInput = function(value) {
|
|
var _this$options = this.options, undefinedReplacement = _this$options.undefinedReplacement, _this$options$stringi = _this$options.stringifyReplacer, stringifyReplacer = _this$options$stringi === void 0 ? function(k, v) {
|
|
return typeof v === "undefined" ? undefinedReplacement : v;
|
|
} : _this$options$stringi;
|
|
return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, " ");
|
|
};
|
|
jsonDiff.equals = function(left, right) {
|
|
return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"));
|
|
};
|
|
function canonicalize(obj, stack, replacementStack, replacer, key2) {
|
|
stack = stack || [];
|
|
replacementStack = replacementStack || [];
|
|
if (replacer) {
|
|
obj = replacer(key2, obj);
|
|
}
|
|
var i;
|
|
for (i = 0; i < stack.length; i += 1) {
|
|
if (stack[i] === obj) {
|
|
return replacementStack[i];
|
|
}
|
|
}
|
|
var canonicalizedObj;
|
|
if (objectPrototypeToString.call(obj) === "[object Array]") {
|
|
stack.push(obj);
|
|
canonicalizedObj = new Array(obj.length);
|
|
replacementStack.push(canonicalizedObj);
|
|
for (i = 0; i < obj.length; i += 1) {
|
|
canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key2);
|
|
}
|
|
stack.pop();
|
|
replacementStack.pop();
|
|
return canonicalizedObj;
|
|
}
|
|
if (obj && obj.toJSON) {
|
|
obj = obj.toJSON();
|
|
}
|
|
if (_typeof(obj) === "object" && obj !== null) {
|
|
stack.push(obj);
|
|
canonicalizedObj = {};
|
|
replacementStack.push(canonicalizedObj);
|
|
var sortedKeys = [], _key;
|
|
for (_key in obj) {
|
|
if (obj.hasOwnProperty(_key)) {
|
|
sortedKeys.push(_key);
|
|
}
|
|
}
|
|
sortedKeys.sort();
|
|
for (i = 0; i < sortedKeys.length; i += 1) {
|
|
_key = sortedKeys[i];
|
|
canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
|
|
}
|
|
stack.pop();
|
|
replacementStack.pop();
|
|
} else {
|
|
canonicalizedObj = obj;
|
|
}
|
|
return canonicalizedObj;
|
|
}
|
|
var arrayDiff = new Diff();
|
|
arrayDiff.tokenize = function(value) {
|
|
return value.slice();
|
|
};
|
|
arrayDiff.join = arrayDiff.removeEmpty = function(value) {
|
|
return value;
|
|
};
|
|
function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
if (typeof options.context === "undefined") {
|
|
options.context = 4;
|
|
}
|
|
var diff2 = diffLines(oldStr, newStr, options);
|
|
if (!diff2) {
|
|
return;
|
|
}
|
|
diff2.push({
|
|
value: "",
|
|
lines: []
|
|
});
|
|
function contextLines(lines) {
|
|
return lines.map(function(entry) {
|
|
return " " + entry;
|
|
});
|
|
}
|
|
var hunks = [];
|
|
var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
|
|
var _loop = function _loop2(i2) {
|
|
var current = diff2[i2], lines = current.lines || current.value.replace(/\n$/, "").split("\n");
|
|
current.lines = lines;
|
|
if (current.added || current.removed) {
|
|
var _curRange;
|
|
if (!oldRangeStart) {
|
|
var prev = diff2[i2 - 1];
|
|
oldRangeStart = oldLine;
|
|
newRangeStart = newLine;
|
|
if (prev) {
|
|
curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
|
|
oldRangeStart -= curRange.length;
|
|
newRangeStart -= curRange.length;
|
|
}
|
|
}
|
|
(_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function(entry) {
|
|
return (current.added ? "+" : "-") + entry;
|
|
})));
|
|
if (current.added) {
|
|
newLine += lines.length;
|
|
} else {
|
|
oldLine += lines.length;
|
|
}
|
|
} else {
|
|
if (oldRangeStart) {
|
|
if (lines.length <= options.context * 2 && i2 < diff2.length - 2) {
|
|
var _curRange2;
|
|
(_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));
|
|
} else {
|
|
var _curRange3;
|
|
var contextSize = Math.min(lines.length, options.context);
|
|
(_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));
|
|
var hunk = {
|
|
oldStart: oldRangeStart,
|
|
oldLines: oldLine - oldRangeStart + contextSize,
|
|
newStart: newRangeStart,
|
|
newLines: newLine - newRangeStart + contextSize,
|
|
lines: curRange
|
|
};
|
|
if (i2 >= diff2.length - 2 && lines.length <= options.context) {
|
|
var oldEOFNewline = /\n$/.test(oldStr);
|
|
var newEOFNewline = /\n$/.test(newStr);
|
|
var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
|
|
if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) {
|
|
curRange.splice(hunk.oldLines, 0, "\\ No newline at end of file");
|
|
}
|
|
if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {
|
|
curRange.push("\\ No newline at end of file");
|
|
}
|
|
}
|
|
hunks.push(hunk);
|
|
oldRangeStart = 0;
|
|
newRangeStart = 0;
|
|
curRange = [];
|
|
}
|
|
}
|
|
oldLine += lines.length;
|
|
newLine += lines.length;
|
|
}
|
|
};
|
|
for (var i = 0; i < diff2.length; i++) {
|
|
_loop(i);
|
|
}
|
|
return {
|
|
oldFileName,
|
|
newFileName,
|
|
oldHeader,
|
|
newHeader,
|
|
hunks
|
|
};
|
|
}
|
|
function formatPatch(diff2) {
|
|
var ret = [];
|
|
if (diff2.oldFileName == diff2.newFileName) {
|
|
ret.push("Index: " + diff2.oldFileName);
|
|
}
|
|
ret.push("===================================================================");
|
|
ret.push("--- " + diff2.oldFileName + (typeof diff2.oldHeader === "undefined" ? "" : " " + diff2.oldHeader));
|
|
ret.push("+++ " + diff2.newFileName + (typeof diff2.newHeader === "undefined" ? "" : " " + diff2.newHeader));
|
|
for (var i = 0; i < diff2.hunks.length; i++) {
|
|
var hunk = diff2.hunks[i];
|
|
if (hunk.oldLines === 0) {
|
|
hunk.oldStart -= 1;
|
|
}
|
|
if (hunk.newLines === 0) {
|
|
hunk.newStart -= 1;
|
|
}
|
|
ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
|
|
ret.push.apply(ret, hunk.lines);
|
|
}
|
|
return ret.join("\n") + "\n";
|
|
}
|
|
function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
|
|
return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));
|
|
}
|
|
function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
|
|
return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
|
|
}
|
|
|
|
// src/isomorphicGit.ts
|
|
var import_obsidian5 = __toModule(require("obsidian"));
|
|
|
|
// src/gitManager.ts
|
|
init_polyfill_buffer();
|
|
var GitManager = class {
|
|
constructor(plugin) {
|
|
this.plugin = plugin;
|
|
this.app = plugin.app;
|
|
}
|
|
getVaultPath(path2) {
|
|
if (this.plugin.settings.basePath) {
|
|
return this.plugin.settings.basePath + "/" + path2;
|
|
} else {
|
|
return path2;
|
|
}
|
|
}
|
|
getPath(path2, relativeToVault) {
|
|
return relativeToVault && this.plugin.settings.basePath.length > 0 ? path2.substring(this.plugin.settings.basePath.length + 1) : path2;
|
|
}
|
|
_getTreeStructure(children2, beginLength = 0) {
|
|
const list = [];
|
|
children2 = [...children2];
|
|
while (children2.length > 0) {
|
|
const first2 = children2.first();
|
|
const restPath = first2.path.substring(beginLength);
|
|
if (restPath.contains("/")) {
|
|
const title = restPath.substring(0, restPath.indexOf("/"));
|
|
const childrenWithSameTitle = children2.filter((item) => {
|
|
return item.path.substring(beginLength).startsWith(title + "/");
|
|
});
|
|
childrenWithSameTitle.forEach((item) => children2.remove(item));
|
|
list.push({
|
|
title,
|
|
path: first2.path.substring(0, restPath.indexOf("/") + beginLength),
|
|
children: this._getTreeStructure(childrenWithSameTitle, (beginLength > 0 ? beginLength + title.length : title.length) + 1)
|
|
});
|
|
} else {
|
|
list.push({ title: restPath, statusResult: first2, path: first2.path });
|
|
children2.remove(first2);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
simplify(tree) {
|
|
var _a2, _b, _c, _d;
|
|
for (const node of tree) {
|
|
const singleChild = ((_a2 = node.children) == null ? void 0 : _a2.length) == 1;
|
|
const singleChildIsDir = ((_c = (_b = node.children) == null ? void 0 : _b.first()) == null ? void 0 : _c.statusResult) == void 0;
|
|
if (node.children != void 0 && singleChild && singleChildIsDir) {
|
|
node.title += "/" + node.children.first().title;
|
|
node.path = node.children.first().path;
|
|
node.children = node.children.first().children;
|
|
} else if (node.children != void 0) {
|
|
this.simplify(node.children);
|
|
}
|
|
(_d = node.children) == null ? void 0 : _d.sort((a, b) => {
|
|
const dirCompare = (b.statusResult == void 0 ? 1 : 0) - (a.statusResult == void 0 ? 1 : 0);
|
|
if (dirCompare != 0) {
|
|
return dirCompare;
|
|
} else {
|
|
return a.title.localeCompare(b.title);
|
|
}
|
|
});
|
|
}
|
|
return tree.sort((a, b) => {
|
|
const dirCompare = (b.statusResult == void 0 ? 1 : 0) - (a.statusResult == void 0 ? 1 : 0);
|
|
if (dirCompare != 0) {
|
|
return dirCompare;
|
|
} else {
|
|
return a.title.localeCompare(b.title);
|
|
}
|
|
});
|
|
}
|
|
getTreeStructure(children2) {
|
|
const tree = this._getTreeStructure(children2);
|
|
const res = this.simplify(tree);
|
|
return res;
|
|
}
|
|
async formatCommitMessage(template) {
|
|
let status2;
|
|
if (template.includes("{{numFiles}}")) {
|
|
status2 = await this.status();
|
|
const numFiles = status2.staged.length;
|
|
template = template.replace("{{numFiles}}", String(numFiles));
|
|
}
|
|
if (template.includes("{{hostname}}")) {
|
|
const hostname = this.plugin.localStorage.getHostname() || "";
|
|
template = template.replace("{{hostname}}", hostname);
|
|
}
|
|
if (template.includes("{{files}}")) {
|
|
status2 = status2 != null ? status2 : await this.status();
|
|
const changeset = {};
|
|
status2.staged.forEach((value) => {
|
|
if (value.index in changeset) {
|
|
changeset[value.index].push(value.path);
|
|
} else {
|
|
changeset[value.index] = [value.path];
|
|
}
|
|
});
|
|
const chunks = [];
|
|
for (const [action, files2] of Object.entries(changeset)) {
|
|
chunks.push(action + " " + files2.join(" "));
|
|
}
|
|
const files = chunks.join(", ");
|
|
template = template.replace("{{files}}", files);
|
|
}
|
|
const moment = window.moment;
|
|
template = template.replace("{{date}}", moment().format(this.plugin.settings.commitDateFormat));
|
|
if (this.plugin.settings.listChangedFilesInMessageBody) {
|
|
template = template + "\n\nAffected files:\n" + (status2 != null ? status2 : await this.status()).staged.map((e) => e.path).join("\n");
|
|
}
|
|
return template;
|
|
}
|
|
};
|
|
|
|
// src/myAdapter.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian2 = __toModule(require("obsidian"));
|
|
var MyAdapter = class {
|
|
constructor(vault, plugin) {
|
|
this.plugin = plugin;
|
|
this.promises = {};
|
|
this.adapter = vault.adapter;
|
|
this.vault = vault;
|
|
this.promises.readFile = this.readFile.bind(this);
|
|
this.promises.writeFile = this.writeFile.bind(this);
|
|
this.promises.readdir = this.readdir.bind(this);
|
|
this.promises.mkdir = this.mkdir.bind(this);
|
|
this.promises.rmdir = this.rmdir.bind(this);
|
|
this.promises.stat = this.stat.bind(this);
|
|
this.promises.unlink = this.unlink.bind(this);
|
|
this.promises.lstat = this.lstat.bind(this);
|
|
this.promises.readlink = this.readlink.bind(this);
|
|
this.promises.symlink = this.symlink.bind(this);
|
|
}
|
|
async readFile(path2, opts) {
|
|
var _a2;
|
|
this.maybeLog("Read: " + path2 + JSON.stringify(opts));
|
|
if (opts == "utf8" || opts.encoding == "utf8") {
|
|
const file = this.vault.getAbstractFileByPath(path2);
|
|
if (file instanceof import_obsidian2.TFile) {
|
|
this.maybeLog("Reuse");
|
|
return this.vault.read(file);
|
|
} else {
|
|
return this.adapter.read(path2);
|
|
}
|
|
} else {
|
|
if (path2.endsWith(".git/index")) {
|
|
return (_a2 = this.index) != null ? _a2 : this.adapter.readBinary(path2);
|
|
}
|
|
const file = this.vault.getAbstractFileByPath(path2);
|
|
if (file instanceof import_obsidian2.TFile) {
|
|
this.maybeLog("Reuse");
|
|
return this.vault.readBinary(file);
|
|
} else {
|
|
return this.adapter.readBinary(path2);
|
|
}
|
|
}
|
|
}
|
|
async writeFile(path2, data) {
|
|
this.maybeLog("Write: " + path2);
|
|
if (typeof data === "string") {
|
|
const file = this.vault.getAbstractFileByPath(path2);
|
|
if (file instanceof import_obsidian2.TFile) {
|
|
return this.vault.modify(file, data);
|
|
} else {
|
|
return this.adapter.write(path2, data);
|
|
}
|
|
} else {
|
|
if (path2.endsWith(".git/index")) {
|
|
this.index = data;
|
|
this.indexmtime = Date.now();
|
|
} else {
|
|
const file = this.vault.getAbstractFileByPath(path2);
|
|
if (file instanceof import_obsidian2.TFile) {
|
|
return this.vault.modifyBinary(file, data);
|
|
} else {
|
|
return this.adapter.writeBinary(path2, data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async readdir(path2) {
|
|
if (path2 === ".")
|
|
path2 = "/";
|
|
const res = await this.adapter.list(path2);
|
|
const all = [...res.files, ...res.folders];
|
|
let formattedAll;
|
|
if (path2 !== "/") {
|
|
formattedAll = all.map((e) => (0, import_obsidian2.normalizePath)(e.substring(path2.length)));
|
|
} else {
|
|
formattedAll = all;
|
|
}
|
|
return formattedAll;
|
|
}
|
|
async mkdir(path2) {
|
|
return this.adapter.mkdir(path2);
|
|
}
|
|
async rmdir(path2, opts) {
|
|
var _a2, _b;
|
|
return this.adapter.rmdir(path2, (_b = (_a2 = opts == null ? void 0 : opts.options) == null ? void 0 : _a2.recursive) != null ? _b : false);
|
|
}
|
|
async stat(path2) {
|
|
if (path2.endsWith(".git/index")) {
|
|
if (this.index !== void 0 && this.indexctime != void 0 && this.indexmtime != void 0) {
|
|
return {
|
|
isFile: () => true,
|
|
isDirectory: () => false,
|
|
isSymbolicLink: () => false,
|
|
size: this.index.length,
|
|
type: "file",
|
|
ctimeMs: this.indexctime,
|
|
mtimeMs: this.indexmtime
|
|
};
|
|
} else {
|
|
const stat = await this.adapter.stat(path2);
|
|
if (stat == void 0) {
|
|
throw { "code": "ENOENT" };
|
|
}
|
|
this.indexctime = stat.ctime;
|
|
this.indexmtime = stat.mtime;
|
|
return {
|
|
ctimeMs: stat.ctime,
|
|
mtimeMs: stat.mtime,
|
|
size: stat.size,
|
|
type: "file",
|
|
isFile: () => true,
|
|
isDirectory: () => false,
|
|
isSymbolicLink: () => false
|
|
};
|
|
}
|
|
}
|
|
if (path2 === ".")
|
|
path2 = "/";
|
|
const file = this.vault.getAbstractFileByPath(path2);
|
|
this.maybeLog("Stat: " + path2);
|
|
if (file instanceof import_obsidian2.TFile) {
|
|
this.maybeLog("Reuse stat");
|
|
return {
|
|
ctimeMs: file.stat.ctime,
|
|
mtimeMs: file.stat.mtime,
|
|
size: file.stat.size,
|
|
type: "file",
|
|
isFile: () => true,
|
|
isDirectory: () => false,
|
|
isSymbolicLink: () => false
|
|
};
|
|
} else {
|
|
const stat = await this.adapter.stat(path2);
|
|
if (stat) {
|
|
return {
|
|
ctimeMs: stat.ctime,
|
|
mtimeMs: stat.mtime,
|
|
size: stat.size,
|
|
type: stat.type === "folder" ? "directory" : stat.type,
|
|
isFile: () => stat.type === "file",
|
|
isDirectory: () => stat.type === "folder",
|
|
isSymbolicLink: () => false
|
|
};
|
|
} else {
|
|
throw { "code": "ENOENT" };
|
|
}
|
|
}
|
|
}
|
|
async unlink(path2) {
|
|
return this.adapter.remove(path2);
|
|
}
|
|
async lstat(path2) {
|
|
return this.stat(path2);
|
|
}
|
|
async readlink(path2) {
|
|
throw new Error(`readlink of (${path2}) is not implemented.`);
|
|
}
|
|
async symlink(path2) {
|
|
throw new Error(`symlink of (${path2}) is not implemented.`);
|
|
}
|
|
async saveAndClear() {
|
|
if (this.index !== void 0) {
|
|
await this.adapter.writeBinary(this.plugin.gitManager.getVaultPath(".git/index"), this.index, {
|
|
ctime: this.indexctime,
|
|
mtime: this.indexmtime
|
|
});
|
|
}
|
|
this.index = void 0;
|
|
this.indexctime = void 0;
|
|
this.indexmtime = void 0;
|
|
}
|
|
maybeLog(text2) {
|
|
}
|
|
};
|
|
|
|
// src/types.ts
|
|
init_polyfill_buffer();
|
|
var PluginState;
|
|
(function(PluginState2) {
|
|
PluginState2[PluginState2["idle"] = 0] = "idle";
|
|
PluginState2[PluginState2["status"] = 1] = "status";
|
|
PluginState2[PluginState2["pull"] = 2] = "pull";
|
|
PluginState2[PluginState2["add"] = 3] = "add";
|
|
PluginState2[PluginState2["commit"] = 4] = "commit";
|
|
PluginState2[PluginState2["push"] = 5] = "push";
|
|
PluginState2[PluginState2["conflicted"] = 6] = "conflicted";
|
|
})(PluginState || (PluginState = {}));
|
|
var FileType;
|
|
(function(FileType2) {
|
|
FileType2[FileType2["staged"] = 0] = "staged";
|
|
FileType2[FileType2["changed"] = 1] = "changed";
|
|
FileType2[FileType2["pulled"] = 2] = "pulled";
|
|
})(FileType || (FileType = {}));
|
|
|
|
// src/ui/modals/generalModal.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian3 = __toModule(require("obsidian"));
|
|
var generalModalConfigDefaults = {
|
|
options: [],
|
|
placeholder: "",
|
|
allowEmpty: false,
|
|
onlySelection: false,
|
|
initialValue: void 0
|
|
};
|
|
var GeneralModal = class extends import_obsidian3.SuggestModal {
|
|
constructor(config) {
|
|
super(app);
|
|
this.config = { ...generalModalConfigDefaults, ...config };
|
|
this.setPlaceholder(this.config.placeholder);
|
|
}
|
|
open() {
|
|
super.open();
|
|
if (this.config.initialValue != void 0) {
|
|
this.inputEl.value = this.config.initialValue;
|
|
this.inputEl.dispatchEvent(new Event("input"));
|
|
}
|
|
return new Promise((resolve) => {
|
|
this.resolve = resolve;
|
|
});
|
|
}
|
|
selectSuggestion(value, evt) {
|
|
if (this.resolve) {
|
|
let res;
|
|
if (this.config.allowEmpty && value === " ")
|
|
res = "";
|
|
else if (value === "...")
|
|
res = void 0;
|
|
else
|
|
res = value;
|
|
this.resolve(res);
|
|
}
|
|
super.selectSuggestion(value, evt);
|
|
}
|
|
onClose() {
|
|
if (this.resolve)
|
|
this.resolve(void 0);
|
|
}
|
|
getSuggestions(query) {
|
|
if (this.config.onlySelection) {
|
|
return this.config.options;
|
|
} else if (this.config.allowEmpty) {
|
|
return [query.length > 0 ? query : " ", ...this.config.options];
|
|
} else {
|
|
return [query.length > 0 ? query : "...", ...this.config.options];
|
|
}
|
|
}
|
|
renderSuggestion(value, el) {
|
|
el.setText(value);
|
|
}
|
|
onChooseSuggestion(item, evt) {
|
|
}
|
|
};
|
|
|
|
// src/utils.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian4 = __toModule(require("obsidian"));
|
|
var worthWalking2 = (filepath, root) => {
|
|
if (filepath === "." || root == null || root.length === 0 || root === ".") {
|
|
return true;
|
|
}
|
|
if (root.length >= filepath.length) {
|
|
return root.startsWith(filepath);
|
|
} else {
|
|
return filepath.startsWith(root);
|
|
}
|
|
};
|
|
function getNewLeaf(event) {
|
|
let leaf;
|
|
if (event) {
|
|
if (event.button === 0 || event.button === 1) {
|
|
const type = import_obsidian4.Keymap.isModEvent(event);
|
|
leaf = app.workspace.getLeaf(type);
|
|
}
|
|
} else {
|
|
leaf = app.workspace.getLeaf(false);
|
|
}
|
|
return leaf;
|
|
}
|
|
|
|
// src/isomorphicGit.ts
|
|
var IsomorphicGit = class extends GitManager {
|
|
constructor(plugin) {
|
|
super(plugin);
|
|
this.FILE = 0;
|
|
this.HEAD = 1;
|
|
this.WORKDIR = 2;
|
|
this.STAGE = 3;
|
|
this.status_mapping = {
|
|
"000": " ",
|
|
"003": "AD",
|
|
"020": "??",
|
|
"022": "A ",
|
|
"023": "AM",
|
|
"100": "D ",
|
|
"101": " D",
|
|
"103": "MD",
|
|
"110": "DA",
|
|
"111": " ",
|
|
"120": "DA",
|
|
"121": " M",
|
|
"122": "M ",
|
|
"123": "MM"
|
|
};
|
|
this.noticeLength = 999999;
|
|
this.fs = new MyAdapter(this.app.vault, this.plugin);
|
|
}
|
|
getRepo() {
|
|
return {
|
|
fs: this.fs,
|
|
dir: this.plugin.settings.basePath,
|
|
onAuth: () => {
|
|
var _a2;
|
|
return {
|
|
username: this.plugin.settings.username,
|
|
password: (_a2 = this.plugin.localStorage.getPassword()) != null ? _a2 : void 0
|
|
};
|
|
},
|
|
onAuthFailure: async () => {
|
|
new import_obsidian5.Notice("Authentication failed. Please try with different credentials");
|
|
const username = await new GeneralModal({ placeholder: "Specify your username" }).open();
|
|
if (username) {
|
|
const password = await new GeneralModal({ placeholder: "Specify your password/personal access token" }).open();
|
|
if (password) {
|
|
this.plugin.settings.username = username;
|
|
await this.plugin.saveSettings();
|
|
this.plugin.localStorage.setPassword(password);
|
|
return {
|
|
username,
|
|
password
|
|
};
|
|
}
|
|
}
|
|
return { cancel: true };
|
|
},
|
|
http: {
|
|
async request({
|
|
url,
|
|
method,
|
|
headers,
|
|
body
|
|
}) {
|
|
if (body) {
|
|
body = await collect2(body);
|
|
body = body.buffer;
|
|
}
|
|
const res = await (0, import_obsidian5.requestUrl)({ url, method, headers, body, throw: false });
|
|
return {
|
|
url,
|
|
method,
|
|
headers: res.headers,
|
|
body: [new Uint8Array(res.arrayBuffer)],
|
|
statusCode: res.status,
|
|
statusMessage: res.status.toString()
|
|
};
|
|
}
|
|
}
|
|
};
|
|
}
|
|
async wrapFS(call) {
|
|
try {
|
|
const res = await call;
|
|
await this.fs.saveAndClear();
|
|
return res;
|
|
} catch (error) {
|
|
await this.fs.saveAndClear();
|
|
throw error;
|
|
}
|
|
}
|
|
async status() {
|
|
const notice = new import_obsidian5.Notice("Getting status...", this.noticeLength);
|
|
try {
|
|
this.plugin.setState(PluginState.status);
|
|
const status2 = (await this.wrapFS(isomorphic_git_default.statusMatrix({ ...this.getRepo() }))).map((row) => this.getFileStatusResult(row));
|
|
const changed = status2.filter((fileStatus) => fileStatus.working_dir !== " ");
|
|
const staged = status2.filter((fileStatus) => fileStatus.index !== " " && fileStatus.index !== "U");
|
|
const conflicted = [];
|
|
notice.hide();
|
|
return { changed, staged, conflicted };
|
|
} catch (error) {
|
|
notice.hide();
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async commitAll({ message, status: status2, unstagedFiles }) {
|
|
try {
|
|
await this.stageAll({ status: status2, unstagedFiles });
|
|
return this.commit(message);
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async commit(message) {
|
|
try {
|
|
this.plugin.setState(PluginState.commit);
|
|
const formatMessage = await this.formatCommitMessage(message);
|
|
const hadConflict = this.plugin.localStorage.getConflict() === "true";
|
|
let parent = void 0;
|
|
if (hadConflict) {
|
|
const branchInfo = await this.branchInfo();
|
|
parent = [branchInfo.current, branchInfo.tracking];
|
|
}
|
|
await this.wrapFS(isomorphic_git_default.commit({
|
|
...this.getRepo(),
|
|
message: formatMessage,
|
|
parent
|
|
}));
|
|
this.plugin.localStorage.setConflict("false");
|
|
return;
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async stage(filepath, relativeToVault) {
|
|
const gitPath = this.getPath(filepath, relativeToVault);
|
|
let vaultPath;
|
|
if (relativeToVault) {
|
|
vaultPath = filepath;
|
|
} else {
|
|
vaultPath = this.getVaultPath(filepath);
|
|
}
|
|
try {
|
|
this.plugin.setState(PluginState.add);
|
|
if (await this.app.vault.adapter.exists(vaultPath)) {
|
|
await this.wrapFS(isomorphic_git_default.add({ ...this.getRepo(), filepath: gitPath }));
|
|
} else {
|
|
await this.wrapFS(isomorphic_git_default.remove({ ...this.getRepo(), filepath: gitPath }));
|
|
}
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async stageAll({ dir, status: status2, unstagedFiles }) {
|
|
try {
|
|
if (status2) {
|
|
await Promise.all(status2.changed.map((file) => file.working_dir !== "D" ? this.wrapFS(isomorphic_git_default.add({ ...this.getRepo(), filepath: file.path })) : isomorphic_git_default.remove({ ...this.getRepo(), filepath: file.path })));
|
|
} else {
|
|
const filesToStage = unstagedFiles != null ? unstagedFiles : await this.getUnstagedFiles(dir != null ? dir : ".");
|
|
await Promise.all(filesToStage.map(({ filepath, deleted }) => deleted ? isomorphic_git_default.remove({ ...this.getRepo(), filepath }) : this.wrapFS(isomorphic_git_default.add({ ...this.getRepo(), filepath }))));
|
|
}
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async unstage(filepath, relativeToVault) {
|
|
try {
|
|
this.plugin.setState(PluginState.add);
|
|
filepath = this.getPath(filepath, relativeToVault);
|
|
await this.wrapFS(isomorphic_git_default.resetIndex({ ...this.getRepo(), filepath }));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async unstageAll({ dir, status: status2 }) {
|
|
try {
|
|
let staged;
|
|
if (status2) {
|
|
staged = status2.staged.map((file) => file.path);
|
|
} else {
|
|
const res = await this.getStagedFiles(dir != null ? dir : ".");
|
|
staged = res.map(({ filepath }) => filepath);
|
|
}
|
|
await Promise.all(staged.map((file) => this.unstage(file, false)));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async discard(filepath) {
|
|
try {
|
|
this.plugin.setState(PluginState.add);
|
|
await this.wrapFS(isomorphic_git_default.checkout({ ...this.getRepo(), filepaths: [filepath], force: true }));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
getProgressText(action, event) {
|
|
let out = `${action} progress:`;
|
|
if (event.phase) {
|
|
out = `${out} ${event.phase}:`;
|
|
}
|
|
if (event.loaded) {
|
|
out = `${out} ${event.loaded}`;
|
|
if (event.total) {
|
|
out = `${out} of ${event.total}`;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
resolveRef(ref) {
|
|
return this.wrapFS(isomorphic_git_default.resolveRef({ ...this.getRepo(), ref }));
|
|
}
|
|
async pull() {
|
|
const progressNotice = new import_obsidian5.Notice("Initializing pull", this.noticeLength);
|
|
try {
|
|
this.plugin.setState(PluginState.pull);
|
|
const localCommit = await this.resolveRef("HEAD");
|
|
await this.fetch();
|
|
const branchInfo = await this.branchInfo();
|
|
await this.wrapFS(isomorphic_git_default.merge({
|
|
...this.getRepo(),
|
|
ours: branchInfo.current,
|
|
theirs: branchInfo.tracking,
|
|
abortOnConflict: false
|
|
}));
|
|
await this.wrapFS(isomorphic_git_default.checkout({
|
|
...this.getRepo(),
|
|
ref: branchInfo.current,
|
|
onProgress: (progress) => {
|
|
progressNotice.noticeEl.innerText = this.getProgressText("Checkout", progress);
|
|
},
|
|
remote: branchInfo.remote
|
|
}));
|
|
progressNotice.hide();
|
|
const upstreamCommit = await this.resolveRef("HEAD");
|
|
this.plugin.lastUpdate = Date.now();
|
|
const changedFiles = await this.getFileChangesCount(localCommit, upstreamCommit);
|
|
new import_obsidian5.Notice("Finished pull");
|
|
return changedFiles.map((file) => ({
|
|
path: file.path,
|
|
working_dir: "P",
|
|
index: "P",
|
|
vault_path: this.getVaultPath(file.path)
|
|
}));
|
|
} catch (error) {
|
|
progressNotice.hide();
|
|
if (error instanceof Errors.MergeConflictError) {
|
|
this.plugin.handleConflict(error.data.filepaths.map((file) => this.getVaultPath(file)));
|
|
}
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async push() {
|
|
if (!await this.canPush()) {
|
|
return 0;
|
|
}
|
|
const progressNotice = new import_obsidian5.Notice("Initializing push", this.noticeLength);
|
|
try {
|
|
this.plugin.setState(PluginState.status);
|
|
const status2 = await this.branchInfo();
|
|
const trackingBranch = status2.tracking;
|
|
const currentBranch2 = status2.current;
|
|
const numChangedFiles = (await this.getFileChangesCount(currentBranch2, trackingBranch)).length;
|
|
this.plugin.setState(PluginState.push);
|
|
await this.wrapFS(isomorphic_git_default.push({
|
|
...this.getRepo(),
|
|
onProgress: (progress) => {
|
|
progressNotice.noticeEl.innerText = this.getProgressText("Pushing", progress);
|
|
}
|
|
}));
|
|
progressNotice.hide();
|
|
return numChangedFiles;
|
|
} catch (error) {
|
|
progressNotice.hide();
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async canPush() {
|
|
const status2 = await this.branchInfo();
|
|
const trackingBranch = status2.tracking;
|
|
const currentBranch2 = status2.current;
|
|
const current = await this.resolveRef(currentBranch2);
|
|
const tracking = await this.resolveRef(trackingBranch);
|
|
return current != tracking;
|
|
}
|
|
async checkRequirements() {
|
|
const headExists = await this.plugin.app.vault.adapter.exists(`${this.getRepo().dir}/.git/HEAD`);
|
|
return headExists ? "valid" : "missing-repo";
|
|
}
|
|
async branchInfo() {
|
|
var _a2, _b;
|
|
try {
|
|
const current = await isomorphic_git_default.currentBranch(this.getRepo()) || "";
|
|
const branches = await isomorphic_git_default.listBranches(this.getRepo());
|
|
const remote = (_a2 = await this.getConfig(`branch.${current}.remote`)) != null ? _a2 : "origin";
|
|
const trackingBranch = (_b = await this.getConfig(`branch.${current}.merge`)) == null ? void 0 : _b.split("refs/heads")[1];
|
|
const tracking = trackingBranch ? remote + trackingBranch : void 0;
|
|
return {
|
|
current,
|
|
tracking,
|
|
branches,
|
|
remote
|
|
};
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async getCurrentRemote() {
|
|
var _a2;
|
|
const current = await isomorphic_git_default.currentBranch(this.getRepo()) || "";
|
|
const remote = (_a2 = await this.getConfig(`branch.${current}.remote`)) != null ? _a2 : "origin";
|
|
return remote;
|
|
}
|
|
async checkout(branch2) {
|
|
try {
|
|
return this.wrapFS(isomorphic_git_default.checkout({
|
|
...this.getRepo(),
|
|
ref: branch2
|
|
}));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async createBranch(branch2) {
|
|
try {
|
|
await this.wrapFS(isomorphic_git_default.branch({ ...this.getRepo(), ref: branch2, checkout: true }));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async deleteBranch(branch2) {
|
|
try {
|
|
await this.wrapFS(isomorphic_git_default.deleteBranch({ ...this.getRepo(), ref: branch2 }));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async branchIsMerged(branch2) {
|
|
return true;
|
|
}
|
|
async init() {
|
|
try {
|
|
await this.wrapFS(isomorphic_git_default.init(this.getRepo()));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async clone(url, dir) {
|
|
const progressNotice = new import_obsidian5.Notice("Initializing clone", this.noticeLength);
|
|
try {
|
|
await this.wrapFS(isomorphic_git_default.clone({
|
|
...this.getRepo(),
|
|
dir,
|
|
url,
|
|
onProgress: (progress) => {
|
|
progressNotice.noticeEl.innerText = this.getProgressText("Cloning", progress);
|
|
}
|
|
}));
|
|
progressNotice.hide();
|
|
} catch (error) {
|
|
progressNotice.hide();
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async setConfig(path2, value) {
|
|
try {
|
|
return this.wrapFS(isomorphic_git_default.setConfig({
|
|
...this.getRepo(),
|
|
path: path2,
|
|
value
|
|
}));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async getConfig(path2) {
|
|
try {
|
|
return this.wrapFS(isomorphic_git_default.getConfig({
|
|
...this.getRepo(),
|
|
path: path2
|
|
}));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async fetch(remote) {
|
|
const progressNotice = new import_obsidian5.Notice("Initializing fetch", this.noticeLength);
|
|
try {
|
|
const args = {
|
|
...this.getRepo(),
|
|
onProgress: (progress) => {
|
|
progressNotice.noticeEl.innerText = this.getProgressText("Fetching", progress);
|
|
},
|
|
remote: remote != null ? remote : await this.getCurrentRemote()
|
|
};
|
|
await this.wrapFS(isomorphic_git_default.fetch(args));
|
|
progressNotice.hide();
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
progressNotice.hide();
|
|
throw error;
|
|
}
|
|
}
|
|
async setRemote(name, url) {
|
|
try {
|
|
await this.wrapFS(isomorphic_git_default.addRemote({ ...this.getRepo(), remote: name, url }));
|
|
} catch (error) {
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async getRemoteBranches(remote) {
|
|
let remoteBranches = [];
|
|
remoteBranches.push(...await this.wrapFS(isomorphic_git_default.listBranches({ ...this.getRepo(), remote })));
|
|
remoteBranches.remove("HEAD");
|
|
remoteBranches = remoteBranches.map((e) => `${remote}/${e}`);
|
|
return remoteBranches;
|
|
}
|
|
async getRemotes() {
|
|
return (await this.wrapFS(isomorphic_git_default.listRemotes({ ...this.getRepo() }))).map((remoteUrl) => remoteUrl.remote);
|
|
}
|
|
async removeRemote(remoteName) {
|
|
await this.wrapFS(isomorphic_git_default.deleteRemote({ ...this.getRepo(), remote: remoteName }));
|
|
}
|
|
async getRemoteUrl(remote) {
|
|
return (await this.wrapFS(isomorphic_git_default.listRemotes({ ...this.getRepo() }))).filter((item) => item.remote == remote)[0].url;
|
|
}
|
|
updateBasePath(basePath) {
|
|
this.getRepo().dir = basePath;
|
|
}
|
|
async updateUpstreamBranch(remoteBranch) {
|
|
const [remote, branch2] = remoteBranch.split("/");
|
|
const branchInfo = await this.branchInfo();
|
|
await this.setConfig(`branch.${branchInfo.current}.merge`, `refs/heads/${branch2}`);
|
|
await this.setConfig(`branch.${branch2}.remote`, remote);
|
|
}
|
|
updateGitPath(gitPath) {
|
|
return;
|
|
}
|
|
async getFileChangesCount(commitHash1, commitHash2) {
|
|
return this.walkDifference({ walkers: [isomorphic_git_default.TREE({ ref: commitHash1 }), isomorphic_git_default.TREE({ ref: commitHash2 })] });
|
|
}
|
|
async walkDifference({ walkers, dir: base }) {
|
|
const res = await this.wrapFS(isomorphic_git_default.walk({
|
|
...this.getRepo(),
|
|
trees: walkers,
|
|
map: async function(filepath, [A, B]) {
|
|
if (!worthWalking2(filepath, base)) {
|
|
return null;
|
|
}
|
|
if (await (A == null ? void 0 : A.type()) === "tree" || await (B == null ? void 0 : B.type()) === "tree") {
|
|
return;
|
|
}
|
|
const Aoid = await (A == null ? void 0 : A.oid());
|
|
const Boid = await (B == null ? void 0 : B.oid());
|
|
let type = "equal";
|
|
if (Aoid !== Boid) {
|
|
type = "modify";
|
|
}
|
|
if (Aoid === void 0) {
|
|
type = "add";
|
|
}
|
|
if (Boid === void 0) {
|
|
type = "remove";
|
|
}
|
|
if (Aoid === void 0 && Boid === void 0) {
|
|
console.log("Something weird happened:");
|
|
console.log(A);
|
|
console.log(B);
|
|
}
|
|
if (type === "equal") {
|
|
return;
|
|
}
|
|
return {
|
|
path: filepath,
|
|
type
|
|
};
|
|
}
|
|
}));
|
|
return res;
|
|
}
|
|
async getStagedFiles(dir = ".") {
|
|
const res = await this.walkDifference({
|
|
walkers: [isomorphic_git_default.TREE({ ref: "HEAD" }), isomorphic_git_default.STAGE()],
|
|
dir
|
|
});
|
|
return res.map((file) => {
|
|
return {
|
|
vault_path: this.getVaultPath(file.path),
|
|
filepath: file.path
|
|
};
|
|
});
|
|
}
|
|
async getUnstagedFiles(base = ".") {
|
|
const notice = new import_obsidian5.Notice("Getting status...", this.noticeLength);
|
|
try {
|
|
const repo = this.getRepo();
|
|
const res = await this.wrapFS(isomorphic_git_default.walk({
|
|
...repo,
|
|
trees: [isomorphic_git_default.WORKDIR(), isomorphic_git_default.STAGE()],
|
|
map: async function(filepath, [workdir, stage]) {
|
|
if (!stage && workdir) {
|
|
const isIgnored2 = await isomorphic_git_default.isIgnored({
|
|
...repo,
|
|
filepath
|
|
});
|
|
if (isIgnored2) {
|
|
return null;
|
|
}
|
|
}
|
|
if (!worthWalking2(filepath, base)) {
|
|
return null;
|
|
}
|
|
const [workdirType, stageType] = await Promise.all([
|
|
workdir && workdir.type(),
|
|
stage && stage.type()
|
|
]);
|
|
const isBlob = [workdirType, stageType].includes("blob");
|
|
if ((workdirType === "tree" || workdirType === "special") && !isBlob)
|
|
return;
|
|
if (stageType === "commit")
|
|
return null;
|
|
if ((stageType === "tree" || stageType === "special") && !isBlob)
|
|
return;
|
|
const stageOid = stageType === "blob" ? await stage.oid() : void 0;
|
|
let workdirOid;
|
|
if (workdirType === "blob" && stageType !== "blob") {
|
|
workdirOid = "42";
|
|
} else if (workdirType === "blob") {
|
|
workdirOid = await workdir.oid();
|
|
}
|
|
if (!workdirOid) {
|
|
return {
|
|
filepath,
|
|
deleted: true
|
|
};
|
|
}
|
|
if (workdirOid !== stageOid) {
|
|
return {
|
|
filepath,
|
|
deleted: false
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
}));
|
|
notice.hide();
|
|
return res;
|
|
} catch (error) {
|
|
notice.hide();
|
|
this.plugin.displayError(error);
|
|
throw error;
|
|
}
|
|
}
|
|
async getDiffString(filePath, stagedChanges = false) {
|
|
const map = async (file, [A]) => {
|
|
if (filePath == file) {
|
|
const oid = await A.oid();
|
|
const contents = await isomorphic_git_default.readBlob({ ...this.getRepo(), oid });
|
|
return contents.blob;
|
|
}
|
|
};
|
|
const stagedBlob = (await isomorphic_git_default.walk({
|
|
...this.getRepo(),
|
|
trees: [isomorphic_git_default.STAGE()],
|
|
map
|
|
})).first();
|
|
const stagedContent = new TextDecoder().decode(stagedBlob);
|
|
if (stagedChanges) {
|
|
const headBlob = await readBlob({ ...this.getRepo(), filepath: filePath, oid: await this.resolveRef("HEAD") });
|
|
const headContent = new TextDecoder().decode(headBlob.blob);
|
|
const diff2 = createPatch(filePath, headContent, stagedContent);
|
|
return diff2;
|
|
} else {
|
|
let workdirContent;
|
|
if (await app.vault.adapter.exists(filePath)) {
|
|
workdirContent = await app.vault.adapter.read(filePath);
|
|
} else {
|
|
workdirContent = "";
|
|
}
|
|
const diff2 = createPatch(filePath, stagedContent, workdirContent);
|
|
return diff2;
|
|
}
|
|
}
|
|
getFileStatusResult(row) {
|
|
const status2 = this.status_mapping[`${row[this.HEAD]}${row[this.WORKDIR]}${row[this.STAGE]}`];
|
|
return {
|
|
index: status2[0] == "?" ? "U" : status2[0],
|
|
working_dir: status2[1] == "?" ? "U" : status2[1],
|
|
path: row[this.FILE],
|
|
vault_path: this.getVaultPath(row[this.FILE])
|
|
};
|
|
}
|
|
};
|
|
function fromValue2(value) {
|
|
let queue = [value];
|
|
return {
|
|
next() {
|
|
return Promise.resolve({ done: queue.length === 0, value: queue.pop() });
|
|
},
|
|
return() {
|
|
queue = [];
|
|
return {};
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
}
|
|
};
|
|
}
|
|
function getIterator2(iterable) {
|
|
if (iterable[Symbol.asyncIterator]) {
|
|
return iterable[Symbol.asyncIterator]();
|
|
}
|
|
if (iterable[Symbol.iterator]) {
|
|
return iterable[Symbol.iterator]();
|
|
}
|
|
if (iterable.next) {
|
|
return iterable;
|
|
}
|
|
return fromValue2(iterable);
|
|
}
|
|
async function forAwait2(iterable, cb) {
|
|
const iter = getIterator2(iterable);
|
|
while (true) {
|
|
const { value, done } = await iter.next();
|
|
if (value)
|
|
await cb(value);
|
|
if (done)
|
|
break;
|
|
}
|
|
if (iter.return)
|
|
iter.return();
|
|
}
|
|
async function collect2(iterable) {
|
|
let size = 0;
|
|
const buffers = [];
|
|
await forAwait2(iterable, (value) => {
|
|
buffers.push(value);
|
|
size += value.byteLength;
|
|
});
|
|
const result = new Uint8Array(size);
|
|
let nextIndex = 0;
|
|
for (const buffer2 of buffers) {
|
|
result.set(buffer2, nextIndex);
|
|
nextIndex += buffer2.byteLength;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// src/simpleGit.ts
|
|
init_polyfill_buffer();
|
|
var import_child_process2 = __toModule(require("child_process"));
|
|
var import_obsidian6 = __toModule(require("obsidian"));
|
|
var path = __toModule(require("path"));
|
|
var import_path = __toModule(require("path"));
|
|
|
|
// node_modules/simple-git/dist/esm/index.js
|
|
init_polyfill_buffer();
|
|
var import_file_exists = __toModule(require_dist());
|
|
var import_debug = __toModule(require_browser());
|
|
var import_child_process = __toModule(require("child_process"));
|
|
var import_promise_deferred = __toModule(require_dist2());
|
|
var import_promise_deferred2 = __toModule(require_dist2());
|
|
var __defProp2 = Object.defineProperty;
|
|
var __defProps = Object.defineProperties;
|
|
var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
|
var __getOwnPropNames2 = Object.getOwnPropertyNames;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp2 = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp2(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
|
|
var __spreadValues = (a, b) => {
|
|
for (var prop in b || (b = {}))
|
|
if (__hasOwnProp2.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
if (__getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(b)) {
|
|
if (__propIsEnum.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
}
|
|
return a;
|
|
};
|
|
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
|
var __markAsModule2 = (target) => __defProp2(target, "__esModule", { value: true });
|
|
var __esm2 = (fn, res) => function __init() {
|
|
return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
|
|
};
|
|
var __commonJS2 = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export2 = (target, all) => {
|
|
for (var name in all)
|
|
__defProp2(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __reExport2 = (target, module2, copyDefault, desc) => {
|
|
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
|
|
for (let key2 of __getOwnPropNames2(module2))
|
|
if (!__hasOwnProp2.call(target, key2) && (copyDefault || key2 !== "default"))
|
|
__defProp2(target, key2, { get: () => module2[key2], enumerable: !(desc = __getOwnPropDesc2(module2, key2)) || desc.enumerable });
|
|
}
|
|
return target;
|
|
};
|
|
var __toCommonJS = /* @__PURE__ */ ((cache) => {
|
|
return (module2, temp) => {
|
|
return cache && cache.get(module2) || (temp = __reExport2(__markAsModule2({}), module2, 1), cache && cache.set(module2, temp), temp);
|
|
};
|
|
})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
|
|
var __async = (__this, __arguments, generator) => {
|
|
return new Promise((resolve, reject) => {
|
|
var fulfilled = (value) => {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var rejected = (value) => {
|
|
try {
|
|
step(generator.throw(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
|
|
step((generator = generator.apply(__this, __arguments)).next());
|
|
});
|
|
};
|
|
var GitError;
|
|
var init_git_error = __esm2({
|
|
"src/lib/errors/git-error.ts"() {
|
|
GitError = class extends Error {
|
|
constructor(task, message) {
|
|
super(message);
|
|
this.task = task;
|
|
Object.setPrototypeOf(this, new.target.prototype);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var GitResponseError;
|
|
var init_git_response_error = __esm2({
|
|
"src/lib/errors/git-response-error.ts"() {
|
|
init_git_error();
|
|
GitResponseError = class extends GitError {
|
|
constructor(git, message) {
|
|
super(void 0, message || String(git));
|
|
this.git = git;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var TaskConfigurationError;
|
|
var init_task_configuration_error = __esm2({
|
|
"src/lib/errors/task-configuration-error.ts"() {
|
|
init_git_error();
|
|
TaskConfigurationError = class extends GitError {
|
|
constructor(message) {
|
|
super(void 0, message);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function asFunction(source) {
|
|
return typeof source === "function" ? source : NOOP;
|
|
}
|
|
function isUserFunction(source) {
|
|
return typeof source === "function" && source !== NOOP;
|
|
}
|
|
function splitOn(input, char) {
|
|
const index2 = input.indexOf(char);
|
|
if (index2 <= 0) {
|
|
return [input, ""];
|
|
}
|
|
return [input.substr(0, index2), input.substr(index2 + 1)];
|
|
}
|
|
function first(input, offset = 0) {
|
|
return isArrayLike(input) && input.length > offset ? input[offset] : void 0;
|
|
}
|
|
function last(input, offset = 0) {
|
|
if (isArrayLike(input) && input.length > offset) {
|
|
return input[input.length - 1 - offset];
|
|
}
|
|
}
|
|
function isArrayLike(input) {
|
|
return !!(input && typeof input.length === "number");
|
|
}
|
|
function toLinesWithContent(input = "", trimmed2 = true, separator2 = "\n") {
|
|
return input.split(separator2).reduce((output, line) => {
|
|
const lineContent = trimmed2 ? line.trim() : line;
|
|
if (lineContent) {
|
|
output.push(lineContent);
|
|
}
|
|
return output;
|
|
}, []);
|
|
}
|
|
function forEachLineWithContent(input, callback) {
|
|
return toLinesWithContent(input, true).map((line) => callback(line));
|
|
}
|
|
function folderExists(path2) {
|
|
return (0, import_file_exists.exists)(path2, import_file_exists.FOLDER);
|
|
}
|
|
function append(target, item) {
|
|
if (Array.isArray(target)) {
|
|
if (!target.includes(item)) {
|
|
target.push(item);
|
|
}
|
|
} else {
|
|
target.add(item);
|
|
}
|
|
return item;
|
|
}
|
|
function including(target, item) {
|
|
if (Array.isArray(target) && !target.includes(item)) {
|
|
target.push(item);
|
|
}
|
|
return target;
|
|
}
|
|
function remove2(target, item) {
|
|
if (Array.isArray(target)) {
|
|
const index2 = target.indexOf(item);
|
|
if (index2 >= 0) {
|
|
target.splice(index2, 1);
|
|
}
|
|
} else {
|
|
target.delete(item);
|
|
}
|
|
return item;
|
|
}
|
|
function asArray(source) {
|
|
return Array.isArray(source) ? source : [source];
|
|
}
|
|
function asStringArray(source) {
|
|
return asArray(source).map(String);
|
|
}
|
|
function asNumber(source, onNaN = 0) {
|
|
if (source == null) {
|
|
return onNaN;
|
|
}
|
|
const num2 = parseInt(source, 10);
|
|
return isNaN(num2) ? onNaN : num2;
|
|
}
|
|
function prefixedArray(input, prefix) {
|
|
const output = [];
|
|
for (let i = 0, max = input.length; i < max; i++) {
|
|
output.push(prefix, input[i]);
|
|
}
|
|
return output;
|
|
}
|
|
function bufferToString(input) {
|
|
return (Array.isArray(input) ? Buffer2.concat(input) : input).toString("utf-8");
|
|
}
|
|
function pick(source, properties) {
|
|
return Object.assign({}, ...properties.map((property) => property in source ? { [property]: source[property] } : {}));
|
|
}
|
|
function delay(duration = 0) {
|
|
return new Promise((done) => setTimeout(done, duration));
|
|
}
|
|
var NULL;
|
|
var NOOP;
|
|
var objectToString;
|
|
var init_util = __esm2({
|
|
"src/lib/utils/util.ts"() {
|
|
NULL = "\0";
|
|
NOOP = () => {
|
|
};
|
|
objectToString = Object.prototype.toString.call.bind(Object.prototype.toString);
|
|
}
|
|
});
|
|
function filterType(input, filter, def) {
|
|
if (filter(input)) {
|
|
return input;
|
|
}
|
|
return arguments.length > 2 ? def : void 0;
|
|
}
|
|
function filterPrimitives(input, omit) {
|
|
return /number|string|boolean/.test(typeof input) && (!omit || !omit.includes(typeof input));
|
|
}
|
|
function filterPlainObject(input) {
|
|
return !!input && objectToString(input) === "[object Object]";
|
|
}
|
|
function filterFunction(input) {
|
|
return typeof input === "function";
|
|
}
|
|
var filterArray;
|
|
var filterString;
|
|
var filterStringArray;
|
|
var filterStringOrStringArray;
|
|
var filterHasLength;
|
|
var init_argument_filters = __esm2({
|
|
"src/lib/utils/argument-filters.ts"() {
|
|
init_util();
|
|
filterArray = (input) => {
|
|
return Array.isArray(input);
|
|
};
|
|
filterString = (input) => {
|
|
return typeof input === "string";
|
|
};
|
|
filterStringArray = (input) => {
|
|
return Array.isArray(input) && input.every(filterString);
|
|
};
|
|
filterStringOrStringArray = (input) => {
|
|
return filterString(input) || Array.isArray(input) && input.every(filterString);
|
|
};
|
|
filterHasLength = (input) => {
|
|
if (input == null || "number|boolean|function".includes(typeof input)) {
|
|
return false;
|
|
}
|
|
return Array.isArray(input) || typeof input === "string" || typeof input.length === "number";
|
|
};
|
|
}
|
|
});
|
|
var ExitCodes;
|
|
var init_exit_codes = __esm2({
|
|
"src/lib/utils/exit-codes.ts"() {
|
|
ExitCodes = /* @__PURE__ */ ((ExitCodes2) => {
|
|
ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS";
|
|
ExitCodes2[ExitCodes2["ERROR"] = 1] = "ERROR";
|
|
ExitCodes2[ExitCodes2["NOT_FOUND"] = -2] = "NOT_FOUND";
|
|
ExitCodes2[ExitCodes2["UNCLEAN"] = 128] = "UNCLEAN";
|
|
return ExitCodes2;
|
|
})(ExitCodes || {});
|
|
}
|
|
});
|
|
var GitOutputStreams;
|
|
var init_git_output_streams = __esm2({
|
|
"src/lib/utils/git-output-streams.ts"() {
|
|
GitOutputStreams = class {
|
|
constructor(stdOut, stdErr) {
|
|
this.stdOut = stdOut;
|
|
this.stdErr = stdErr;
|
|
}
|
|
asStrings() {
|
|
return new GitOutputStreams(this.stdOut.toString("utf8"), this.stdErr.toString("utf8"));
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var LineParser;
|
|
var RemoteLineParser;
|
|
var init_line_parser = __esm2({
|
|
"src/lib/utils/line-parser.ts"() {
|
|
LineParser = class {
|
|
constructor(regExp, useMatches) {
|
|
this.matches = [];
|
|
this.parse = (line, target) => {
|
|
this.resetMatches();
|
|
if (!this._regExp.every((reg, index2) => this.addMatch(reg, index2, line(index2)))) {
|
|
return false;
|
|
}
|
|
return this.useMatches(target, this.prepareMatches()) !== false;
|
|
};
|
|
this._regExp = Array.isArray(regExp) ? regExp : [regExp];
|
|
if (useMatches) {
|
|
this.useMatches = useMatches;
|
|
}
|
|
}
|
|
useMatches(target, match) {
|
|
throw new Error(`LineParser:useMatches not implemented`);
|
|
}
|
|
resetMatches() {
|
|
this.matches.length = 0;
|
|
}
|
|
prepareMatches() {
|
|
return this.matches;
|
|
}
|
|
addMatch(reg, index2, line) {
|
|
const matched = line && reg.exec(line);
|
|
if (matched) {
|
|
this.pushMatch(index2, matched);
|
|
}
|
|
return !!matched;
|
|
}
|
|
pushMatch(_index, matched) {
|
|
this.matches.push(...matched.slice(1));
|
|
}
|
|
};
|
|
RemoteLineParser = class extends LineParser {
|
|
addMatch(reg, index2, line) {
|
|
return /^remote:\s/.test(String(line)) && super.addMatch(reg, index2, line);
|
|
}
|
|
pushMatch(index2, matched) {
|
|
if (index2 > 0 || matched.length > 1) {
|
|
super.pushMatch(index2, matched);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function createInstanceConfig(...options) {
|
|
const baseDir = process.cwd();
|
|
const config = Object.assign(__spreadValues({ baseDir }, defaultOptions), ...options.filter((o) => typeof o === "object" && o));
|
|
config.baseDir = config.baseDir || baseDir;
|
|
config.trimmed = config.trimmed === true;
|
|
return config;
|
|
}
|
|
var defaultOptions;
|
|
var init_simple_git_options = __esm2({
|
|
"src/lib/utils/simple-git-options.ts"() {
|
|
defaultOptions = {
|
|
binary: "git",
|
|
maxConcurrentProcesses: 5,
|
|
config: [],
|
|
trimmed: false
|
|
};
|
|
}
|
|
});
|
|
function appendTaskOptions(options, commands = []) {
|
|
if (!filterPlainObject(options)) {
|
|
return commands;
|
|
}
|
|
return Object.keys(options).reduce((commands2, key2) => {
|
|
const value = options[key2];
|
|
if (filterPrimitives(value, ["boolean"])) {
|
|
commands2.push(key2 + "=" + value);
|
|
} else {
|
|
commands2.push(key2);
|
|
}
|
|
return commands2;
|
|
}, commands);
|
|
}
|
|
function getTrailingOptions(args, initialPrimitive = 0, objectOnly = false) {
|
|
const command = [];
|
|
for (let i = 0, max = initialPrimitive < 0 ? args.length : initialPrimitive; i < max; i++) {
|
|
if ("string|number".includes(typeof args[i])) {
|
|
command.push(String(args[i]));
|
|
}
|
|
}
|
|
appendTaskOptions(trailingOptionsArgument(args), command);
|
|
if (!objectOnly) {
|
|
command.push(...trailingArrayArgument(args));
|
|
}
|
|
return command;
|
|
}
|
|
function trailingArrayArgument(args) {
|
|
const hasTrailingCallback = typeof last(args) === "function";
|
|
return filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []);
|
|
}
|
|
function trailingOptionsArgument(args) {
|
|
const hasTrailingCallback = filterFunction(last(args));
|
|
return filterType(last(args, hasTrailingCallback ? 1 : 0), filterPlainObject);
|
|
}
|
|
function trailingFunctionArgument(args, includeNoop = true) {
|
|
const callback = asFunction(last(args));
|
|
return includeNoop || isUserFunction(callback) ? callback : void 0;
|
|
}
|
|
var init_task_options = __esm2({
|
|
"src/lib/utils/task-options.ts"() {
|
|
init_argument_filters();
|
|
init_util();
|
|
}
|
|
});
|
|
function callTaskParser(parser3, streams) {
|
|
return parser3(streams.stdOut, streams.stdErr);
|
|
}
|
|
function parseStringResponse(result, parsers12, texts, trim = true) {
|
|
asArray(texts).forEach((text2) => {
|
|
for (let lines = toLinesWithContent(text2, trim), i = 0, max = lines.length; i < max; i++) {
|
|
const line = (offset = 0) => {
|
|
if (i + offset >= max) {
|
|
return;
|
|
}
|
|
return lines[i + offset];
|
|
};
|
|
parsers12.some(({ parse: parse2 }) => parse2(line, result));
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
var init_task_parser = __esm2({
|
|
"src/lib/utils/task-parser.ts"() {
|
|
init_util();
|
|
}
|
|
});
|
|
var utils_exports = {};
|
|
__export2(utils_exports, {
|
|
ExitCodes: () => ExitCodes,
|
|
GitOutputStreams: () => GitOutputStreams,
|
|
LineParser: () => LineParser,
|
|
NOOP: () => NOOP,
|
|
NULL: () => NULL,
|
|
RemoteLineParser: () => RemoteLineParser,
|
|
append: () => append,
|
|
appendTaskOptions: () => appendTaskOptions,
|
|
asArray: () => asArray,
|
|
asFunction: () => asFunction,
|
|
asNumber: () => asNumber,
|
|
asStringArray: () => asStringArray,
|
|
bufferToString: () => bufferToString,
|
|
callTaskParser: () => callTaskParser,
|
|
createInstanceConfig: () => createInstanceConfig,
|
|
delay: () => delay,
|
|
filterArray: () => filterArray,
|
|
filterFunction: () => filterFunction,
|
|
filterHasLength: () => filterHasLength,
|
|
filterPlainObject: () => filterPlainObject,
|
|
filterPrimitives: () => filterPrimitives,
|
|
filterString: () => filterString,
|
|
filterStringArray: () => filterStringArray,
|
|
filterStringOrStringArray: () => filterStringOrStringArray,
|
|
filterType: () => filterType,
|
|
first: () => first,
|
|
folderExists: () => folderExists,
|
|
forEachLineWithContent: () => forEachLineWithContent,
|
|
getTrailingOptions: () => getTrailingOptions,
|
|
including: () => including,
|
|
isUserFunction: () => isUserFunction,
|
|
last: () => last,
|
|
objectToString: () => objectToString,
|
|
parseStringResponse: () => parseStringResponse,
|
|
pick: () => pick,
|
|
prefixedArray: () => prefixedArray,
|
|
remove: () => remove2,
|
|
splitOn: () => splitOn,
|
|
toLinesWithContent: () => toLinesWithContent,
|
|
trailingFunctionArgument: () => trailingFunctionArgument,
|
|
trailingOptionsArgument: () => trailingOptionsArgument
|
|
});
|
|
var init_utils = __esm2({
|
|
"src/lib/utils/index.ts"() {
|
|
init_argument_filters();
|
|
init_exit_codes();
|
|
init_git_output_streams();
|
|
init_line_parser();
|
|
init_simple_git_options();
|
|
init_task_options();
|
|
init_task_parser();
|
|
init_util();
|
|
}
|
|
});
|
|
var check_is_repo_exports = {};
|
|
__export2(check_is_repo_exports, {
|
|
CheckRepoActions: () => CheckRepoActions,
|
|
checkIsBareRepoTask: () => checkIsBareRepoTask,
|
|
checkIsRepoRootTask: () => checkIsRepoRootTask,
|
|
checkIsRepoTask: () => checkIsRepoTask
|
|
});
|
|
function checkIsRepoTask(action) {
|
|
switch (action) {
|
|
case "bare":
|
|
return checkIsBareRepoTask();
|
|
case "root":
|
|
return checkIsRepoRootTask();
|
|
}
|
|
const commands = ["rev-parse", "--is-inside-work-tree"];
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
onError,
|
|
parser
|
|
};
|
|
}
|
|
function checkIsRepoRootTask() {
|
|
const commands = ["rev-parse", "--git-dir"];
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
onError,
|
|
parser(path2) {
|
|
return /^\.(git)?$/.test(path2.trim());
|
|
}
|
|
};
|
|
}
|
|
function checkIsBareRepoTask() {
|
|
const commands = ["rev-parse", "--is-bare-repository"];
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
onError,
|
|
parser
|
|
};
|
|
}
|
|
function isNotRepoMessage(error) {
|
|
return /(Not a git repository|Kein Git-Repository)/i.test(String(error));
|
|
}
|
|
var CheckRepoActions;
|
|
var onError;
|
|
var parser;
|
|
var init_check_is_repo = __esm2({
|
|
"src/lib/tasks/check-is-repo.ts"() {
|
|
init_utils();
|
|
CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => {
|
|
CheckRepoActions2["BARE"] = "bare";
|
|
CheckRepoActions2["IN_TREE"] = "tree";
|
|
CheckRepoActions2["IS_REPO_ROOT"] = "root";
|
|
return CheckRepoActions2;
|
|
})(CheckRepoActions || {});
|
|
onError = ({ exitCode }, error, done, fail) => {
|
|
if (exitCode === 128 && isNotRepoMessage(error)) {
|
|
return done(Buffer2.from("false"));
|
|
}
|
|
fail(error);
|
|
};
|
|
parser = (text2) => {
|
|
return text2.trim() === "true";
|
|
};
|
|
}
|
|
});
|
|
function cleanSummaryParser(dryRun, text2) {
|
|
const summary = new CleanResponse(dryRun);
|
|
const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp;
|
|
toLinesWithContent(text2).forEach((line) => {
|
|
const removed = line.replace(regexp, "");
|
|
summary.paths.push(removed);
|
|
(isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed);
|
|
});
|
|
return summary;
|
|
}
|
|
var CleanResponse;
|
|
var removalRegexp;
|
|
var dryRunRemovalRegexp;
|
|
var isFolderRegexp;
|
|
var init_CleanSummary = __esm2({
|
|
"src/lib/responses/CleanSummary.ts"() {
|
|
init_utils();
|
|
CleanResponse = class {
|
|
constructor(dryRun) {
|
|
this.dryRun = dryRun;
|
|
this.paths = [];
|
|
this.files = [];
|
|
this.folders = [];
|
|
}
|
|
};
|
|
removalRegexp = /^[a-z]+\s*/i;
|
|
dryRunRemovalRegexp = /^[a-z]+\s+[a-z]+\s*/i;
|
|
isFolderRegexp = /\/$/;
|
|
}
|
|
});
|
|
var task_exports = {};
|
|
__export2(task_exports, {
|
|
EMPTY_COMMANDS: () => EMPTY_COMMANDS,
|
|
adhocExecTask: () => adhocExecTask,
|
|
configurationErrorTask: () => configurationErrorTask,
|
|
isBufferTask: () => isBufferTask,
|
|
isEmptyTask: () => isEmptyTask,
|
|
straightThroughBufferTask: () => straightThroughBufferTask,
|
|
straightThroughStringTask: () => straightThroughStringTask
|
|
});
|
|
function adhocExecTask(parser3) {
|
|
return {
|
|
commands: EMPTY_COMMANDS,
|
|
format: "empty",
|
|
parser: parser3
|
|
};
|
|
}
|
|
function configurationErrorTask(error) {
|
|
return {
|
|
commands: EMPTY_COMMANDS,
|
|
format: "empty",
|
|
parser() {
|
|
throw typeof error === "string" ? new TaskConfigurationError(error) : error;
|
|
}
|
|
};
|
|
}
|
|
function straightThroughStringTask(commands, trimmed2 = false) {
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser(text2) {
|
|
return trimmed2 ? String(text2).trim() : text2;
|
|
}
|
|
};
|
|
}
|
|
function straightThroughBufferTask(commands) {
|
|
return {
|
|
commands,
|
|
format: "buffer",
|
|
parser(buffer2) {
|
|
return buffer2;
|
|
}
|
|
};
|
|
}
|
|
function isBufferTask(task) {
|
|
return task.format === "buffer";
|
|
}
|
|
function isEmptyTask(task) {
|
|
return task.format === "empty" || !task.commands.length;
|
|
}
|
|
var EMPTY_COMMANDS;
|
|
var init_task = __esm2({
|
|
"src/lib/tasks/task.ts"() {
|
|
init_task_configuration_error();
|
|
EMPTY_COMMANDS = [];
|
|
}
|
|
});
|
|
var clean_exports = {};
|
|
__export2(clean_exports, {
|
|
CONFIG_ERROR_INTERACTIVE_MODE: () => CONFIG_ERROR_INTERACTIVE_MODE,
|
|
CONFIG_ERROR_MODE_REQUIRED: () => CONFIG_ERROR_MODE_REQUIRED,
|
|
CONFIG_ERROR_UNKNOWN_OPTION: () => CONFIG_ERROR_UNKNOWN_OPTION,
|
|
CleanOptions: () => CleanOptions,
|
|
cleanTask: () => cleanTask,
|
|
cleanWithOptionsTask: () => cleanWithOptionsTask,
|
|
isCleanOptionsArray: () => isCleanOptionsArray
|
|
});
|
|
function cleanWithOptionsTask(mode, customArgs) {
|
|
const { cleanMode, options, valid } = getCleanOptions(mode);
|
|
if (!cleanMode) {
|
|
return configurationErrorTask(CONFIG_ERROR_MODE_REQUIRED);
|
|
}
|
|
if (!valid.options) {
|
|
return configurationErrorTask(CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode));
|
|
}
|
|
options.push(...customArgs);
|
|
if (options.some(isInteractiveMode)) {
|
|
return configurationErrorTask(CONFIG_ERROR_INTERACTIVE_MODE);
|
|
}
|
|
return cleanTask(cleanMode, options);
|
|
}
|
|
function cleanTask(mode, customArgs) {
|
|
const commands = ["clean", `-${mode}`, ...customArgs];
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser(text2) {
|
|
return cleanSummaryParser(mode === "n", text2);
|
|
}
|
|
};
|
|
}
|
|
function isCleanOptionsArray(input) {
|
|
return Array.isArray(input) && input.every((test) => CleanOptionValues.has(test));
|
|
}
|
|
function getCleanOptions(input) {
|
|
let cleanMode;
|
|
let options = [];
|
|
let valid = { cleanMode: false, options: true };
|
|
input.replace(/[^a-z]i/g, "").split("").forEach((char) => {
|
|
if (isCleanMode(char)) {
|
|
cleanMode = char;
|
|
valid.cleanMode = true;
|
|
} else {
|
|
valid.options = valid.options && isKnownOption(options[options.length] = `-${char}`);
|
|
}
|
|
});
|
|
return {
|
|
cleanMode,
|
|
options,
|
|
valid
|
|
};
|
|
}
|
|
function isCleanMode(cleanMode) {
|
|
return cleanMode === "f" || cleanMode === "n";
|
|
}
|
|
function isKnownOption(option) {
|
|
return /^-[a-z]$/i.test(option) && CleanOptionValues.has(option.charAt(1));
|
|
}
|
|
function isInteractiveMode(option) {
|
|
if (/^-[^\-]/.test(option)) {
|
|
return option.indexOf("i") > 0;
|
|
}
|
|
return option === "--interactive";
|
|
}
|
|
var CONFIG_ERROR_INTERACTIVE_MODE;
|
|
var CONFIG_ERROR_MODE_REQUIRED;
|
|
var CONFIG_ERROR_UNKNOWN_OPTION;
|
|
var CleanOptions;
|
|
var CleanOptionValues;
|
|
var init_clean = __esm2({
|
|
"src/lib/tasks/clean.ts"() {
|
|
init_CleanSummary();
|
|
init_utils();
|
|
init_task();
|
|
CONFIG_ERROR_INTERACTIVE_MODE = "Git clean interactive mode is not supported";
|
|
CONFIG_ERROR_MODE_REQUIRED = 'Git clean mode parameter ("n" or "f") is required';
|
|
CONFIG_ERROR_UNKNOWN_OPTION = "Git clean unknown option found in: ";
|
|
CleanOptions = /* @__PURE__ */ ((CleanOptions2) => {
|
|
CleanOptions2["DRY_RUN"] = "n";
|
|
CleanOptions2["FORCE"] = "f";
|
|
CleanOptions2["IGNORED_INCLUDED"] = "x";
|
|
CleanOptions2["IGNORED_ONLY"] = "X";
|
|
CleanOptions2["EXCLUDING"] = "e";
|
|
CleanOptions2["QUIET"] = "q";
|
|
CleanOptions2["RECURSIVE"] = "d";
|
|
return CleanOptions2;
|
|
})(CleanOptions || {});
|
|
CleanOptionValues = /* @__PURE__ */ new Set([
|
|
"i",
|
|
...asStringArray(Object.values(CleanOptions))
|
|
]);
|
|
}
|
|
});
|
|
function configListParser(text2) {
|
|
const config = new ConfigList();
|
|
for (const item of configParser(text2)) {
|
|
config.addValue(item.file, String(item.key), item.value);
|
|
}
|
|
return config;
|
|
}
|
|
function configGetParser(text2, key2) {
|
|
let value = null;
|
|
const values = [];
|
|
const scopes = /* @__PURE__ */ new Map();
|
|
for (const item of configParser(text2, key2)) {
|
|
if (item.key !== key2) {
|
|
continue;
|
|
}
|
|
values.push(value = item.value);
|
|
if (!scopes.has(item.file)) {
|
|
scopes.set(item.file, []);
|
|
}
|
|
scopes.get(item.file).push(value);
|
|
}
|
|
return {
|
|
key: key2,
|
|
paths: Array.from(scopes.keys()),
|
|
scopes,
|
|
value,
|
|
values
|
|
};
|
|
}
|
|
function configFilePath(filePath) {
|
|
return filePath.replace(/^(file):/, "");
|
|
}
|
|
function* configParser(text2, requestedKey = null) {
|
|
const lines = text2.split("\0");
|
|
for (let i = 0, max = lines.length - 1; i < max; ) {
|
|
const file = configFilePath(lines[i++]);
|
|
let value = lines[i++];
|
|
let key2 = requestedKey;
|
|
if (value.includes("\n")) {
|
|
const line = splitOn(value, "\n");
|
|
key2 = line[0];
|
|
value = line[1];
|
|
}
|
|
yield { file, key: key2, value };
|
|
}
|
|
}
|
|
var ConfigList;
|
|
var init_ConfigList = __esm2({
|
|
"src/lib/responses/ConfigList.ts"() {
|
|
init_utils();
|
|
ConfigList = class {
|
|
constructor() {
|
|
this.files = [];
|
|
this.values = /* @__PURE__ */ Object.create(null);
|
|
}
|
|
get all() {
|
|
if (!this._all) {
|
|
this._all = this.files.reduce((all, file) => {
|
|
return Object.assign(all, this.values[file]);
|
|
}, {});
|
|
}
|
|
return this._all;
|
|
}
|
|
addFile(file) {
|
|
if (!(file in this.values)) {
|
|
const latest = last(this.files);
|
|
this.values[file] = latest ? Object.create(this.values[latest]) : {};
|
|
this.files.push(file);
|
|
}
|
|
return this.values[file];
|
|
}
|
|
addValue(file, key2, value) {
|
|
const values = this.addFile(file);
|
|
if (!values.hasOwnProperty(key2)) {
|
|
values[key2] = value;
|
|
} else if (Array.isArray(values[key2])) {
|
|
values[key2].push(value);
|
|
} else {
|
|
values[key2] = [values[key2], value];
|
|
}
|
|
this._all = void 0;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function asConfigScope(scope, fallback) {
|
|
if (typeof scope === "string" && GitConfigScope.hasOwnProperty(scope)) {
|
|
return scope;
|
|
}
|
|
return fallback;
|
|
}
|
|
function addConfigTask(key2, value, append22, scope) {
|
|
const commands = ["config", `--${scope}`];
|
|
if (append22) {
|
|
commands.push("--add");
|
|
}
|
|
commands.push(key2, value);
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser(text2) {
|
|
return text2;
|
|
}
|
|
};
|
|
}
|
|
function getConfigTask(key2, scope) {
|
|
const commands = ["config", "--null", "--show-origin", "--get-all", key2];
|
|
if (scope) {
|
|
commands.splice(1, 0, `--${scope}`);
|
|
}
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser(text2) {
|
|
return configGetParser(text2, key2);
|
|
}
|
|
};
|
|
}
|
|
function listConfigTask(scope) {
|
|
const commands = ["config", "--list", "--show-origin", "--null"];
|
|
if (scope) {
|
|
commands.push(`--${scope}`);
|
|
}
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser(text2) {
|
|
return configListParser(text2);
|
|
}
|
|
};
|
|
}
|
|
function config_default() {
|
|
return {
|
|
addConfig(key2, value, ...rest) {
|
|
return this._runTask(addConfigTask(key2, value, rest[0] === true, asConfigScope(rest[1], "local")), trailingFunctionArgument(arguments));
|
|
},
|
|
getConfig(key2, scope) {
|
|
return this._runTask(getConfigTask(key2, asConfigScope(scope, void 0)), trailingFunctionArgument(arguments));
|
|
},
|
|
listConfig(...rest) {
|
|
return this._runTask(listConfigTask(asConfigScope(rest[0], void 0)), trailingFunctionArgument(arguments));
|
|
}
|
|
};
|
|
}
|
|
var GitConfigScope;
|
|
var init_config = __esm2({
|
|
"src/lib/tasks/config.ts"() {
|
|
init_ConfigList();
|
|
init_utils();
|
|
GitConfigScope = /* @__PURE__ */ ((GitConfigScope2) => {
|
|
GitConfigScope2["system"] = "system";
|
|
GitConfigScope2["global"] = "global";
|
|
GitConfigScope2["local"] = "local";
|
|
GitConfigScope2["worktree"] = "worktree";
|
|
return GitConfigScope2;
|
|
})(GitConfigScope || {});
|
|
}
|
|
});
|
|
function grepQueryBuilder(...params) {
|
|
return new GrepQuery().param(...params);
|
|
}
|
|
function parseGrep(grep) {
|
|
const paths = /* @__PURE__ */ new Set();
|
|
const results = {};
|
|
forEachLineWithContent(grep, (input) => {
|
|
const [path2, line, preview] = input.split(NULL);
|
|
paths.add(path2);
|
|
(results[path2] = results[path2] || []).push({
|
|
line: asNumber(line),
|
|
path: path2,
|
|
preview
|
|
});
|
|
});
|
|
return {
|
|
paths,
|
|
results
|
|
};
|
|
}
|
|
function grep_default() {
|
|
return {
|
|
grep(searchTerm) {
|
|
const then = trailingFunctionArgument(arguments);
|
|
const options = getTrailingOptions(arguments);
|
|
for (const option of disallowedOptions) {
|
|
if (options.includes(option)) {
|
|
return this._runTask(configurationErrorTask(`git.grep: use of "${option}" is not supported.`), then);
|
|
}
|
|
}
|
|
if (typeof searchTerm === "string") {
|
|
searchTerm = grepQueryBuilder().param(searchTerm);
|
|
}
|
|
const commands = ["grep", "--null", "-n", "--full-name", ...options, ...searchTerm];
|
|
return this._runTask({
|
|
commands,
|
|
format: "utf-8",
|
|
parser(stdOut) {
|
|
return parseGrep(stdOut);
|
|
}
|
|
}, then);
|
|
}
|
|
};
|
|
}
|
|
var disallowedOptions;
|
|
var Query;
|
|
var _a;
|
|
var GrepQuery;
|
|
var init_grep = __esm2({
|
|
"src/lib/tasks/grep.ts"() {
|
|
init_utils();
|
|
init_task();
|
|
disallowedOptions = ["-h"];
|
|
Query = Symbol("grepQuery");
|
|
GrepQuery = class {
|
|
constructor() {
|
|
this[_a] = [];
|
|
}
|
|
*[(_a = Query, Symbol.iterator)]() {
|
|
for (const query of this[Query]) {
|
|
yield query;
|
|
}
|
|
}
|
|
and(...and) {
|
|
and.length && this[Query].push("--and", "(", ...prefixedArray(and, "-e"), ")");
|
|
return this;
|
|
}
|
|
param(...param) {
|
|
this[Query].push(...prefixedArray(param, "-e"));
|
|
return this;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var reset_exports = {};
|
|
__export2(reset_exports, {
|
|
ResetMode: () => ResetMode,
|
|
getResetMode: () => getResetMode,
|
|
resetTask: () => resetTask
|
|
});
|
|
function resetTask(mode, customArgs) {
|
|
const commands = ["reset"];
|
|
if (isValidResetMode(mode)) {
|
|
commands.push(`--${mode}`);
|
|
}
|
|
commands.push(...customArgs);
|
|
return straightThroughStringTask(commands);
|
|
}
|
|
function getResetMode(mode) {
|
|
if (isValidResetMode(mode)) {
|
|
return mode;
|
|
}
|
|
switch (typeof mode) {
|
|
case "string":
|
|
case "undefined":
|
|
return "soft";
|
|
}
|
|
return;
|
|
}
|
|
function isValidResetMode(mode) {
|
|
return ResetModes.includes(mode);
|
|
}
|
|
var ResetMode;
|
|
var ResetModes;
|
|
var init_reset = __esm2({
|
|
"src/lib/tasks/reset.ts"() {
|
|
init_task();
|
|
ResetMode = /* @__PURE__ */ ((ResetMode2) => {
|
|
ResetMode2["MIXED"] = "mixed";
|
|
ResetMode2["SOFT"] = "soft";
|
|
ResetMode2["HARD"] = "hard";
|
|
ResetMode2["MERGE"] = "merge";
|
|
ResetMode2["KEEP"] = "keep";
|
|
return ResetMode2;
|
|
})(ResetMode || {});
|
|
ResetModes = Array.from(Object.values(ResetMode));
|
|
}
|
|
});
|
|
function createLog() {
|
|
return (0, import_debug.default)("simple-git");
|
|
}
|
|
function prefixedLogger(to, prefix, forward) {
|
|
if (!prefix || !String(prefix).replace(/\s*/, "")) {
|
|
return !forward ? to : (message, ...args) => {
|
|
to(message, ...args);
|
|
forward(message, ...args);
|
|
};
|
|
}
|
|
return (message, ...args) => {
|
|
to(`%s ${message}`, prefix, ...args);
|
|
if (forward) {
|
|
forward(message, ...args);
|
|
}
|
|
};
|
|
}
|
|
function childLoggerName(name, childDebugger, { namespace: parentNamespace }) {
|
|
if (typeof name === "string") {
|
|
return name;
|
|
}
|
|
const childNamespace = childDebugger && childDebugger.namespace || "";
|
|
if (childNamespace.startsWith(parentNamespace)) {
|
|
return childNamespace.substr(parentNamespace.length + 1);
|
|
}
|
|
return childNamespace || parentNamespace;
|
|
}
|
|
function createLogger(label, verbose, initialStep, infoDebugger = createLog()) {
|
|
const labelPrefix = label && `[${label}]` || "";
|
|
const spawned = [];
|
|
const debugDebugger = typeof verbose === "string" ? infoDebugger.extend(verbose) : verbose;
|
|
const key2 = childLoggerName(filterType(verbose, filterString), debugDebugger, infoDebugger);
|
|
return step(initialStep);
|
|
function sibling(name, initial) {
|
|
return append(spawned, createLogger(label, key2.replace(/^[^:]+/, name), initial, infoDebugger));
|
|
}
|
|
function step(phase) {
|
|
const stepPrefix = phase && `[${phase}]` || "";
|
|
const debug2 = debugDebugger && prefixedLogger(debugDebugger, stepPrefix) || NOOP;
|
|
const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug2);
|
|
return Object.assign(debugDebugger ? debug2 : info, {
|
|
label,
|
|
sibling,
|
|
info,
|
|
step
|
|
});
|
|
}
|
|
}
|
|
var init_git_logger = __esm2({
|
|
"src/lib/git-logger.ts"() {
|
|
init_utils();
|
|
import_debug.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-");
|
|
import_debug.default.formatters.B = (value) => {
|
|
if (Buffer2.isBuffer(value)) {
|
|
return value.toString("utf8");
|
|
}
|
|
return objectToString(value);
|
|
};
|
|
}
|
|
});
|
|
var _TasksPendingQueue;
|
|
var TasksPendingQueue;
|
|
var init_tasks_pending_queue = __esm2({
|
|
"src/lib/runners/tasks-pending-queue.ts"() {
|
|
init_git_error();
|
|
init_git_logger();
|
|
_TasksPendingQueue = class {
|
|
constructor(logLabel = "GitExecutor") {
|
|
this.logLabel = logLabel;
|
|
this._queue = /* @__PURE__ */ new Map();
|
|
}
|
|
withProgress(task) {
|
|
return this._queue.get(task);
|
|
}
|
|
createProgress(task) {
|
|
const name = _TasksPendingQueue.getName(task.commands[0]);
|
|
const logger = createLogger(this.logLabel, name);
|
|
return {
|
|
task,
|
|
logger,
|
|
name
|
|
};
|
|
}
|
|
push(task) {
|
|
const progress = this.createProgress(task);
|
|
progress.logger("Adding task to the queue, commands = %o", task.commands);
|
|
this._queue.set(task, progress);
|
|
return progress;
|
|
}
|
|
fatal(err) {
|
|
for (const [task, { logger }] of Array.from(this._queue.entries())) {
|
|
if (task === err.task) {
|
|
logger.info(`Failed %o`, err);
|
|
logger(`Fatal exception, any as-yet un-started tasks run through this executor will not be attempted`);
|
|
} else {
|
|
logger.info(`A fatal exception occurred in a previous task, the queue has been purged: %o`, err.message);
|
|
}
|
|
this.complete(task);
|
|
}
|
|
if (this._queue.size !== 0) {
|
|
throw new Error(`Queue size should be zero after fatal: ${this._queue.size}`);
|
|
}
|
|
}
|
|
complete(task) {
|
|
const progress = this.withProgress(task);
|
|
if (progress) {
|
|
this._queue.delete(task);
|
|
}
|
|
}
|
|
attempt(task) {
|
|
const progress = this.withProgress(task);
|
|
if (!progress) {
|
|
throw new GitError(void 0, "TasksPendingQueue: attempt called for an unknown task");
|
|
}
|
|
progress.logger("Starting task");
|
|
return progress;
|
|
}
|
|
static getName(name = "empty") {
|
|
return `task:${name}:${++_TasksPendingQueue.counter}`;
|
|
}
|
|
};
|
|
TasksPendingQueue = _TasksPendingQueue;
|
|
TasksPendingQueue.counter = 0;
|
|
}
|
|
});
|
|
function pluginContext(task, commands) {
|
|
return {
|
|
method: first(task.commands) || "",
|
|
commands
|
|
};
|
|
}
|
|
function onErrorReceived(target, logger) {
|
|
return (err) => {
|
|
logger(`[ERROR] child process exception %o`, err);
|
|
target.push(Buffer2.from(String(err.stack), "ascii"));
|
|
};
|
|
}
|
|
function onDataReceived(target, name, logger, output) {
|
|
return (buffer2) => {
|
|
logger(`%s received %L bytes`, name, buffer2);
|
|
output(`%B`, buffer2);
|
|
target.push(buffer2);
|
|
};
|
|
}
|
|
var GitExecutorChain;
|
|
var init_git_executor_chain = __esm2({
|
|
"src/lib/runners/git-executor-chain.ts"() {
|
|
init_git_error();
|
|
init_task();
|
|
init_utils();
|
|
init_tasks_pending_queue();
|
|
GitExecutorChain = class {
|
|
constructor(_executor, _scheduler, _plugins) {
|
|
this._executor = _executor;
|
|
this._scheduler = _scheduler;
|
|
this._plugins = _plugins;
|
|
this._chain = Promise.resolve();
|
|
this._queue = new TasksPendingQueue();
|
|
}
|
|
get binary() {
|
|
return this._executor.binary;
|
|
}
|
|
get cwd() {
|
|
return this._cwd || this._executor.cwd;
|
|
}
|
|
set cwd(cwd) {
|
|
this._cwd = cwd;
|
|
}
|
|
get env() {
|
|
return this._executor.env;
|
|
}
|
|
get outputHandler() {
|
|
return this._executor.outputHandler;
|
|
}
|
|
chain() {
|
|
return this;
|
|
}
|
|
push(task) {
|
|
this._queue.push(task);
|
|
return this._chain = this._chain.then(() => this.attemptTask(task));
|
|
}
|
|
attemptTask(task) {
|
|
return __async(this, null, function* () {
|
|
const onScheduleComplete = yield this._scheduler.next();
|
|
const onQueueComplete = () => this._queue.complete(task);
|
|
try {
|
|
const { logger } = this._queue.attempt(task);
|
|
return yield isEmptyTask(task) ? this.attemptEmptyTask(task, logger) : this.attemptRemoteTask(task, logger);
|
|
} catch (e) {
|
|
throw this.onFatalException(task, e);
|
|
} finally {
|
|
onQueueComplete();
|
|
onScheduleComplete();
|
|
}
|
|
});
|
|
}
|
|
onFatalException(task, e) {
|
|
const gitError = e instanceof GitError ? Object.assign(e, { task }) : new GitError(task, e && String(e));
|
|
this._chain = Promise.resolve();
|
|
this._queue.fatal(gitError);
|
|
return gitError;
|
|
}
|
|
attemptRemoteTask(task, logger) {
|
|
return __async(this, null, function* () {
|
|
const args = this._plugins.exec("spawn.args", [...task.commands], pluginContext(task, task.commands));
|
|
const raw = yield this.gitResponse(task, this.binary, args, this.outputHandler, logger.step("SPAWN"));
|
|
const outputStreams = yield this.handleTaskData(task, args, raw, logger.step("HANDLE"));
|
|
logger(`passing response to task's parser as a %s`, task.format);
|
|
if (isBufferTask(task)) {
|
|
return callTaskParser(task.parser, outputStreams);
|
|
}
|
|
return callTaskParser(task.parser, outputStreams.asStrings());
|
|
});
|
|
}
|
|
attemptEmptyTask(task, logger) {
|
|
return __async(this, null, function* () {
|
|
logger(`empty task bypassing child process to call to task's parser`);
|
|
return task.parser(this);
|
|
});
|
|
}
|
|
handleTaskData(task, args, result, logger) {
|
|
const { exitCode, rejection, stdOut, stdErr } = result;
|
|
return new Promise((done, fail) => {
|
|
logger(`Preparing to handle process response exitCode=%d stdOut=`, exitCode);
|
|
const { error } = this._plugins.exec("task.error", { error: rejection }, __spreadValues(__spreadValues({}, pluginContext(task, args)), result));
|
|
if (error && task.onError) {
|
|
logger.info(`exitCode=%s handling with custom error handler`);
|
|
return task.onError(result, error, (newStdOut) => {
|
|
logger.info(`custom error handler treated as success`);
|
|
logger(`custom error returned a %s`, objectToString(newStdOut));
|
|
done(new GitOutputStreams(Array.isArray(newStdOut) ? Buffer2.concat(newStdOut) : newStdOut, Buffer2.concat(stdErr)));
|
|
}, fail);
|
|
}
|
|
if (error) {
|
|
logger.info(`handling as error: exitCode=%s stdErr=%s rejection=%o`, exitCode, stdErr.length, rejection);
|
|
return fail(error);
|
|
}
|
|
logger.info(`retrieving task output complete`);
|
|
done(new GitOutputStreams(Buffer2.concat(stdOut), Buffer2.concat(stdErr)));
|
|
});
|
|
}
|
|
gitResponse(task, command, args, outputHandler, logger) {
|
|
return __async(this, null, function* () {
|
|
const outputLogger = logger.sibling("output");
|
|
const spawnOptions = this._plugins.exec("spawn.options", {
|
|
cwd: this.cwd,
|
|
env: this.env,
|
|
windowsHide: true
|
|
}, pluginContext(task, task.commands));
|
|
return new Promise((done) => {
|
|
const stdOut = [];
|
|
const stdErr = [];
|
|
logger.info(`%s %o`, command, args);
|
|
logger("%O", spawnOptions);
|
|
let rejection = this._beforeSpawn(task, args);
|
|
if (rejection) {
|
|
return done({
|
|
stdOut,
|
|
stdErr,
|
|
exitCode: 9901,
|
|
rejection
|
|
});
|
|
}
|
|
this._plugins.exec("spawn.before", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), {
|
|
kill(reason) {
|
|
rejection = reason || rejection;
|
|
}
|
|
}));
|
|
const spawned = (0, import_child_process.spawn)(command, args, spawnOptions);
|
|
spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut")));
|
|
spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr")));
|
|
spawned.on("error", onErrorReceived(stdErr, logger));
|
|
if (outputHandler) {
|
|
logger(`Passing child process stdOut/stdErr to custom outputHandler`);
|
|
outputHandler(command, spawned.stdout, spawned.stderr, [...args]);
|
|
}
|
|
this._plugins.exec("spawn.after", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), {
|
|
spawned,
|
|
close(exitCode, reason) {
|
|
done({
|
|
stdOut,
|
|
stdErr,
|
|
exitCode,
|
|
rejection: rejection || reason
|
|
});
|
|
},
|
|
kill(reason) {
|
|
if (spawned.killed) {
|
|
return;
|
|
}
|
|
rejection = reason;
|
|
spawned.kill("SIGINT");
|
|
}
|
|
}));
|
|
});
|
|
});
|
|
}
|
|
_beforeSpawn(task, args) {
|
|
let rejection;
|
|
this._plugins.exec("spawn.before", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), {
|
|
kill(reason) {
|
|
rejection = reason || rejection;
|
|
}
|
|
}));
|
|
return rejection;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var git_executor_exports = {};
|
|
__export2(git_executor_exports, {
|
|
GitExecutor: () => GitExecutor
|
|
});
|
|
var GitExecutor;
|
|
var init_git_executor = __esm2({
|
|
"src/lib/runners/git-executor.ts"() {
|
|
init_git_executor_chain();
|
|
GitExecutor = class {
|
|
constructor(binary = "git", cwd, _scheduler, _plugins) {
|
|
this.binary = binary;
|
|
this.cwd = cwd;
|
|
this._scheduler = _scheduler;
|
|
this._plugins = _plugins;
|
|
this._chain = new GitExecutorChain(this, this._scheduler, this._plugins);
|
|
}
|
|
chain() {
|
|
return new GitExecutorChain(this, this._scheduler, this._plugins);
|
|
}
|
|
push(task) {
|
|
return this._chain.push(task);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function taskCallback(task, response, callback = NOOP) {
|
|
const onSuccess = (data) => {
|
|
callback(null, data);
|
|
};
|
|
const onError2 = (err) => {
|
|
if ((err == null ? void 0 : err.task) === task) {
|
|
callback(err instanceof GitResponseError ? addDeprecationNoticeToError(err) : err, void 0);
|
|
}
|
|
};
|
|
response.then(onSuccess, onError2);
|
|
}
|
|
function addDeprecationNoticeToError(err) {
|
|
let log2 = (name) => {
|
|
console.warn(`simple-git deprecation notice: accessing GitResponseError.${name} should be GitResponseError.git.${name}, this will no longer be available in version 3`);
|
|
log2 = NOOP;
|
|
};
|
|
return Object.create(err, Object.getOwnPropertyNames(err.git).reduce(descriptorReducer, {}));
|
|
function descriptorReducer(all, name) {
|
|
if (name in err) {
|
|
return all;
|
|
}
|
|
all[name] = {
|
|
enumerable: false,
|
|
configurable: false,
|
|
get() {
|
|
log2(name);
|
|
return err.git[name];
|
|
}
|
|
};
|
|
return all;
|
|
}
|
|
}
|
|
var init_task_callback = __esm2({
|
|
"src/lib/task-callback.ts"() {
|
|
init_git_response_error();
|
|
init_utils();
|
|
}
|
|
});
|
|
function changeWorkingDirectoryTask(directory, root) {
|
|
return adhocExecTask((instance6) => {
|
|
if (!folderExists(directory)) {
|
|
throw new Error(`Git.cwd: cannot change to non-directory "${directory}"`);
|
|
}
|
|
return (root || instance6).cwd = directory;
|
|
});
|
|
}
|
|
var init_change_working_directory = __esm2({
|
|
"src/lib/tasks/change-working-directory.ts"() {
|
|
init_utils();
|
|
init_task();
|
|
}
|
|
});
|
|
function parseCommitResult(stdOut) {
|
|
const result = {
|
|
author: null,
|
|
branch: "",
|
|
commit: "",
|
|
root: false,
|
|
summary: {
|
|
changes: 0,
|
|
insertions: 0,
|
|
deletions: 0
|
|
}
|
|
};
|
|
return parseStringResponse(result, parsers, stdOut);
|
|
}
|
|
var parsers;
|
|
var init_parse_commit = __esm2({
|
|
"src/lib/parsers/parse-commit.ts"() {
|
|
init_utils();
|
|
parsers = [
|
|
new LineParser(/^\[([^\s]+)( \([^)]+\))? ([^\]]+)/, (result, [branch2, root, commit2]) => {
|
|
result.branch = branch2;
|
|
result.commit = commit2;
|
|
result.root = !!root;
|
|
}),
|
|
new LineParser(/\s*Author:\s(.+)/i, (result, [author]) => {
|
|
const parts = author.split("<");
|
|
const email = parts.pop();
|
|
if (!email || !email.includes("@")) {
|
|
return;
|
|
}
|
|
result.author = {
|
|
email: email.substr(0, email.length - 1),
|
|
name: parts.join("<").trim()
|
|
};
|
|
}),
|
|
new LineParser(/(\d+)[^,]*(?:,\s*(\d+)[^,]*)(?:,\s*(\d+))/g, (result, [changes, insertions, deletions]) => {
|
|
result.summary.changes = parseInt(changes, 10) || 0;
|
|
result.summary.insertions = parseInt(insertions, 10) || 0;
|
|
result.summary.deletions = parseInt(deletions, 10) || 0;
|
|
}),
|
|
new LineParser(/^(\d+)[^,]*(?:,\s*(\d+)[^(]+\(([+-]))?/, (result, [changes, lines, direction]) => {
|
|
result.summary.changes = parseInt(changes, 10) || 0;
|
|
const count = parseInt(lines, 10) || 0;
|
|
if (direction === "-") {
|
|
result.summary.deletions = count;
|
|
} else if (direction === "+") {
|
|
result.summary.insertions = count;
|
|
}
|
|
})
|
|
];
|
|
}
|
|
});
|
|
var commit_exports = {};
|
|
__export2(commit_exports, {
|
|
commitTask: () => commitTask,
|
|
default: () => commit_default
|
|
});
|
|
function commitTask(message, files, customArgs) {
|
|
const commands = [
|
|
"-c",
|
|
"core.abbrev=40",
|
|
"commit",
|
|
...prefixedArray(message, "-m"),
|
|
...files,
|
|
...customArgs
|
|
];
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser: parseCommitResult
|
|
};
|
|
}
|
|
function commit_default() {
|
|
return {
|
|
commit(message, ...rest) {
|
|
const next = trailingFunctionArgument(arguments);
|
|
const task = rejectDeprecatedSignatures(message) || commitTask(asArray(message), asArray(filterType(rest[0], filterStringOrStringArray, [])), [...filterType(rest[1], filterArray, []), ...getTrailingOptions(arguments, 0, true)]);
|
|
return this._runTask(task, next);
|
|
}
|
|
};
|
|
function rejectDeprecatedSignatures(message) {
|
|
return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`);
|
|
}
|
|
}
|
|
var init_commit = __esm2({
|
|
"src/lib/tasks/commit.ts"() {
|
|
init_parse_commit();
|
|
init_utils();
|
|
init_task();
|
|
}
|
|
});
|
|
function hashObjectTask(filePath, write) {
|
|
const commands = ["hash-object", filePath];
|
|
if (write) {
|
|
commands.push("-w");
|
|
}
|
|
return straightThroughStringTask(commands, true);
|
|
}
|
|
var init_hash_object = __esm2({
|
|
"src/lib/tasks/hash-object.ts"() {
|
|
init_task();
|
|
}
|
|
});
|
|
function parseInit(bare, path2, text2) {
|
|
const response = String(text2).trim();
|
|
let result;
|
|
if (result = initResponseRegex.exec(response)) {
|
|
return new InitSummary(bare, path2, false, result[1]);
|
|
}
|
|
if (result = reInitResponseRegex.exec(response)) {
|
|
return new InitSummary(bare, path2, true, result[1]);
|
|
}
|
|
let gitDir = "";
|
|
const tokens = response.split(" ");
|
|
while (tokens.length) {
|
|
const token = tokens.shift();
|
|
if (token === "in") {
|
|
gitDir = tokens.join(" ");
|
|
break;
|
|
}
|
|
}
|
|
return new InitSummary(bare, path2, /^re/i.test(response), gitDir);
|
|
}
|
|
var InitSummary;
|
|
var initResponseRegex;
|
|
var reInitResponseRegex;
|
|
var init_InitSummary = __esm2({
|
|
"src/lib/responses/InitSummary.ts"() {
|
|
InitSummary = class {
|
|
constructor(bare, path2, existing, gitDir) {
|
|
this.bare = bare;
|
|
this.path = path2;
|
|
this.existing = existing;
|
|
this.gitDir = gitDir;
|
|
}
|
|
};
|
|
initResponseRegex = /^Init.+ repository in (.+)$/;
|
|
reInitResponseRegex = /^Rein.+ in (.+)$/;
|
|
}
|
|
});
|
|
function hasBareCommand(command) {
|
|
return command.includes(bareCommand);
|
|
}
|
|
function initTask(bare = false, path2, customArgs) {
|
|
const commands = ["init", ...customArgs];
|
|
if (bare && !hasBareCommand(commands)) {
|
|
commands.splice(1, 0, bareCommand);
|
|
}
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser(text2) {
|
|
return parseInit(commands.includes("--bare"), path2, text2);
|
|
}
|
|
};
|
|
}
|
|
var bareCommand;
|
|
var init_init = __esm2({
|
|
"src/lib/tasks/init.ts"() {
|
|
init_InitSummary();
|
|
bareCommand = "--bare";
|
|
}
|
|
});
|
|
function logFormatFromCommand(customArgs) {
|
|
for (let i = 0; i < customArgs.length; i++) {
|
|
const format = logFormatRegex.exec(customArgs[i]);
|
|
if (format) {
|
|
return `--${format[1]}`;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
function isLogFormat(customArg) {
|
|
return logFormatRegex.test(customArg);
|
|
}
|
|
var logFormatRegex;
|
|
var init_log_format = __esm2({
|
|
"src/lib/args/log-format.ts"() {
|
|
logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/;
|
|
}
|
|
});
|
|
var DiffSummary;
|
|
var init_DiffSummary = __esm2({
|
|
"src/lib/responses/DiffSummary.ts"() {
|
|
DiffSummary = class {
|
|
constructor() {
|
|
this.changed = 0;
|
|
this.deletions = 0;
|
|
this.insertions = 0;
|
|
this.files = [];
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function getDiffParser(format = "") {
|
|
const parser3 = diffSummaryParsers[format];
|
|
return (stdOut) => parseStringResponse(new DiffSummary(), parser3, stdOut, false);
|
|
}
|
|
var statParser;
|
|
var numStatParser;
|
|
var nameOnlyParser;
|
|
var nameStatusParser;
|
|
var diffSummaryParsers;
|
|
var init_parse_diff_summary = __esm2({
|
|
"src/lib/parsers/parse-diff-summary.ts"() {
|
|
init_log_format();
|
|
init_DiffSummary();
|
|
init_utils();
|
|
statParser = [
|
|
new LineParser(/(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/, (result, [file, changes, alterations = ""]) => {
|
|
result.files.push({
|
|
file: file.trim(),
|
|
changes: asNumber(changes),
|
|
insertions: alterations.replace(/[^+]/g, "").length,
|
|
deletions: alterations.replace(/[^-]/g, "").length,
|
|
binary: false
|
|
});
|
|
}),
|
|
new LineParser(/(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)/, (result, [file, before, after]) => {
|
|
result.files.push({
|
|
file: file.trim(),
|
|
before: asNumber(before),
|
|
after: asNumber(after),
|
|
binary: true
|
|
});
|
|
}),
|
|
new LineParser(/(\d+) files? changed\s*((?:, \d+ [^,]+){0,2})/, (result, [changed, summary]) => {
|
|
const inserted = /(\d+) i/.exec(summary);
|
|
const deleted = /(\d+) d/.exec(summary);
|
|
result.changed = asNumber(changed);
|
|
result.insertions = asNumber(inserted == null ? void 0 : inserted[1]);
|
|
result.deletions = asNumber(deleted == null ? void 0 : deleted[1]);
|
|
})
|
|
];
|
|
numStatParser = [
|
|
new LineParser(/(\d+)\t(\d+)\t(.+)$/, (result, [changesInsert, changesDelete, file]) => {
|
|
const insertions = asNumber(changesInsert);
|
|
const deletions = asNumber(changesDelete);
|
|
result.changed++;
|
|
result.insertions += insertions;
|
|
result.deletions += deletions;
|
|
result.files.push({
|
|
file,
|
|
changes: insertions + deletions,
|
|
insertions,
|
|
deletions,
|
|
binary: false
|
|
});
|
|
}),
|
|
new LineParser(/-\t-\t(.+)$/, (result, [file]) => {
|
|
result.changed++;
|
|
result.files.push({
|
|
file,
|
|
after: 0,
|
|
before: 0,
|
|
binary: true
|
|
});
|
|
})
|
|
];
|
|
nameOnlyParser = [
|
|
new LineParser(/(.+)$/, (result, [file]) => {
|
|
result.changed++;
|
|
result.files.push({
|
|
file,
|
|
changes: 0,
|
|
insertions: 0,
|
|
deletions: 0,
|
|
binary: false
|
|
});
|
|
})
|
|
];
|
|
nameStatusParser = [
|
|
new LineParser(/([ACDMRTUXB])\s*(.+)$/, (result, [_status, file]) => {
|
|
result.changed++;
|
|
result.files.push({
|
|
file,
|
|
changes: 0,
|
|
insertions: 0,
|
|
deletions: 0,
|
|
binary: false
|
|
});
|
|
})
|
|
];
|
|
diffSummaryParsers = {
|
|
[""]: statParser,
|
|
["--stat"]: statParser,
|
|
["--numstat"]: numStatParser,
|
|
["--name-status"]: nameStatusParser,
|
|
["--name-only"]: nameOnlyParser
|
|
};
|
|
}
|
|
});
|
|
function lineBuilder(tokens, fields) {
|
|
return fields.reduce((line, field, index2) => {
|
|
line[field] = tokens[index2] || "";
|
|
return line;
|
|
}, /* @__PURE__ */ Object.create({ diff: null }));
|
|
}
|
|
function createListLogSummaryParser(splitter = SPLITTER, fields = defaultFieldNames, logFormat = "") {
|
|
const parseDiffResult = getDiffParser(logFormat);
|
|
return function(stdOut) {
|
|
const all = toLinesWithContent(stdOut, true, START_BOUNDARY).map(function(item) {
|
|
const lineDetail = item.trim().split(COMMIT_BOUNDARY);
|
|
const listLogLine = lineBuilder(lineDetail[0].trim().split(splitter), fields);
|
|
if (lineDetail.length > 1 && !!lineDetail[1].trim()) {
|
|
listLogLine.diff = parseDiffResult(lineDetail[1]);
|
|
}
|
|
return listLogLine;
|
|
});
|
|
return {
|
|
all,
|
|
latest: all.length && all[0] || null,
|
|
total: all.length
|
|
};
|
|
};
|
|
}
|
|
var START_BOUNDARY;
|
|
var COMMIT_BOUNDARY;
|
|
var SPLITTER;
|
|
var defaultFieldNames;
|
|
var init_parse_list_log_summary = __esm2({
|
|
"src/lib/parsers/parse-list-log-summary.ts"() {
|
|
init_utils();
|
|
init_parse_diff_summary();
|
|
init_log_format();
|
|
START_BOUNDARY = "\xF2\xF2\xF2\xF2\xF2\xF2 ";
|
|
COMMIT_BOUNDARY = " \xF2\xF2";
|
|
SPLITTER = " \xF2 ";
|
|
defaultFieldNames = ["hash", "date", "message", "refs", "author_name", "author_email"];
|
|
}
|
|
});
|
|
var diff_exports = {};
|
|
__export2(diff_exports, {
|
|
diffSummaryTask: () => diffSummaryTask,
|
|
validateLogFormatConfig: () => validateLogFormatConfig
|
|
});
|
|
function diffSummaryTask(customArgs) {
|
|
let logFormat = logFormatFromCommand(customArgs);
|
|
const commands = ["diff"];
|
|
if (logFormat === "") {
|
|
logFormat = "--stat";
|
|
commands.push("--stat=4096");
|
|
}
|
|
commands.push(...customArgs);
|
|
return validateLogFormatConfig(commands) || {
|
|
commands,
|
|
format: "utf-8",
|
|
parser: getDiffParser(logFormat)
|
|
};
|
|
}
|
|
function validateLogFormatConfig(customArgs) {
|
|
const flags = customArgs.filter(isLogFormat);
|
|
if (flags.length > 1) {
|
|
return configurationErrorTask(`Summary flags are mutually exclusive - pick one of ${flags.join(",")}`);
|
|
}
|
|
if (flags.length && customArgs.includes("-z")) {
|
|
return configurationErrorTask(`Summary flag ${flags} parsing is not compatible with null termination option '-z'`);
|
|
}
|
|
}
|
|
var init_diff = __esm2({
|
|
"src/lib/tasks/diff.ts"() {
|
|
init_log_format();
|
|
init_parse_diff_summary();
|
|
init_task();
|
|
}
|
|
});
|
|
function prettyFormat(format, splitter) {
|
|
const fields = [];
|
|
const formatStr = [];
|
|
Object.keys(format).forEach((field) => {
|
|
fields.push(field);
|
|
formatStr.push(String(format[field]));
|
|
});
|
|
return [fields, formatStr.join(splitter)];
|
|
}
|
|
function userOptions(input) {
|
|
return Object.keys(input).reduce((out, key2) => {
|
|
if (!(key2 in excludeOptions)) {
|
|
out[key2] = input[key2];
|
|
}
|
|
return out;
|
|
}, {});
|
|
}
|
|
function parseLogOptions(opt = {}, customArgs = []) {
|
|
const splitter = filterType(opt.splitter, filterString, SPLITTER);
|
|
const format = !filterPrimitives(opt.format) && opt.format ? opt.format : {
|
|
hash: "%H",
|
|
date: opt.strictDate === false ? "%ai" : "%aI",
|
|
message: "%s",
|
|
refs: "%D",
|
|
body: opt.multiLine ? "%B" : "%b",
|
|
author_name: opt.mailMap !== false ? "%aN" : "%an",
|
|
author_email: opt.mailMap !== false ? "%aE" : "%ae"
|
|
};
|
|
const [fields, formatStr] = prettyFormat(format, splitter);
|
|
const suffix = [];
|
|
const command = [
|
|
`--pretty=format:${START_BOUNDARY}${formatStr}${COMMIT_BOUNDARY}`,
|
|
...customArgs
|
|
];
|
|
const maxCount = opt.n || opt["max-count"] || opt.maxCount;
|
|
if (maxCount) {
|
|
command.push(`--max-count=${maxCount}`);
|
|
}
|
|
if (opt.from || opt.to) {
|
|
const rangeOperator = opt.symmetric !== false ? "..." : "..";
|
|
suffix.push(`${opt.from || ""}${rangeOperator}${opt.to || ""}`);
|
|
}
|
|
if (filterString(opt.file)) {
|
|
suffix.push("--follow", opt.file);
|
|
}
|
|
appendTaskOptions(userOptions(opt), command);
|
|
return {
|
|
fields,
|
|
splitter,
|
|
commands: [...command, ...suffix]
|
|
};
|
|
}
|
|
function logTask(splitter, fields, customArgs) {
|
|
const parser3 = createListLogSummaryParser(splitter, fields, logFormatFromCommand(customArgs));
|
|
return {
|
|
commands: ["log", ...customArgs],
|
|
format: "utf-8",
|
|
parser: parser3
|
|
};
|
|
}
|
|
function log_default() {
|
|
return {
|
|
log(...rest) {
|
|
const next = trailingFunctionArgument(arguments);
|
|
const options = parseLogOptions(trailingOptionsArgument(arguments), filterType(arguments[0], filterArray));
|
|
const task = rejectDeprecatedSignatures(...rest) || validateLogFormatConfig(options.commands) || createLogTask(options);
|
|
return this._runTask(task, next);
|
|
}
|
|
};
|
|
function createLogTask(options) {
|
|
return logTask(options.splitter, options.fields, options.commands);
|
|
}
|
|
function rejectDeprecatedSignatures(from, to) {
|
|
return filterString(from) && filterString(to) && configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`);
|
|
}
|
|
}
|
|
var excludeOptions;
|
|
var init_log = __esm2({
|
|
"src/lib/tasks/log.ts"() {
|
|
init_log_format();
|
|
init_parse_list_log_summary();
|
|
init_utils();
|
|
init_task();
|
|
init_diff();
|
|
excludeOptions = /* @__PURE__ */ ((excludeOptions2) => {
|
|
excludeOptions2[excludeOptions2["--pretty"] = 0] = "--pretty";
|
|
excludeOptions2[excludeOptions2["max-count"] = 1] = "max-count";
|
|
excludeOptions2[excludeOptions2["maxCount"] = 2] = "maxCount";
|
|
excludeOptions2[excludeOptions2["n"] = 3] = "n";
|
|
excludeOptions2[excludeOptions2["file"] = 4] = "file";
|
|
excludeOptions2[excludeOptions2["format"] = 5] = "format";
|
|
excludeOptions2[excludeOptions2["from"] = 6] = "from";
|
|
excludeOptions2[excludeOptions2["to"] = 7] = "to";
|
|
excludeOptions2[excludeOptions2["splitter"] = 8] = "splitter";
|
|
excludeOptions2[excludeOptions2["symmetric"] = 9] = "symmetric";
|
|
excludeOptions2[excludeOptions2["mailMap"] = 10] = "mailMap";
|
|
excludeOptions2[excludeOptions2["multiLine"] = 11] = "multiLine";
|
|
excludeOptions2[excludeOptions2["strictDate"] = 12] = "strictDate";
|
|
return excludeOptions2;
|
|
})(excludeOptions || {});
|
|
}
|
|
});
|
|
var MergeSummaryConflict;
|
|
var MergeSummaryDetail;
|
|
var init_MergeSummary = __esm2({
|
|
"src/lib/responses/MergeSummary.ts"() {
|
|
MergeSummaryConflict = class {
|
|
constructor(reason, file = null, meta) {
|
|
this.reason = reason;
|
|
this.file = file;
|
|
this.meta = meta;
|
|
}
|
|
toString() {
|
|
return `${this.file}:${this.reason}`;
|
|
}
|
|
};
|
|
MergeSummaryDetail = class {
|
|
constructor() {
|
|
this.conflicts = [];
|
|
this.merges = [];
|
|
this.result = "success";
|
|
}
|
|
get failed() {
|
|
return this.conflicts.length > 0;
|
|
}
|
|
get reason() {
|
|
return this.result;
|
|
}
|
|
toString() {
|
|
if (this.conflicts.length) {
|
|
return `CONFLICTS: ${this.conflicts.join(", ")}`;
|
|
}
|
|
return "OK";
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var PullSummary;
|
|
var PullFailedSummary;
|
|
var init_PullSummary = __esm2({
|
|
"src/lib/responses/PullSummary.ts"() {
|
|
PullSummary = class {
|
|
constructor() {
|
|
this.remoteMessages = {
|
|
all: []
|
|
};
|
|
this.created = [];
|
|
this.deleted = [];
|
|
this.files = [];
|
|
this.deletions = {};
|
|
this.insertions = {};
|
|
this.summary = {
|
|
changes: 0,
|
|
deletions: 0,
|
|
insertions: 0
|
|
};
|
|
}
|
|
};
|
|
PullFailedSummary = class {
|
|
constructor() {
|
|
this.remote = "";
|
|
this.hash = {
|
|
local: "",
|
|
remote: ""
|
|
};
|
|
this.branch = {
|
|
local: "",
|
|
remote: ""
|
|
};
|
|
this.message = "";
|
|
}
|
|
toString() {
|
|
return this.message;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function objectEnumerationResult(remoteMessages) {
|
|
return remoteMessages.objects = remoteMessages.objects || {
|
|
compressing: 0,
|
|
counting: 0,
|
|
enumerating: 0,
|
|
packReused: 0,
|
|
reused: { count: 0, delta: 0 },
|
|
total: { count: 0, delta: 0 }
|
|
};
|
|
}
|
|
function asObjectCount(source) {
|
|
const count = /^\s*(\d+)/.exec(source);
|
|
const delta = /delta (\d+)/i.exec(source);
|
|
return {
|
|
count: asNumber(count && count[1] || "0"),
|
|
delta: asNumber(delta && delta[1] || "0")
|
|
};
|
|
}
|
|
var remoteMessagesObjectParsers;
|
|
var init_parse_remote_objects = __esm2({
|
|
"src/lib/parsers/parse-remote-objects.ts"() {
|
|
init_utils();
|
|
remoteMessagesObjectParsers = [
|
|
new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: (\d+),/i, (result, [action, count]) => {
|
|
const key2 = action.toLowerCase();
|
|
const enumeration = objectEnumerationResult(result.remoteMessages);
|
|
Object.assign(enumeration, { [key2]: asNumber(count) });
|
|
}),
|
|
new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: \d+% \(\d+\/(\d+)\),/i, (result, [action, count]) => {
|
|
const key2 = action.toLowerCase();
|
|
const enumeration = objectEnumerationResult(result.remoteMessages);
|
|
Object.assign(enumeration, { [key2]: asNumber(count) });
|
|
}),
|
|
new RemoteLineParser(/total ([^,]+), reused ([^,]+), pack-reused (\d+)/i, (result, [total, reused, packReused]) => {
|
|
const objects = objectEnumerationResult(result.remoteMessages);
|
|
objects.total = asObjectCount(total);
|
|
objects.reused = asObjectCount(reused);
|
|
objects.packReused = asNumber(packReused);
|
|
})
|
|
];
|
|
}
|
|
});
|
|
function parseRemoteMessages(_stdOut, stdErr) {
|
|
return parseStringResponse({ remoteMessages: new RemoteMessageSummary() }, parsers2, stdErr);
|
|
}
|
|
var parsers2;
|
|
var RemoteMessageSummary;
|
|
var init_parse_remote_messages = __esm2({
|
|
"src/lib/parsers/parse-remote-messages.ts"() {
|
|
init_utils();
|
|
init_parse_remote_objects();
|
|
parsers2 = [
|
|
new RemoteLineParser(/^remote:\s*(.+)$/, (result, [text2]) => {
|
|
result.remoteMessages.all.push(text2.trim());
|
|
return false;
|
|
}),
|
|
...remoteMessagesObjectParsers,
|
|
new RemoteLineParser([/create a (?:pull|merge) request/i, /\s(https?:\/\/\S+)$/], (result, [pullRequestUrl]) => {
|
|
result.remoteMessages.pullRequestUrl = pullRequestUrl;
|
|
}),
|
|
new RemoteLineParser([/found (\d+) vulnerabilities.+\(([^)]+)\)/i, /\s(https?:\/\/\S+)$/], (result, [count, summary, url]) => {
|
|
result.remoteMessages.vulnerabilities = {
|
|
count: asNumber(count),
|
|
summary,
|
|
url
|
|
};
|
|
})
|
|
];
|
|
RemoteMessageSummary = class {
|
|
constructor() {
|
|
this.all = [];
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function parsePullErrorResult(stdOut, stdErr) {
|
|
const pullError = parseStringResponse(new PullFailedSummary(), errorParsers, [stdOut, stdErr]);
|
|
return pullError.message && pullError;
|
|
}
|
|
var FILE_UPDATE_REGEX;
|
|
var SUMMARY_REGEX;
|
|
var ACTION_REGEX;
|
|
var parsers3;
|
|
var errorParsers;
|
|
var parsePullDetail;
|
|
var parsePullResult;
|
|
var init_parse_pull = __esm2({
|
|
"src/lib/parsers/parse-pull.ts"() {
|
|
init_PullSummary();
|
|
init_utils();
|
|
init_parse_remote_messages();
|
|
FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/;
|
|
SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/;
|
|
ACTION_REGEX = /^(create|delete) mode \d+ (.+)/;
|
|
parsers3 = [
|
|
new LineParser(FILE_UPDATE_REGEX, (result, [file, insertions, deletions]) => {
|
|
result.files.push(file);
|
|
if (insertions) {
|
|
result.insertions[file] = insertions.length;
|
|
}
|
|
if (deletions) {
|
|
result.deletions[file] = deletions.length;
|
|
}
|
|
}),
|
|
new LineParser(SUMMARY_REGEX, (result, [changes, , insertions, , deletions]) => {
|
|
if (insertions !== void 0 || deletions !== void 0) {
|
|
result.summary.changes = +changes || 0;
|
|
result.summary.insertions = +insertions || 0;
|
|
result.summary.deletions = +deletions || 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}),
|
|
new LineParser(ACTION_REGEX, (result, [action, file]) => {
|
|
append(result.files, file);
|
|
append(action === "create" ? result.created : result.deleted, file);
|
|
})
|
|
];
|
|
errorParsers = [
|
|
new LineParser(/^from\s(.+)$/i, (result, [remote]) => void (result.remote = remote)),
|
|
new LineParser(/^fatal:\s(.+)$/, (result, [message]) => void (result.message = message)),
|
|
new LineParser(/([a-z0-9]+)\.\.([a-z0-9]+)\s+(\S+)\s+->\s+(\S+)$/, (result, [hashLocal, hashRemote, branchLocal, branchRemote]) => {
|
|
result.branch.local = branchLocal;
|
|
result.hash.local = hashLocal;
|
|
result.branch.remote = branchRemote;
|
|
result.hash.remote = hashRemote;
|
|
})
|
|
];
|
|
parsePullDetail = (stdOut, stdErr) => {
|
|
return parseStringResponse(new PullSummary(), parsers3, [stdOut, stdErr]);
|
|
};
|
|
parsePullResult = (stdOut, stdErr) => {
|
|
return Object.assign(new PullSummary(), parsePullDetail(stdOut, stdErr), parseRemoteMessages(stdOut, stdErr));
|
|
};
|
|
}
|
|
});
|
|
var parsers4;
|
|
var parseMergeResult;
|
|
var parseMergeDetail;
|
|
var init_parse_merge = __esm2({
|
|
"src/lib/parsers/parse-merge.ts"() {
|
|
init_MergeSummary();
|
|
init_utils();
|
|
init_parse_pull();
|
|
parsers4 = [
|
|
new LineParser(/^Auto-merging\s+(.+)$/, (summary, [autoMerge]) => {
|
|
summary.merges.push(autoMerge);
|
|
}),
|
|
new LineParser(/^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/, (summary, [reason, file]) => {
|
|
summary.conflicts.push(new MergeSummaryConflict(reason, file));
|
|
}),
|
|
new LineParser(/^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/, (summary, [reason, file, deleteRef2]) => {
|
|
summary.conflicts.push(new MergeSummaryConflict(reason, file, { deleteRef: deleteRef2 }));
|
|
}),
|
|
new LineParser(/^CONFLICT\s+\((.+)\):/, (summary, [reason]) => {
|
|
summary.conflicts.push(new MergeSummaryConflict(reason, null));
|
|
}),
|
|
new LineParser(/^Automatic merge failed;\s+(.+)$/, (summary, [result]) => {
|
|
summary.result = result;
|
|
})
|
|
];
|
|
parseMergeResult = (stdOut, stdErr) => {
|
|
return Object.assign(parseMergeDetail(stdOut, stdErr), parsePullResult(stdOut, stdErr));
|
|
};
|
|
parseMergeDetail = (stdOut) => {
|
|
return parseStringResponse(new MergeSummaryDetail(), parsers4, stdOut);
|
|
};
|
|
}
|
|
});
|
|
function mergeTask(customArgs) {
|
|
if (!customArgs.length) {
|
|
return configurationErrorTask("Git.merge requires at least one option");
|
|
}
|
|
return {
|
|
commands: ["merge", ...customArgs],
|
|
format: "utf-8",
|
|
parser(stdOut, stdErr) {
|
|
const merge2 = parseMergeResult(stdOut, stdErr);
|
|
if (merge2.failed) {
|
|
throw new GitResponseError(merge2);
|
|
}
|
|
return merge2;
|
|
}
|
|
};
|
|
}
|
|
var init_merge = __esm2({
|
|
"src/lib/tasks/merge.ts"() {
|
|
init_git_response_error();
|
|
init_parse_merge();
|
|
init_task();
|
|
}
|
|
});
|
|
function pushResultPushedItem(local, remote, status2) {
|
|
const deleted = status2.includes("deleted");
|
|
const tag2 = status2.includes("tag") || /^refs\/tags/.test(local);
|
|
const alreadyUpdated = !status2.includes("new");
|
|
return {
|
|
deleted,
|
|
tag: tag2,
|
|
branch: !tag2,
|
|
new: !alreadyUpdated,
|
|
alreadyUpdated,
|
|
local,
|
|
remote
|
|
};
|
|
}
|
|
var parsers5;
|
|
var parsePushResult;
|
|
var parsePushDetail;
|
|
var init_parse_push = __esm2({
|
|
"src/lib/parsers/parse-push.ts"() {
|
|
init_utils();
|
|
init_parse_remote_messages();
|
|
parsers5 = [
|
|
new LineParser(/^Pushing to (.+)$/, (result, [repo]) => {
|
|
result.repo = repo;
|
|
}),
|
|
new LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => {
|
|
result.ref = __spreadProps(__spreadValues({}, result.ref || {}), {
|
|
local
|
|
});
|
|
}),
|
|
new LineParser(/^[*-=]\s+([^:]+):(\S+)\s+\[(.+)]$/, (result, [local, remote, type]) => {
|
|
result.pushed.push(pushResultPushedItem(local, remote, type));
|
|
}),
|
|
new LineParser(/^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/, (result, [local, remote, remoteName]) => {
|
|
result.branch = __spreadProps(__spreadValues({}, result.branch || {}), {
|
|
local,
|
|
remote,
|
|
remoteName
|
|
});
|
|
}),
|
|
new LineParser(/^([^:]+):(\S+)\s+([a-z0-9]+)\.\.([a-z0-9]+)$/, (result, [local, remote, from, to]) => {
|
|
result.update = {
|
|
head: {
|
|
local,
|
|
remote
|
|
},
|
|
hash: {
|
|
from,
|
|
to
|
|
}
|
|
};
|
|
})
|
|
];
|
|
parsePushResult = (stdOut, stdErr) => {
|
|
const pushDetail = parsePushDetail(stdOut, stdErr);
|
|
const responseDetail = parseRemoteMessages(stdOut, stdErr);
|
|
return __spreadValues(__spreadValues({}, pushDetail), responseDetail);
|
|
};
|
|
parsePushDetail = (stdOut, stdErr) => {
|
|
return parseStringResponse({ pushed: [] }, parsers5, [stdOut, stdErr]);
|
|
};
|
|
}
|
|
});
|
|
var push_exports = {};
|
|
__export2(push_exports, {
|
|
pushTagsTask: () => pushTagsTask,
|
|
pushTask: () => pushTask
|
|
});
|
|
function pushTagsTask(ref = {}, customArgs) {
|
|
append(customArgs, "--tags");
|
|
return pushTask(ref, customArgs);
|
|
}
|
|
function pushTask(ref = {}, customArgs) {
|
|
const commands = ["push", ...customArgs];
|
|
if (ref.branch) {
|
|
commands.splice(1, 0, ref.branch);
|
|
}
|
|
if (ref.remote) {
|
|
commands.splice(1, 0, ref.remote);
|
|
}
|
|
remove2(commands, "-v");
|
|
append(commands, "--verbose");
|
|
append(commands, "--porcelain");
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser: parsePushResult
|
|
};
|
|
}
|
|
var init_push = __esm2({
|
|
"src/lib/tasks/push.ts"() {
|
|
init_parse_push();
|
|
init_utils();
|
|
}
|
|
});
|
|
var fromPathRegex;
|
|
var FileStatusSummary;
|
|
var init_FileStatusSummary = __esm2({
|
|
"src/lib/responses/FileStatusSummary.ts"() {
|
|
fromPathRegex = /^(.+) -> (.+)$/;
|
|
FileStatusSummary = class {
|
|
constructor(path2, index2, working_dir) {
|
|
this.path = path2;
|
|
this.index = index2;
|
|
this.working_dir = working_dir;
|
|
if (index2 + working_dir === "R") {
|
|
const detail = fromPathRegex.exec(path2) || [null, path2, path2];
|
|
this.from = detail[1] || "";
|
|
this.path = detail[2] || "";
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function renamedFile(line) {
|
|
const [to, from] = line.split(NULL);
|
|
return {
|
|
from: from || to,
|
|
to
|
|
};
|
|
}
|
|
function parser2(indexX, indexY, handler) {
|
|
return [`${indexX}${indexY}`, handler];
|
|
}
|
|
function conflicts(indexX, ...indexY) {
|
|
return indexY.map((y) => parser2(indexX, y, (result, file) => append(result.conflicted, file)));
|
|
}
|
|
function splitLine(result, lineStr) {
|
|
const trimmed2 = lineStr.trim();
|
|
switch (" ") {
|
|
case trimmed2.charAt(2):
|
|
return data(trimmed2.charAt(0), trimmed2.charAt(1), trimmed2.substr(3));
|
|
case trimmed2.charAt(1):
|
|
return data(" ", trimmed2.charAt(0), trimmed2.substr(2));
|
|
default:
|
|
return;
|
|
}
|
|
function data(index2, workingDir, path2) {
|
|
const raw = `${index2}${workingDir}`;
|
|
const handler = parsers6.get(raw);
|
|
if (handler) {
|
|
handler(result, path2);
|
|
}
|
|
if (raw !== "##" && raw !== "!!") {
|
|
result.files.push(new FileStatusSummary(path2.replace(/\0.+$/, ""), index2, workingDir));
|
|
}
|
|
}
|
|
}
|
|
var StatusSummary;
|
|
var parsers6;
|
|
var parseStatusSummary;
|
|
var init_StatusSummary = __esm2({
|
|
"src/lib/responses/StatusSummary.ts"() {
|
|
init_utils();
|
|
init_FileStatusSummary();
|
|
StatusSummary = class {
|
|
constructor() {
|
|
this.not_added = [];
|
|
this.conflicted = [];
|
|
this.created = [];
|
|
this.deleted = [];
|
|
this.ignored = void 0;
|
|
this.modified = [];
|
|
this.renamed = [];
|
|
this.files = [];
|
|
this.staged = [];
|
|
this.ahead = 0;
|
|
this.behind = 0;
|
|
this.current = null;
|
|
this.tracking = null;
|
|
this.detached = false;
|
|
this.isClean = () => {
|
|
return !this.files.length;
|
|
};
|
|
}
|
|
};
|
|
parsers6 = new Map([
|
|
parser2(" ", "A", (result, file) => append(result.created, file)),
|
|
parser2(" ", "D", (result, file) => append(result.deleted, file)),
|
|
parser2(" ", "M", (result, file) => append(result.modified, file)),
|
|
parser2("A", " ", (result, file) => append(result.created, file) && append(result.staged, file)),
|
|
parser2("A", "M", (result, file) => append(result.created, file) && append(result.staged, file) && append(result.modified, file)),
|
|
parser2("D", " ", (result, file) => append(result.deleted, file) && append(result.staged, file)),
|
|
parser2("M", " ", (result, file) => append(result.modified, file) && append(result.staged, file)),
|
|
parser2("M", "M", (result, file) => append(result.modified, file) && append(result.staged, file)),
|
|
parser2("R", " ", (result, file) => {
|
|
append(result.renamed, renamedFile(file));
|
|
}),
|
|
parser2("R", "M", (result, file) => {
|
|
const renamed = renamedFile(file);
|
|
append(result.renamed, renamed);
|
|
append(result.modified, renamed.to);
|
|
}),
|
|
parser2("!", "!", (_result, _file) => {
|
|
append(_result.ignored = _result.ignored || [], _file);
|
|
}),
|
|
parser2("?", "?", (result, file) => append(result.not_added, file)),
|
|
...conflicts("A", "A", "U"),
|
|
...conflicts("D", "D", "U"),
|
|
...conflicts("U", "A", "D", "U"),
|
|
[
|
|
"##",
|
|
(result, line) => {
|
|
const aheadReg = /ahead (\d+)/;
|
|
const behindReg = /behind (\d+)/;
|
|
const currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/;
|
|
const trackingReg = /\.{3}(\S*)/;
|
|
const onEmptyBranchReg = /\son\s([\S]+)$/;
|
|
let regexResult;
|
|
regexResult = aheadReg.exec(line);
|
|
result.ahead = regexResult && +regexResult[1] || 0;
|
|
regexResult = behindReg.exec(line);
|
|
result.behind = regexResult && +regexResult[1] || 0;
|
|
regexResult = currentReg.exec(line);
|
|
result.current = regexResult && regexResult[1];
|
|
regexResult = trackingReg.exec(line);
|
|
result.tracking = regexResult && regexResult[1];
|
|
regexResult = onEmptyBranchReg.exec(line);
|
|
result.current = regexResult && regexResult[1] || result.current;
|
|
result.detached = /\(no branch\)/.test(line);
|
|
}
|
|
]
|
|
]);
|
|
parseStatusSummary = function(text2) {
|
|
const lines = text2.split(NULL);
|
|
const status2 = new StatusSummary();
|
|
for (let i = 0, l = lines.length; i < l; ) {
|
|
let line = lines[i++].trim();
|
|
if (!line) {
|
|
continue;
|
|
}
|
|
if (line.charAt(0) === "R") {
|
|
line += NULL + (lines[i++] || "");
|
|
}
|
|
splitLine(status2, line);
|
|
}
|
|
return status2;
|
|
};
|
|
}
|
|
});
|
|
function statusTask(customArgs) {
|
|
const commands = [
|
|
"status",
|
|
"--porcelain",
|
|
"-b",
|
|
"-u",
|
|
"--null",
|
|
...customArgs.filter((arg) => !ignoredOptions.includes(arg))
|
|
];
|
|
return {
|
|
format: "utf-8",
|
|
commands,
|
|
parser(text2) {
|
|
return parseStatusSummary(text2);
|
|
}
|
|
};
|
|
}
|
|
var ignoredOptions;
|
|
var init_status = __esm2({
|
|
"src/lib/tasks/status.ts"() {
|
|
init_StatusSummary();
|
|
ignoredOptions = ["--null", "-z"];
|
|
}
|
|
});
|
|
function versionResponse(major = 0, minor = 0, patch = 0, agent = "", installed = true) {
|
|
return Object.defineProperty({
|
|
major,
|
|
minor,
|
|
patch,
|
|
agent,
|
|
installed
|
|
}, "toString", {
|
|
value() {
|
|
return `${this.major}.${this.minor}.${this.patch}`;
|
|
},
|
|
configurable: false,
|
|
enumerable: false
|
|
});
|
|
}
|
|
function notInstalledResponse() {
|
|
return versionResponse(0, 0, 0, "", false);
|
|
}
|
|
function version_default() {
|
|
return {
|
|
version() {
|
|
return this._runTask({
|
|
commands: ["--version"],
|
|
format: "utf-8",
|
|
parser: versionParser,
|
|
onError(result, error, done, fail) {
|
|
if (result.exitCode === -2) {
|
|
return done(Buffer2.from(NOT_INSTALLED));
|
|
}
|
|
fail(error);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
function versionParser(stdOut) {
|
|
if (stdOut === NOT_INSTALLED) {
|
|
return notInstalledResponse();
|
|
}
|
|
return parseStringResponse(versionResponse(0, 0, 0, stdOut), parsers7, stdOut);
|
|
}
|
|
var NOT_INSTALLED;
|
|
var parsers7;
|
|
var init_version = __esm2({
|
|
"src/lib/tasks/version.ts"() {
|
|
init_utils();
|
|
NOT_INSTALLED = "installed=false";
|
|
parsers7 = [
|
|
new LineParser(/version (\d+)\.(\d+)\.(\d+)(?:\s*\((.+)\))?/, (result, [major, minor, patch, agent = ""]) => {
|
|
Object.assign(result, versionResponse(asNumber(major), asNumber(minor), asNumber(patch), agent));
|
|
}),
|
|
new LineParser(/version (\d+)\.(\d+)\.(\D+)(.+)?$/, (result, [major, minor, patch, agent = ""]) => {
|
|
Object.assign(result, versionResponse(asNumber(major), asNumber(minor), patch, agent));
|
|
})
|
|
];
|
|
}
|
|
});
|
|
var simple_git_api_exports = {};
|
|
__export2(simple_git_api_exports, {
|
|
SimpleGitApi: () => SimpleGitApi
|
|
});
|
|
var SimpleGitApi;
|
|
var init_simple_git_api = __esm2({
|
|
"src/lib/simple-git-api.ts"() {
|
|
init_task_callback();
|
|
init_change_working_directory();
|
|
init_commit();
|
|
init_config();
|
|
init_grep();
|
|
init_hash_object();
|
|
init_init();
|
|
init_log();
|
|
init_merge();
|
|
init_push();
|
|
init_status();
|
|
init_task();
|
|
init_version();
|
|
init_utils();
|
|
SimpleGitApi = class {
|
|
constructor(_executor) {
|
|
this._executor = _executor;
|
|
}
|
|
_runTask(task, then) {
|
|
const chain = this._executor.chain();
|
|
const promise2 = chain.push(task);
|
|
if (then) {
|
|
taskCallback(task, promise2, then);
|
|
}
|
|
return Object.create(this, {
|
|
then: { value: promise2.then.bind(promise2) },
|
|
catch: { value: promise2.catch.bind(promise2) },
|
|
_executor: { value: chain }
|
|
});
|
|
}
|
|
add(files) {
|
|
return this._runTask(straightThroughStringTask(["add", ...asArray(files)]), trailingFunctionArgument(arguments));
|
|
}
|
|
cwd(directory) {
|
|
const next = trailingFunctionArgument(arguments);
|
|
if (typeof directory === "string") {
|
|
return this._runTask(changeWorkingDirectoryTask(directory, this._executor), next);
|
|
}
|
|
if (typeof (directory == null ? void 0 : directory.path) === "string") {
|
|
return this._runTask(changeWorkingDirectoryTask(directory.path, directory.root && this._executor || void 0), next);
|
|
}
|
|
return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
|
|
}
|
|
hashObject(path2, write) {
|
|
return this._runTask(hashObjectTask(path2, write === true), trailingFunctionArgument(arguments));
|
|
}
|
|
init(bare) {
|
|
return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
|
|
}
|
|
merge() {
|
|
return this._runTask(mergeTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
|
|
}
|
|
mergeFromTo(remote, branch2) {
|
|
if (!(filterString(remote) && filterString(branch2))) {
|
|
return this._runTask(configurationErrorTask(`Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`));
|
|
}
|
|
return this._runTask(mergeTask([remote, branch2, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments, false));
|
|
}
|
|
outputHandler(handler) {
|
|
this._executor.outputHandler = handler;
|
|
return this;
|
|
}
|
|
push() {
|
|
const task = pushTask({
|
|
remote: filterType(arguments[0], filterString),
|
|
branch: filterType(arguments[1], filterString)
|
|
}, getTrailingOptions(arguments));
|
|
return this._runTask(task, trailingFunctionArgument(arguments));
|
|
}
|
|
stash() {
|
|
return this._runTask(straightThroughStringTask(["stash", ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments));
|
|
}
|
|
status() {
|
|
return this._runTask(statusTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
|
|
}
|
|
};
|
|
Object.assign(SimpleGitApi.prototype, commit_default(), config_default(), grep_default(), log_default(), version_default());
|
|
}
|
|
});
|
|
var scheduler_exports = {};
|
|
__export2(scheduler_exports, {
|
|
Scheduler: () => Scheduler
|
|
});
|
|
var createScheduledTask;
|
|
var Scheduler;
|
|
var init_scheduler = __esm2({
|
|
"src/lib/runners/scheduler.ts"() {
|
|
init_utils();
|
|
init_git_logger();
|
|
createScheduledTask = (() => {
|
|
let id = 0;
|
|
return () => {
|
|
id++;
|
|
const { promise: promise2, done } = (0, import_promise_deferred.createDeferred)();
|
|
return {
|
|
promise: promise2,
|
|
done,
|
|
id
|
|
};
|
|
};
|
|
})();
|
|
Scheduler = class {
|
|
constructor(concurrency = 2) {
|
|
this.concurrency = concurrency;
|
|
this.logger = createLogger("", "scheduler");
|
|
this.pending = [];
|
|
this.running = [];
|
|
this.logger(`Constructed, concurrency=%s`, concurrency);
|
|
}
|
|
schedule() {
|
|
if (!this.pending.length || this.running.length >= this.concurrency) {
|
|
this.logger(`Schedule attempt ignored, pending=%s running=%s concurrency=%s`, this.pending.length, this.running.length, this.concurrency);
|
|
return;
|
|
}
|
|
const task = append(this.running, this.pending.shift());
|
|
this.logger(`Attempting id=%s`, task.id);
|
|
task.done(() => {
|
|
this.logger(`Completing id=`, task.id);
|
|
remove2(this.running, task);
|
|
this.schedule();
|
|
});
|
|
}
|
|
next() {
|
|
const { promise: promise2, id } = append(this.pending, createScheduledTask());
|
|
this.logger(`Scheduling id=%s`, id);
|
|
this.schedule();
|
|
return promise2;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var apply_patch_exports = {};
|
|
__export2(apply_patch_exports, {
|
|
applyPatchTask: () => applyPatchTask
|
|
});
|
|
function applyPatchTask(patches, customArgs) {
|
|
return straightThroughStringTask(["apply", ...customArgs, ...patches]);
|
|
}
|
|
var init_apply_patch = __esm2({
|
|
"src/lib/tasks/apply-patch.ts"() {
|
|
init_task();
|
|
}
|
|
});
|
|
function branchDeletionSuccess(branch2, hash2) {
|
|
return {
|
|
branch: branch2,
|
|
hash: hash2,
|
|
success: true
|
|
};
|
|
}
|
|
function branchDeletionFailure(branch2) {
|
|
return {
|
|
branch: branch2,
|
|
hash: null,
|
|
success: false
|
|
};
|
|
}
|
|
var BranchDeletionBatch;
|
|
var init_BranchDeleteSummary = __esm2({
|
|
"src/lib/responses/BranchDeleteSummary.ts"() {
|
|
BranchDeletionBatch = class {
|
|
constructor() {
|
|
this.all = [];
|
|
this.branches = {};
|
|
this.errors = [];
|
|
}
|
|
get success() {
|
|
return !this.errors.length;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function hasBranchDeletionError(data, processExitCode) {
|
|
return processExitCode === 1 && deleteErrorRegex.test(data);
|
|
}
|
|
var deleteSuccessRegex;
|
|
var deleteErrorRegex;
|
|
var parsers8;
|
|
var parseBranchDeletions;
|
|
var init_parse_branch_delete = __esm2({
|
|
"src/lib/parsers/parse-branch-delete.ts"() {
|
|
init_BranchDeleteSummary();
|
|
init_utils();
|
|
deleteSuccessRegex = /(\S+)\s+\(\S+\s([^)]+)\)/;
|
|
deleteErrorRegex = /^error[^']+'([^']+)'/m;
|
|
parsers8 = [
|
|
new LineParser(deleteSuccessRegex, (result, [branch2, hash2]) => {
|
|
const deletion = branchDeletionSuccess(branch2, hash2);
|
|
result.all.push(deletion);
|
|
result.branches[branch2] = deletion;
|
|
}),
|
|
new LineParser(deleteErrorRegex, (result, [branch2]) => {
|
|
const deletion = branchDeletionFailure(branch2);
|
|
result.errors.push(deletion);
|
|
result.all.push(deletion);
|
|
result.branches[branch2] = deletion;
|
|
})
|
|
];
|
|
parseBranchDeletions = (stdOut, stdErr) => {
|
|
return parseStringResponse(new BranchDeletionBatch(), parsers8, [stdOut, stdErr]);
|
|
};
|
|
}
|
|
});
|
|
var BranchSummaryResult;
|
|
var init_BranchSummary = __esm2({
|
|
"src/lib/responses/BranchSummary.ts"() {
|
|
BranchSummaryResult = class {
|
|
constructor() {
|
|
this.all = [];
|
|
this.branches = {};
|
|
this.current = "";
|
|
this.detached = false;
|
|
}
|
|
push(status2, detached, name, commit2, label) {
|
|
if (status2 === "*") {
|
|
this.detached = detached;
|
|
this.current = name;
|
|
}
|
|
this.all.push(name);
|
|
this.branches[name] = {
|
|
current: status2 === "*",
|
|
linkedWorkTree: status2 === "+",
|
|
name,
|
|
commit: commit2,
|
|
label
|
|
};
|
|
}
|
|
};
|
|
}
|
|
});
|
|
function branchStatus(input) {
|
|
return input ? input.charAt(0) : "";
|
|
}
|
|
function parseBranchSummary(stdOut) {
|
|
return parseStringResponse(new BranchSummaryResult(), parsers9, stdOut);
|
|
}
|
|
var parsers9;
|
|
var init_parse_branch = __esm2({
|
|
"src/lib/parsers/parse-branch.ts"() {
|
|
init_BranchSummary();
|
|
init_utils();
|
|
parsers9 = [
|
|
new LineParser(/^([*+]\s)?\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/, (result, [current, name, commit2, label]) => {
|
|
result.push(branchStatus(current), true, name, commit2, label);
|
|
}),
|
|
new LineParser(/^([*+]\s)?(\S+)\s+([a-z0-9]+)\s?(.*)$/s, (result, [current, name, commit2, label]) => {
|
|
result.push(branchStatus(current), false, name, commit2, label);
|
|
})
|
|
];
|
|
}
|
|
});
|
|
var branch_exports = {};
|
|
__export2(branch_exports, {
|
|
branchLocalTask: () => branchLocalTask,
|
|
branchTask: () => branchTask,
|
|
containsDeleteBranchCommand: () => containsDeleteBranchCommand,
|
|
deleteBranchTask: () => deleteBranchTask,
|
|
deleteBranchesTask: () => deleteBranchesTask
|
|
});
|
|
function containsDeleteBranchCommand(commands) {
|
|
const deleteCommands = ["-d", "-D", "--delete"];
|
|
return commands.some((command) => deleteCommands.includes(command));
|
|
}
|
|
function branchTask(customArgs) {
|
|
const isDelete = containsDeleteBranchCommand(customArgs);
|
|
const commands = ["branch", ...customArgs];
|
|
if (commands.length === 1) {
|
|
commands.push("-a");
|
|
}
|
|
if (!commands.includes("-v")) {
|
|
commands.splice(1, 0, "-v");
|
|
}
|
|
return {
|
|
format: "utf-8",
|
|
commands,
|
|
parser(stdOut, stdErr) {
|
|
if (isDelete) {
|
|
return parseBranchDeletions(stdOut, stdErr).all[0];
|
|
}
|
|
return parseBranchSummary(stdOut);
|
|
}
|
|
};
|
|
}
|
|
function branchLocalTask() {
|
|
const parser3 = parseBranchSummary;
|
|
return {
|
|
format: "utf-8",
|
|
commands: ["branch", "-v"],
|
|
parser: parser3
|
|
};
|
|
}
|
|
function deleteBranchesTask(branches, forceDelete = false) {
|
|
return {
|
|
format: "utf-8",
|
|
commands: ["branch", "-v", forceDelete ? "-D" : "-d", ...branches],
|
|
parser(stdOut, stdErr) {
|
|
return parseBranchDeletions(stdOut, stdErr);
|
|
},
|
|
onError({ exitCode, stdOut }, error, done, fail) {
|
|
if (!hasBranchDeletionError(String(error), exitCode)) {
|
|
return fail(error);
|
|
}
|
|
done(stdOut);
|
|
}
|
|
};
|
|
}
|
|
function deleteBranchTask(branch2, forceDelete = false) {
|
|
const task = {
|
|
format: "utf-8",
|
|
commands: ["branch", "-v", forceDelete ? "-D" : "-d", branch2],
|
|
parser(stdOut, stdErr) {
|
|
return parseBranchDeletions(stdOut, stdErr).branches[branch2];
|
|
},
|
|
onError({ exitCode, stdErr, stdOut }, error, _, fail) {
|
|
if (!hasBranchDeletionError(String(error), exitCode)) {
|
|
return fail(error);
|
|
}
|
|
throw new GitResponseError(task.parser(bufferToString(stdOut), bufferToString(stdErr)), String(error));
|
|
}
|
|
};
|
|
return task;
|
|
}
|
|
var init_branch = __esm2({
|
|
"src/lib/tasks/branch.ts"() {
|
|
init_git_response_error();
|
|
init_parse_branch_delete();
|
|
init_parse_branch();
|
|
init_utils();
|
|
}
|
|
});
|
|
var parseCheckIgnore;
|
|
var init_CheckIgnore = __esm2({
|
|
"src/lib/responses/CheckIgnore.ts"() {
|
|
parseCheckIgnore = (text2) => {
|
|
return text2.split(/\n/g).map((line) => line.trim()).filter((file) => !!file);
|
|
};
|
|
}
|
|
});
|
|
var check_ignore_exports = {};
|
|
__export2(check_ignore_exports, {
|
|
checkIgnoreTask: () => checkIgnoreTask
|
|
});
|
|
function checkIgnoreTask(paths) {
|
|
return {
|
|
commands: ["check-ignore", ...paths],
|
|
format: "utf-8",
|
|
parser: parseCheckIgnore
|
|
};
|
|
}
|
|
var init_check_ignore = __esm2({
|
|
"src/lib/tasks/check-ignore.ts"() {
|
|
init_CheckIgnore();
|
|
}
|
|
});
|
|
var clone_exports = {};
|
|
__export2(clone_exports, {
|
|
cloneMirrorTask: () => cloneMirrorTask,
|
|
cloneTask: () => cloneTask
|
|
});
|
|
function disallowedCommand(command) {
|
|
return /^--upload-pack(=|$)/.test(command);
|
|
}
|
|
function cloneTask(repo, directory, customArgs) {
|
|
const commands = ["clone", ...customArgs];
|
|
filterString(repo) && commands.push(repo);
|
|
filterString(directory) && commands.push(directory);
|
|
const banned = commands.find(disallowedCommand);
|
|
if (banned) {
|
|
return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);
|
|
}
|
|
return straightThroughStringTask(commands);
|
|
}
|
|
function cloneMirrorTask(repo, directory, customArgs) {
|
|
append(customArgs, "--mirror");
|
|
return cloneTask(repo, directory, customArgs);
|
|
}
|
|
var init_clone = __esm2({
|
|
"src/lib/tasks/clone.ts"() {
|
|
init_task();
|
|
init_utils();
|
|
}
|
|
});
|
|
function parseFetchResult(stdOut, stdErr) {
|
|
const result = {
|
|
raw: stdOut,
|
|
remote: null,
|
|
branches: [],
|
|
tags: [],
|
|
updated: [],
|
|
deleted: []
|
|
};
|
|
return parseStringResponse(result, parsers10, [stdOut, stdErr]);
|
|
}
|
|
var parsers10;
|
|
var init_parse_fetch = __esm2({
|
|
"src/lib/parsers/parse-fetch.ts"() {
|
|
init_utils();
|
|
parsers10 = [
|
|
new LineParser(/From (.+)$/, (result, [remote]) => {
|
|
result.remote = remote;
|
|
}),
|
|
new LineParser(/\* \[new branch]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => {
|
|
result.branches.push({
|
|
name,
|
|
tracking
|
|
});
|
|
}),
|
|
new LineParser(/\* \[new tag]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => {
|
|
result.tags.push({
|
|
name,
|
|
tracking
|
|
});
|
|
}),
|
|
new LineParser(/- \[deleted]\s+\S+\s*-> (.+)$/, (result, [tracking]) => {
|
|
result.deleted.push({
|
|
tracking
|
|
});
|
|
}),
|
|
new LineParser(/\s*([^.]+)\.\.(\S+)\s+(\S+)\s*-> (.+)$/, (result, [from, to, name, tracking]) => {
|
|
result.updated.push({
|
|
name,
|
|
tracking,
|
|
to,
|
|
from
|
|
});
|
|
})
|
|
];
|
|
}
|
|
});
|
|
var fetch_exports = {};
|
|
__export2(fetch_exports, {
|
|
fetchTask: () => fetchTask
|
|
});
|
|
function disallowedCommand2(command) {
|
|
return /^--upload-pack(=|$)/.test(command);
|
|
}
|
|
function fetchTask(remote, branch2, customArgs) {
|
|
const commands = ["fetch", ...customArgs];
|
|
if (remote && branch2) {
|
|
commands.push(remote, branch2);
|
|
}
|
|
const banned = commands.find(disallowedCommand2);
|
|
if (banned) {
|
|
return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);
|
|
}
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser: parseFetchResult
|
|
};
|
|
}
|
|
var init_fetch = __esm2({
|
|
"src/lib/tasks/fetch.ts"() {
|
|
init_parse_fetch();
|
|
init_task();
|
|
}
|
|
});
|
|
function parseMoveResult(stdOut) {
|
|
return parseStringResponse({ moves: [] }, parsers11, stdOut);
|
|
}
|
|
var parsers11;
|
|
var init_parse_move = __esm2({
|
|
"src/lib/parsers/parse-move.ts"() {
|
|
init_utils();
|
|
parsers11 = [
|
|
new LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => {
|
|
result.moves.push({ from, to });
|
|
})
|
|
];
|
|
}
|
|
});
|
|
var move_exports = {};
|
|
__export2(move_exports, {
|
|
moveTask: () => moveTask
|
|
});
|
|
function moveTask(from, to) {
|
|
return {
|
|
commands: ["mv", "-v", ...asArray(from), to],
|
|
format: "utf-8",
|
|
parser: parseMoveResult
|
|
};
|
|
}
|
|
var init_move = __esm2({
|
|
"src/lib/tasks/move.ts"() {
|
|
init_parse_move();
|
|
init_utils();
|
|
}
|
|
});
|
|
var pull_exports = {};
|
|
__export2(pull_exports, {
|
|
pullTask: () => pullTask
|
|
});
|
|
function pullTask(remote, branch2, customArgs) {
|
|
const commands = ["pull", ...customArgs];
|
|
if (remote && branch2) {
|
|
commands.splice(1, 0, remote, branch2);
|
|
}
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser(stdOut, stdErr) {
|
|
return parsePullResult(stdOut, stdErr);
|
|
},
|
|
onError(result, _error, _done, fail) {
|
|
const pullError = parsePullErrorResult(bufferToString(result.stdOut), bufferToString(result.stdErr));
|
|
if (pullError) {
|
|
return fail(new GitResponseError(pullError));
|
|
}
|
|
fail(_error);
|
|
}
|
|
};
|
|
}
|
|
var init_pull = __esm2({
|
|
"src/lib/tasks/pull.ts"() {
|
|
init_git_response_error();
|
|
init_parse_pull();
|
|
init_utils();
|
|
}
|
|
});
|
|
function parseGetRemotes(text2) {
|
|
const remotes = {};
|
|
forEach(text2, ([name]) => remotes[name] = { name });
|
|
return Object.values(remotes);
|
|
}
|
|
function parseGetRemotesVerbose(text2) {
|
|
const remotes = {};
|
|
forEach(text2, ([name, url, purpose]) => {
|
|
if (!remotes.hasOwnProperty(name)) {
|
|
remotes[name] = {
|
|
name,
|
|
refs: { fetch: "", push: "" }
|
|
};
|
|
}
|
|
if (purpose && url) {
|
|
remotes[name].refs[purpose.replace(/[^a-z]/g, "")] = url;
|
|
}
|
|
});
|
|
return Object.values(remotes);
|
|
}
|
|
function forEach(text2, handler) {
|
|
forEachLineWithContent(text2, (line) => handler(line.split(/\s+/)));
|
|
}
|
|
var init_GetRemoteSummary = __esm2({
|
|
"src/lib/responses/GetRemoteSummary.ts"() {
|
|
init_utils();
|
|
}
|
|
});
|
|
var remote_exports = {};
|
|
__export2(remote_exports, {
|
|
addRemoteTask: () => addRemoteTask,
|
|
getRemotesTask: () => getRemotesTask,
|
|
listRemotesTask: () => listRemotesTask,
|
|
remoteTask: () => remoteTask,
|
|
removeRemoteTask: () => removeRemoteTask
|
|
});
|
|
function addRemoteTask(remoteName, remoteRepo, customArgs = []) {
|
|
return straightThroughStringTask(["remote", "add", ...customArgs, remoteName, remoteRepo]);
|
|
}
|
|
function getRemotesTask(verbose) {
|
|
const commands = ["remote"];
|
|
if (verbose) {
|
|
commands.push("-v");
|
|
}
|
|
return {
|
|
commands,
|
|
format: "utf-8",
|
|
parser: verbose ? parseGetRemotesVerbose : parseGetRemotes
|
|
};
|
|
}
|
|
function listRemotesTask(customArgs = []) {
|
|
const commands = [...customArgs];
|
|
if (commands[0] !== "ls-remote") {
|
|
commands.unshift("ls-remote");
|
|
}
|
|
return straightThroughStringTask(commands);
|
|
}
|
|
function remoteTask(customArgs = []) {
|
|
const commands = [...customArgs];
|
|
if (commands[0] !== "remote") {
|
|
commands.unshift("remote");
|
|
}
|
|
return straightThroughStringTask(commands);
|
|
}
|
|
function removeRemoteTask(remoteName) {
|
|
return straightThroughStringTask(["remote", "remove", remoteName]);
|
|
}
|
|
var init_remote = __esm2({
|
|
"src/lib/tasks/remote.ts"() {
|
|
init_GetRemoteSummary();
|
|
init_task();
|
|
}
|
|
});
|
|
var stash_list_exports = {};
|
|
__export2(stash_list_exports, {
|
|
stashListTask: () => stashListTask
|
|
});
|
|
function stashListTask(opt = {}, customArgs) {
|
|
const options = parseLogOptions(opt);
|
|
const commands = ["stash", "list", ...options.commands, ...customArgs];
|
|
const parser3 = createListLogSummaryParser(options.splitter, options.fields, logFormatFromCommand(commands));
|
|
return validateLogFormatConfig(commands) || {
|
|
commands,
|
|
format: "utf-8",
|
|
parser: parser3
|
|
};
|
|
}
|
|
var init_stash_list = __esm2({
|
|
"src/lib/tasks/stash-list.ts"() {
|
|
init_log_format();
|
|
init_parse_list_log_summary();
|
|
init_diff();
|
|
init_log();
|
|
}
|
|
});
|
|
var sub_module_exports = {};
|
|
__export2(sub_module_exports, {
|
|
addSubModuleTask: () => addSubModuleTask,
|
|
initSubModuleTask: () => initSubModuleTask,
|
|
subModuleTask: () => subModuleTask,
|
|
updateSubModuleTask: () => updateSubModuleTask
|
|
});
|
|
function addSubModuleTask(repo, path2) {
|
|
return subModuleTask(["add", repo, path2]);
|
|
}
|
|
function initSubModuleTask(customArgs) {
|
|
return subModuleTask(["init", ...customArgs]);
|
|
}
|
|
function subModuleTask(customArgs) {
|
|
const commands = [...customArgs];
|
|
if (commands[0] !== "submodule") {
|
|
commands.unshift("submodule");
|
|
}
|
|
return straightThroughStringTask(commands);
|
|
}
|
|
function updateSubModuleTask(customArgs) {
|
|
return subModuleTask(["update", ...customArgs]);
|
|
}
|
|
var init_sub_module = __esm2({
|
|
"src/lib/tasks/sub-module.ts"() {
|
|
init_task();
|
|
}
|
|
});
|
|
function singleSorted(a, b) {
|
|
const aIsNum = isNaN(a);
|
|
const bIsNum = isNaN(b);
|
|
if (aIsNum !== bIsNum) {
|
|
return aIsNum ? 1 : -1;
|
|
}
|
|
return aIsNum ? sorted(a, b) : 0;
|
|
}
|
|
function sorted(a, b) {
|
|
return a === b ? 0 : a > b ? 1 : -1;
|
|
}
|
|
function trimmed(input) {
|
|
return input.trim();
|
|
}
|
|
function toNumber(input) {
|
|
if (typeof input === "string") {
|
|
return parseInt(input.replace(/^\D+/g, ""), 10) || 0;
|
|
}
|
|
return 0;
|
|
}
|
|
var TagList;
|
|
var parseTagList;
|
|
var init_TagList = __esm2({
|
|
"src/lib/responses/TagList.ts"() {
|
|
TagList = class {
|
|
constructor(all, latest) {
|
|
this.all = all;
|
|
this.latest = latest;
|
|
}
|
|
};
|
|
parseTagList = function(data, customSort = false) {
|
|
const tags = data.split("\n").map(trimmed).filter(Boolean);
|
|
if (!customSort) {
|
|
tags.sort(function(tagA, tagB) {
|
|
const partsA = tagA.split(".");
|
|
const partsB = tagB.split(".");
|
|
if (partsA.length === 1 || partsB.length === 1) {
|
|
return singleSorted(toNumber(partsA[0]), toNumber(partsB[0]));
|
|
}
|
|
for (let i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) {
|
|
const diff2 = sorted(toNumber(partsA[i]), toNumber(partsB[i]));
|
|
if (diff2) {
|
|
return diff2;
|
|
}
|
|
}
|
|
return 0;
|
|
});
|
|
}
|
|
const latest = customSort ? tags[0] : [...tags].reverse().find((tag2) => tag2.indexOf(".") >= 0);
|
|
return new TagList(tags, latest);
|
|
};
|
|
}
|
|
});
|
|
var tag_exports = {};
|
|
__export2(tag_exports, {
|
|
addAnnotatedTagTask: () => addAnnotatedTagTask,
|
|
addTagTask: () => addTagTask,
|
|
tagListTask: () => tagListTask
|
|
});
|
|
function tagListTask(customArgs = []) {
|
|
const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option));
|
|
return {
|
|
format: "utf-8",
|
|
commands: ["tag", "-l", ...customArgs],
|
|
parser(text2) {
|
|
return parseTagList(text2, hasCustomSort);
|
|
}
|
|
};
|
|
}
|
|
function addTagTask(name) {
|
|
return {
|
|
format: "utf-8",
|
|
commands: ["tag", name],
|
|
parser() {
|
|
return { name };
|
|
}
|
|
};
|
|
}
|
|
function addAnnotatedTagTask(name, tagMessage) {
|
|
return {
|
|
format: "utf-8",
|
|
commands: ["tag", "-a", "-m", tagMessage, name],
|
|
parser() {
|
|
return { name };
|
|
}
|
|
};
|
|
}
|
|
var init_tag = __esm2({
|
|
"src/lib/tasks/tag.ts"() {
|
|
init_TagList();
|
|
}
|
|
});
|
|
var require_git = __commonJS2({
|
|
"src/git.js"(exports, module2) {
|
|
var { GitExecutor: GitExecutor2 } = (init_git_executor(), __toCommonJS(git_executor_exports));
|
|
var { SimpleGitApi: SimpleGitApi2 } = (init_simple_git_api(), __toCommonJS(simple_git_api_exports));
|
|
var { Scheduler: Scheduler2 } = (init_scheduler(), __toCommonJS(scheduler_exports));
|
|
var { configurationErrorTask: configurationErrorTask2 } = (init_task(), __toCommonJS(task_exports));
|
|
var {
|
|
asArray: asArray2,
|
|
filterArray: filterArray2,
|
|
filterPrimitives: filterPrimitives2,
|
|
filterString: filterString2,
|
|
filterStringOrStringArray: filterStringOrStringArray2,
|
|
filterType: filterType2,
|
|
getTrailingOptions: getTrailingOptions2,
|
|
trailingFunctionArgument: trailingFunctionArgument2,
|
|
trailingOptionsArgument: trailingOptionsArgument2
|
|
} = (init_utils(), __toCommonJS(utils_exports));
|
|
var { applyPatchTask: applyPatchTask2 } = (init_apply_patch(), __toCommonJS(apply_patch_exports));
|
|
var {
|
|
branchTask: branchTask2,
|
|
branchLocalTask: branchLocalTask2,
|
|
deleteBranchesTask: deleteBranchesTask2,
|
|
deleteBranchTask: deleteBranchTask2
|
|
} = (init_branch(), __toCommonJS(branch_exports));
|
|
var { checkIgnoreTask: checkIgnoreTask2 } = (init_check_ignore(), __toCommonJS(check_ignore_exports));
|
|
var { checkIsRepoTask: checkIsRepoTask2 } = (init_check_is_repo(), __toCommonJS(check_is_repo_exports));
|
|
var { cloneTask: cloneTask2, cloneMirrorTask: cloneMirrorTask2 } = (init_clone(), __toCommonJS(clone_exports));
|
|
var { cleanWithOptionsTask: cleanWithOptionsTask2, isCleanOptionsArray: isCleanOptionsArray2 } = (init_clean(), __toCommonJS(clean_exports));
|
|
var { commitTask: commitTask2 } = (init_commit(), __toCommonJS(commit_exports));
|
|
var { diffSummaryTask: diffSummaryTask2 } = (init_diff(), __toCommonJS(diff_exports));
|
|
var { fetchTask: fetchTask2 } = (init_fetch(), __toCommonJS(fetch_exports));
|
|
var { moveTask: moveTask2 } = (init_move(), __toCommonJS(move_exports));
|
|
var { pullTask: pullTask2 } = (init_pull(), __toCommonJS(pull_exports));
|
|
var { pushTagsTask: pushTagsTask2 } = (init_push(), __toCommonJS(push_exports));
|
|
var {
|
|
addRemoteTask: addRemoteTask2,
|
|
getRemotesTask: getRemotesTask2,
|
|
listRemotesTask: listRemotesTask2,
|
|
remoteTask: remoteTask2,
|
|
removeRemoteTask: removeRemoteTask2
|
|
} = (init_remote(), __toCommonJS(remote_exports));
|
|
var { getResetMode: getResetMode2, resetTask: resetTask2 } = (init_reset(), __toCommonJS(reset_exports));
|
|
var { stashListTask: stashListTask2 } = (init_stash_list(), __toCommonJS(stash_list_exports));
|
|
var {
|
|
addSubModuleTask: addSubModuleTask2,
|
|
initSubModuleTask: initSubModuleTask2,
|
|
subModuleTask: subModuleTask2,
|
|
updateSubModuleTask: updateSubModuleTask2
|
|
} = (init_sub_module(), __toCommonJS(sub_module_exports));
|
|
var { addAnnotatedTagTask: addAnnotatedTagTask2, addTagTask: addTagTask2, tagListTask: tagListTask2 } = (init_tag(), __toCommonJS(tag_exports));
|
|
var { straightThroughBufferTask: straightThroughBufferTask2, straightThroughStringTask: straightThroughStringTask2 } = (init_task(), __toCommonJS(task_exports));
|
|
function Git2(options, plugins) {
|
|
this._executor = new GitExecutor2(options.binary, options.baseDir, new Scheduler2(options.maxConcurrentProcesses), plugins);
|
|
this._trimmed = options.trimmed;
|
|
}
|
|
(Git2.prototype = Object.create(SimpleGitApi2.prototype)).constructor = Git2;
|
|
Git2.prototype.customBinary = function(command) {
|
|
this._executor.binary = command;
|
|
return this;
|
|
};
|
|
Git2.prototype.env = function(name, value) {
|
|
if (arguments.length === 1 && typeof name === "object") {
|
|
this._executor.env = name;
|
|
} else {
|
|
(this._executor.env = this._executor.env || {})[name] = value;
|
|
}
|
|
return this;
|
|
};
|
|
Git2.prototype.stashList = function(options) {
|
|
return this._runTask(stashListTask2(trailingOptionsArgument2(arguments) || {}, filterArray2(options) && options || []), trailingFunctionArgument2(arguments));
|
|
};
|
|
function createCloneTask(api, task, repoPath, localPath) {
|
|
if (typeof repoPath !== "string") {
|
|
return configurationErrorTask2(`git.${api}() requires a string 'repoPath'`);
|
|
}
|
|
return task(repoPath, filterType2(localPath, filterString2), getTrailingOptions2(arguments));
|
|
}
|
|
Git2.prototype.clone = function() {
|
|
return this._runTask(createCloneTask("clone", cloneTask2, ...arguments), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.mirror = function() {
|
|
return this._runTask(createCloneTask("mirror", cloneMirrorTask2, ...arguments), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.mv = function(from, to) {
|
|
return this._runTask(moveTask2(from, to), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.checkoutLatestTag = function(then) {
|
|
var git = this;
|
|
return this.pull(function() {
|
|
git.tags(function(err, tags) {
|
|
git.checkout(tags.latest, then);
|
|
});
|
|
});
|
|
};
|
|
Git2.prototype.pull = function(remote, branch2, options, then) {
|
|
return this._runTask(pullTask2(filterType2(remote, filterString2), filterType2(branch2, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.fetch = function(remote, branch2) {
|
|
return this._runTask(fetchTask2(filterType2(remote, filterString2), filterType2(branch2, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.silent = function(silence) {
|
|
console.warn("simple-git deprecation notice: git.silent: logging should be configured using the `debug` library / `DEBUG` environment variable, this will be an error in version 3");
|
|
return this;
|
|
};
|
|
Git2.prototype.tags = function(options, then) {
|
|
return this._runTask(tagListTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.rebase = function() {
|
|
return this._runTask(straightThroughStringTask2(["rebase", ...getTrailingOptions2(arguments)]), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.reset = function(mode) {
|
|
return this._runTask(resetTask2(getResetMode2(mode), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.revert = function(commit2) {
|
|
const next = trailingFunctionArgument2(arguments);
|
|
if (typeof commit2 !== "string") {
|
|
return this._runTask(configurationErrorTask2("Commit must be a string"), next);
|
|
}
|
|
return this._runTask(straightThroughStringTask2(["revert", ...getTrailingOptions2(arguments, 0, true), commit2]), next);
|
|
};
|
|
Git2.prototype.addTag = function(name) {
|
|
const task = typeof name === "string" ? addTagTask2(name) : configurationErrorTask2("Git.addTag requires a tag name");
|
|
return this._runTask(task, trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.addAnnotatedTag = function(tagName, tagMessage) {
|
|
return this._runTask(addAnnotatedTagTask2(tagName, tagMessage), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.checkout = function() {
|
|
const commands = ["checkout", ...getTrailingOptions2(arguments, true)];
|
|
return this._runTask(straightThroughStringTask2(commands), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.checkoutBranch = function(branchName, startPoint, then) {
|
|
return this.checkout(["-b", branchName, startPoint], trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.checkoutLocalBranch = function(branchName, then) {
|
|
return this.checkout(["-b", branchName], trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.deleteLocalBranch = function(branchName, forceDelete, then) {
|
|
return this._runTask(deleteBranchTask2(branchName, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.deleteLocalBranches = function(branchNames, forceDelete, then) {
|
|
return this._runTask(deleteBranchesTask2(branchNames, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.branch = function(options, then) {
|
|
return this._runTask(branchTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.branchLocal = function(then) {
|
|
return this._runTask(branchLocalTask2(), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.raw = function(commands) {
|
|
const createRestCommands = !Array.isArray(commands);
|
|
const command = [].slice.call(createRestCommands ? arguments : commands, 0);
|
|
for (let i = 0; i < command.length && createRestCommands; i++) {
|
|
if (!filterPrimitives2(command[i])) {
|
|
command.splice(i, command.length - i);
|
|
break;
|
|
}
|
|
}
|
|
command.push(...getTrailingOptions2(arguments, 0, true));
|
|
var next = trailingFunctionArgument2(arguments);
|
|
if (!command.length) {
|
|
return this._runTask(configurationErrorTask2("Raw: must supply one or more command to execute"), next);
|
|
}
|
|
return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
|
|
};
|
|
Git2.prototype.submoduleAdd = function(repo, path2, then) {
|
|
return this._runTask(addSubModuleTask2(repo, path2), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.submoduleUpdate = function(args, then) {
|
|
return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.submoduleInit = function(args, then) {
|
|
return this._runTask(initSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.subModule = function(options, then) {
|
|
return this._runTask(subModuleTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.listRemote = function() {
|
|
return this._runTask(listRemotesTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.addRemote = function(remoteName, remoteRepo, then) {
|
|
return this._runTask(addRemoteTask2(remoteName, remoteRepo, getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.removeRemote = function(remoteName, then) {
|
|
return this._runTask(removeRemoteTask2(remoteName), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.getRemotes = function(verbose, then) {
|
|
return this._runTask(getRemotesTask2(verbose === true), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.remote = function(options, then) {
|
|
return this._runTask(remoteTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.tag = function(options, then) {
|
|
const command = getTrailingOptions2(arguments);
|
|
if (command[0] !== "tag") {
|
|
command.unshift("tag");
|
|
}
|
|
return this._runTask(straightThroughStringTask2(command), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.updateServerInfo = function(then) {
|
|
return this._runTask(straightThroughStringTask2(["update-server-info"]), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.pushTags = function(remote, then) {
|
|
const task = pushTagsTask2({ remote: filterType2(remote, filterString2) }, getTrailingOptions2(arguments));
|
|
return this._runTask(task, trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.rm = function(files) {
|
|
return this._runTask(straightThroughStringTask2(["rm", "-f", ...asArray2(files)]), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.rmKeepLocal = function(files) {
|
|
return this._runTask(straightThroughStringTask2(["rm", "--cached", ...asArray2(files)]), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.catFile = function(options, then) {
|
|
return this._catFile("utf-8", arguments);
|
|
};
|
|
Git2.prototype.binaryCatFile = function() {
|
|
return this._catFile("buffer", arguments);
|
|
};
|
|
Git2.prototype._catFile = function(format, args) {
|
|
var handler = trailingFunctionArgument2(args);
|
|
var command = ["cat-file"];
|
|
var options = args[0];
|
|
if (typeof options === "string") {
|
|
return this._runTask(configurationErrorTask2("Git.catFile: options must be supplied as an array of strings"), handler);
|
|
}
|
|
if (Array.isArray(options)) {
|
|
command.push.apply(command, options);
|
|
}
|
|
const task = format === "buffer" ? straightThroughBufferTask2(command) : straightThroughStringTask2(command);
|
|
return this._runTask(task, handler);
|
|
};
|
|
Git2.prototype.diff = function(options, then) {
|
|
const task = filterString2(options) ? configurationErrorTask2("git.diff: supplying options as a single string is no longer supported, switch to an array of strings") : straightThroughStringTask2(["diff", ...getTrailingOptions2(arguments)]);
|
|
return this._runTask(task, trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.diffSummary = function() {
|
|
return this._runTask(diffSummaryTask2(getTrailingOptions2(arguments, 1)), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.applyPatch = function(patches) {
|
|
const task = !filterStringOrStringArray2(patches) ? configurationErrorTask2(`git.applyPatch requires one or more string patches as the first argument`) : applyPatchTask2(asArray2(patches), getTrailingOptions2([].slice.call(arguments, 1)));
|
|
return this._runTask(task, trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.revparse = function() {
|
|
const commands = ["rev-parse", ...getTrailingOptions2(arguments, true)];
|
|
return this._runTask(straightThroughStringTask2(commands, true), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.show = function(options, then) {
|
|
return this._runTask(straightThroughStringTask2(["show", ...getTrailingOptions2(arguments, 1)]), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.clean = function(mode, options, then) {
|
|
const usingCleanOptionsArray = isCleanOptionsArray2(mode);
|
|
const cleanMode = usingCleanOptionsArray && mode.join("") || filterType2(mode, filterString2) || "";
|
|
const customArgs = getTrailingOptions2([].slice.call(arguments, usingCleanOptionsArray ? 1 : 0));
|
|
return this._runTask(cleanWithOptionsTask2(cleanMode, customArgs), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.exec = function(then) {
|
|
const task = {
|
|
commands: [],
|
|
format: "utf-8",
|
|
parser() {
|
|
if (typeof then === "function") {
|
|
then();
|
|
}
|
|
}
|
|
};
|
|
return this._runTask(task);
|
|
};
|
|
Git2.prototype.clearQueue = function() {
|
|
return this;
|
|
};
|
|
Git2.prototype.checkIgnore = function(pathnames, then) {
|
|
return this._runTask(checkIgnoreTask2(asArray2(filterType2(pathnames, filterStringOrStringArray2, []))), trailingFunctionArgument2(arguments));
|
|
};
|
|
Git2.prototype.checkIsRepo = function(checkType, then) {
|
|
return this._runTask(checkIsRepoTask2(filterType2(checkType, filterString2)), trailingFunctionArgument2(arguments));
|
|
};
|
|
module2.exports = Git2;
|
|
}
|
|
});
|
|
init_git_error();
|
|
var GitConstructError = class extends GitError {
|
|
constructor(config, message) {
|
|
super(void 0, message);
|
|
this.config = config;
|
|
}
|
|
};
|
|
init_git_error();
|
|
init_git_error();
|
|
var GitPluginError = class extends GitError {
|
|
constructor(task, plugin, message) {
|
|
super(task, message);
|
|
this.task = task;
|
|
this.plugin = plugin;
|
|
Object.setPrototypeOf(this, new.target.prototype);
|
|
}
|
|
};
|
|
init_git_response_error();
|
|
init_task_configuration_error();
|
|
init_check_is_repo();
|
|
init_clean();
|
|
init_config();
|
|
init_grep();
|
|
init_reset();
|
|
function abortPlugin(signal) {
|
|
if (!signal) {
|
|
return;
|
|
}
|
|
const onSpawnAfter = {
|
|
type: "spawn.after",
|
|
action(_data, context) {
|
|
function kill() {
|
|
context.kill(new GitPluginError(void 0, "abort", "Abort signal received"));
|
|
}
|
|
signal.addEventListener("abort", kill);
|
|
context.spawned.on("close", () => signal.removeEventListener("abort", kill));
|
|
}
|
|
};
|
|
const onSpawnBefore = {
|
|
type: "spawn.before",
|
|
action(_data, context) {
|
|
if (signal.aborted) {
|
|
context.kill(new GitPluginError(void 0, "abort", "Abort already signaled"));
|
|
}
|
|
}
|
|
};
|
|
return [onSpawnBefore, onSpawnAfter];
|
|
}
|
|
init_utils();
|
|
function commandConfigPrefixingPlugin(configuration) {
|
|
const prefix = prefixedArray(configuration, "-c");
|
|
return {
|
|
type: "spawn.args",
|
|
action(data) {
|
|
return [...prefix, ...data];
|
|
}
|
|
};
|
|
}
|
|
init_utils();
|
|
var never = (0, import_promise_deferred2.deferred)().promise;
|
|
function completionDetectionPlugin({
|
|
onClose = true,
|
|
onExit = 50
|
|
} = {}) {
|
|
function createEvents() {
|
|
let exitCode = -1;
|
|
const events = {
|
|
close: (0, import_promise_deferred2.deferred)(),
|
|
closeTimeout: (0, import_promise_deferred2.deferred)(),
|
|
exit: (0, import_promise_deferred2.deferred)(),
|
|
exitTimeout: (0, import_promise_deferred2.deferred)()
|
|
};
|
|
const result = Promise.race([
|
|
onClose === false ? never : events.closeTimeout.promise,
|
|
onExit === false ? never : events.exitTimeout.promise
|
|
]);
|
|
configureTimeout(onClose, events.close, events.closeTimeout);
|
|
configureTimeout(onExit, events.exit, events.exitTimeout);
|
|
return {
|
|
close(code) {
|
|
exitCode = code;
|
|
events.close.done();
|
|
},
|
|
exit(code) {
|
|
exitCode = code;
|
|
events.exit.done();
|
|
},
|
|
get exitCode() {
|
|
return exitCode;
|
|
},
|
|
result
|
|
};
|
|
}
|
|
function configureTimeout(flag, event, timeout) {
|
|
if (flag === false) {
|
|
return;
|
|
}
|
|
(flag === true ? event.promise : event.promise.then(() => delay(flag))).then(timeout.done);
|
|
}
|
|
return {
|
|
type: "spawn.after",
|
|
action(_0, _1) {
|
|
return __async(this, arguments, function* (_data, { spawned, close }) {
|
|
var _a2, _b;
|
|
const events = createEvents();
|
|
let deferClose = true;
|
|
let quickClose = () => void (deferClose = false);
|
|
(_a2 = spawned.stdout) == null ? void 0 : _a2.on("data", quickClose);
|
|
(_b = spawned.stderr) == null ? void 0 : _b.on("data", quickClose);
|
|
spawned.on("error", quickClose);
|
|
spawned.on("close", (code) => events.close(code));
|
|
spawned.on("exit", (code) => events.exit(code));
|
|
try {
|
|
yield events.result;
|
|
if (deferClose) {
|
|
yield delay(50);
|
|
}
|
|
close(events.exitCode);
|
|
} catch (err) {
|
|
close(events.exitCode, err);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
init_git_error();
|
|
function isTaskError(result) {
|
|
return !!(result.exitCode && result.stdErr.length);
|
|
}
|
|
function getErrorMessage(result) {
|
|
return Buffer2.concat([...result.stdOut, ...result.stdErr]);
|
|
}
|
|
function errorDetectionHandler(overwrite = false, isError = isTaskError, errorMessage = getErrorMessage) {
|
|
return (error, result) => {
|
|
if (!overwrite && error || !isError(result)) {
|
|
return error;
|
|
}
|
|
return errorMessage(result);
|
|
};
|
|
}
|
|
function errorDetectionPlugin(config) {
|
|
return {
|
|
type: "task.error",
|
|
action(data, context) {
|
|
const error = config(data.error, {
|
|
stdErr: context.stdErr,
|
|
stdOut: context.stdOut,
|
|
exitCode: context.exitCode
|
|
});
|
|
if (Buffer2.isBuffer(error)) {
|
|
return { error: new GitError(void 0, error.toString("utf-8")) };
|
|
}
|
|
return {
|
|
error
|
|
};
|
|
}
|
|
};
|
|
}
|
|
init_utils();
|
|
var PluginStore = class {
|
|
constructor() {
|
|
this.plugins = /* @__PURE__ */ new Set();
|
|
}
|
|
add(plugin) {
|
|
const plugins = [];
|
|
asArray(plugin).forEach((plugin2) => plugin2 && this.plugins.add(append(plugins, plugin2)));
|
|
return () => {
|
|
plugins.forEach((plugin2) => this.plugins.delete(plugin2));
|
|
};
|
|
}
|
|
exec(type, data, context) {
|
|
let output = data;
|
|
const contextual = Object.freeze(Object.create(context));
|
|
for (const plugin of this.plugins) {
|
|
if (plugin.type === type) {
|
|
output = plugin.action(output, contextual);
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
};
|
|
init_utils();
|
|
function progressMonitorPlugin(progress) {
|
|
const progressCommand = "--progress";
|
|
const progressMethods = ["checkout", "clone", "fetch", "pull", "push"];
|
|
const onProgress = {
|
|
type: "spawn.after",
|
|
action(_data, context) {
|
|
var _a2;
|
|
if (!context.commands.includes(progressCommand)) {
|
|
return;
|
|
}
|
|
(_a2 = context.spawned.stderr) == null ? void 0 : _a2.on("data", (chunk) => {
|
|
const message = /^([\s\S]+?):\s*(\d+)% \((\d+)\/(\d+)\)/.exec(chunk.toString("utf8"));
|
|
if (!message) {
|
|
return;
|
|
}
|
|
progress({
|
|
method: context.method,
|
|
stage: progressEventStage(message[1]),
|
|
progress: asNumber(message[2]),
|
|
processed: asNumber(message[3]),
|
|
total: asNumber(message[4])
|
|
});
|
|
});
|
|
}
|
|
};
|
|
const onArgs = {
|
|
type: "spawn.args",
|
|
action(args, context) {
|
|
if (!progressMethods.includes(context.method)) {
|
|
return args;
|
|
}
|
|
return including(args, progressCommand);
|
|
}
|
|
};
|
|
return [onArgs, onProgress];
|
|
}
|
|
function progressEventStage(input) {
|
|
return String(input.toLowerCase().split(" ", 1)) || "unknown";
|
|
}
|
|
init_utils();
|
|
function spawnOptionsPlugin(spawnOptions) {
|
|
const options = pick(spawnOptions, ["uid", "gid"]);
|
|
return {
|
|
type: "spawn.options",
|
|
action(data) {
|
|
return __spreadValues(__spreadValues({}, options), data);
|
|
}
|
|
};
|
|
}
|
|
function timeoutPlugin({
|
|
block
|
|
}) {
|
|
if (block > 0) {
|
|
return {
|
|
type: "spawn.after",
|
|
action(_data, context) {
|
|
var _a2, _b;
|
|
let timeout;
|
|
function wait3() {
|
|
timeout && clearTimeout(timeout);
|
|
timeout = setTimeout(kill, block);
|
|
}
|
|
function stop() {
|
|
var _a3, _b2;
|
|
(_a3 = context.spawned.stdout) == null ? void 0 : _a3.off("data", wait3);
|
|
(_b2 = context.spawned.stderr) == null ? void 0 : _b2.off("data", wait3);
|
|
context.spawned.off("exit", stop);
|
|
context.spawned.off("close", stop);
|
|
timeout && clearTimeout(timeout);
|
|
}
|
|
function kill() {
|
|
stop();
|
|
context.kill(new GitPluginError(void 0, "timeout", `block timeout reached`));
|
|
}
|
|
(_a2 = context.spawned.stdout) == null ? void 0 : _a2.on("data", wait3);
|
|
(_b = context.spawned.stderr) == null ? void 0 : _b.on("data", wait3);
|
|
context.spawned.on("exit", stop);
|
|
context.spawned.on("close", stop);
|
|
wait3();
|
|
}
|
|
};
|
|
}
|
|
}
|
|
init_utils();
|
|
var Git = require_git();
|
|
function gitInstanceFactory(baseDir, options) {
|
|
const plugins = new PluginStore();
|
|
const config = createInstanceConfig(baseDir && (typeof baseDir === "string" ? { baseDir } : baseDir) || {}, options);
|
|
if (!folderExists(config.baseDir)) {
|
|
throw new GitConstructError(config, `Cannot use simple-git on a directory that does not exist`);
|
|
}
|
|
if (Array.isArray(config.config)) {
|
|
plugins.add(commandConfigPrefixingPlugin(config.config));
|
|
}
|
|
plugins.add(completionDetectionPlugin(config.completion));
|
|
config.abort && plugins.add(abortPlugin(config.abort));
|
|
config.progress && plugins.add(progressMonitorPlugin(config.progress));
|
|
config.timeout && plugins.add(timeoutPlugin(config.timeout));
|
|
config.spawnOptions && plugins.add(spawnOptionsPlugin(config.spawnOptions));
|
|
plugins.add(errorDetectionPlugin(errorDetectionHandler(true)));
|
|
config.errors && plugins.add(errorDetectionPlugin(config.errors));
|
|
return new Git(config, plugins);
|
|
}
|
|
init_git_response_error();
|
|
var esm_default = gitInstanceFactory;
|
|
|
|
// src/simpleGit.ts
|
|
var SimpleGit = class extends GitManager {
|
|
constructor(plugin) {
|
|
super(plugin);
|
|
}
|
|
async setGitInstance(ignoreError = false) {
|
|
if (this.isGitInstalled()) {
|
|
const adapter = this.app.vault.adapter;
|
|
const path2 = adapter.getBasePath();
|
|
let basePath = path2;
|
|
if (this.plugin.settings.basePath) {
|
|
const exists2 = await adapter.exists((0, import_obsidian6.normalizePath)(this.plugin.settings.basePath));
|
|
if (exists2) {
|
|
basePath = path2 + import_path.sep + this.plugin.settings.basePath;
|
|
} else if (!ignoreError) {
|
|
new import_obsidian6.Notice("ObsidianGit: Base path does not exist");
|
|
}
|
|
}
|
|
this.git = esm_default({
|
|
baseDir: basePath,
|
|
binary: this.plugin.localStorage.getGitPath() || void 0,
|
|
config: ["core.quotepath=off"]
|
|
});
|
|
this.git.cwd(await this.git.revparse("--show-toplevel"));
|
|
}
|
|
}
|
|
async status() {
|
|
this.plugin.setState(PluginState.status);
|
|
const status2 = await this.git.status((err) => this.onError(err));
|
|
this.plugin.setState(PluginState.idle);
|
|
return {
|
|
changed: status2.files.filter((e) => e.working_dir !== " ").map((e) => {
|
|
const res = this.formatPath(e);
|
|
return {
|
|
path: res.path,
|
|
from: res.from,
|
|
working_dir: e.working_dir === "?" ? "U" : e.working_dir,
|
|
vault_path: this.getVaultPath(res.path)
|
|
};
|
|
}),
|
|
staged: status2.files.filter((e) => e.index !== " " && e.index != "?").map((e) => {
|
|
const res = this.formatPath(e, e.index === "R");
|
|
return {
|
|
path: res.path,
|
|
from: res.from,
|
|
index: e.index,
|
|
vault_path: this.getVaultPath(res.path)
|
|
};
|
|
}),
|
|
conflicted: status2.conflicted.map((path2) => this.formatPath({ path: path2 }).path)
|
|
};
|
|
}
|
|
formatPath(path2, renamed = false) {
|
|
function format(path3) {
|
|
if (path3 == void 0)
|
|
return void 0;
|
|
if (path3.startsWith('"') && path3.endsWith('"')) {
|
|
return path3.substring(1, path3.length - 1);
|
|
} else {
|
|
return path3;
|
|
}
|
|
}
|
|
if (renamed) {
|
|
return {
|
|
from: format(path2.from),
|
|
path: format(path2.path)
|
|
};
|
|
} else {
|
|
return {
|
|
path: format(path2.path)
|
|
};
|
|
}
|
|
}
|
|
async commitAll({ message }) {
|
|
if (this.plugin.settings.updateSubmodules) {
|
|
this.plugin.setState(PluginState.commit);
|
|
await new Promise(async (resolve, reject) => {
|
|
this.git.outputHandler(async (cmd, stdout, stderr, args) => {
|
|
if (!(args.contains("submodule") && args.contains("foreach")))
|
|
return;
|
|
let body = "";
|
|
const root = this.app.vault.adapter.getBasePath() + (this.plugin.settings.basePath ? "/" + this.plugin.settings.basePath : "");
|
|
stdout.on("data", (chunk) => {
|
|
body += chunk.toString("utf8");
|
|
});
|
|
stdout.on("end", async () => {
|
|
const submods = body.split("\n");
|
|
const strippedSubmods = submods.map((i) => {
|
|
const submod = i.match(/'([^']*)'/);
|
|
if (submod != void 0) {
|
|
return root + "/" + submod[1] + import_path.sep;
|
|
}
|
|
});
|
|
strippedSubmods.reverse();
|
|
for (const item of strippedSubmods) {
|
|
if (item != void 0) {
|
|
await this.git.cwd({ path: item, root: false }).add("-A", (err) => this.onError(err));
|
|
await this.git.cwd({ path: item, root: false }).commit(await this.formatCommitMessage(message), (err) => this.onError(err));
|
|
}
|
|
}
|
|
resolve();
|
|
});
|
|
});
|
|
await this.git.subModule(["foreach", "--recursive", ""]);
|
|
this.git.outputHandler(() => {
|
|
});
|
|
});
|
|
}
|
|
this.plugin.setState(PluginState.add);
|
|
await this.git.add("-A", (err) => this.onError(err));
|
|
this.plugin.setState(PluginState.commit);
|
|
return (await this.git.commit(await this.formatCommitMessage(message), (err) => this.onError(err))).summary.changes;
|
|
}
|
|
async commit(message) {
|
|
this.plugin.setState(PluginState.commit);
|
|
const res = (await this.git.commit(await this.formatCommitMessage(message), (err) => this.onError(err))).summary.changes;
|
|
this.plugin.setState(PluginState.idle);
|
|
return res;
|
|
}
|
|
async stage(path2, relativeToVault) {
|
|
this.plugin.setState(PluginState.add);
|
|
path2 = this.getPath(path2, relativeToVault);
|
|
await this.git.add(["--", path2], (err) => this.onError(err));
|
|
this.plugin.setState(PluginState.idle);
|
|
}
|
|
async stageAll({ dir }) {
|
|
this.plugin.setState(PluginState.add);
|
|
await this.git.add(dir != null ? dir : "-A", (err) => this.onError(err));
|
|
this.plugin.setState(PluginState.idle);
|
|
}
|
|
async unstageAll() {
|
|
this.plugin.setState(PluginState.add);
|
|
await this.git.reset([], (err) => this.onError(err));
|
|
this.plugin.setState(PluginState.idle);
|
|
}
|
|
async unstage(path2, relativeToVault) {
|
|
this.plugin.setState(PluginState.add);
|
|
path2 = this.getPath(path2, relativeToVault);
|
|
await this.git.reset(["--", path2], (err) => this.onError(err));
|
|
this.plugin.setState(PluginState.idle);
|
|
}
|
|
async discard(filepath) {
|
|
this.plugin.setState(PluginState.add);
|
|
await this.git.checkout(["--", filepath], (err) => this.onError(err));
|
|
this.plugin.setState(PluginState.idle);
|
|
}
|
|
async pull() {
|
|
this.plugin.setState(PluginState.pull);
|
|
if (this.plugin.settings.updateSubmodules)
|
|
await this.git.subModule(["update", "--remote", "--merge", "--recursive"], (err) => this.onError(err));
|
|
const branchInfo = await this.branchInfo();
|
|
const localCommit = await this.git.revparse([branchInfo.current], (err) => this.onError(err));
|
|
await this.git.fetch((err) => this.onError(err));
|
|
const upstreamCommit = await this.git.revparse([branchInfo.tracking], (err) => this.onError(err));
|
|
if (localCommit !== upstreamCommit) {
|
|
if (this.plugin.settings.syncMethod === "merge" || this.plugin.settings.syncMethod === "rebase") {
|
|
try {
|
|
switch (this.plugin.settings.syncMethod) {
|
|
case "merge":
|
|
await this.git.merge([branchInfo.tracking]);
|
|
break;
|
|
case "rebase":
|
|
await this.git.rebase([branchInfo.tracking]);
|
|
}
|
|
} catch (err) {
|
|
this.plugin.displayError(`Pull failed (${this.plugin.settings.syncMethod}): ${err.message}`);
|
|
return;
|
|
}
|
|
} else if (this.plugin.settings.syncMethod === "reset") {
|
|
try {
|
|
await this.git.raw(["update-ref", `refs/heads/${branchInfo.current}`, upstreamCommit], (err) => this.onError(err));
|
|
await this.unstageAll();
|
|
} catch (err) {
|
|
this.plugin.displayError(`Sync failed (${this.plugin.settings.syncMethod}): ${err.message}`);
|
|
}
|
|
}
|
|
const afterMergeCommit = await this.git.revparse([branchInfo.current], (err) => this.onError(err));
|
|
const filesChanged = await this.git.diff([`${localCommit}..${afterMergeCommit}`, "--name-only"]);
|
|
return filesChanged.split(/\r\n|\r|\n/).filter((value) => value.length > 0).map((e) => {
|
|
return {
|
|
path: e,
|
|
working_dir: "P",
|
|
vault_path: this.getVaultPath(e)
|
|
};
|
|
});
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
async push() {
|
|
this.plugin.setState(PluginState.status);
|
|
const status2 = await this.git.status();
|
|
const trackingBranch = status2.tracking;
|
|
const currentBranch2 = status2.current;
|
|
const remoteChangedFiles = (await this.git.diffSummary([currentBranch2, trackingBranch, "--"], (err) => this.onError(err))).changed;
|
|
this.plugin.setState(PluginState.push);
|
|
if (this.plugin.settings.updateSubmodules) {
|
|
await this.git.env({ ...process.env, "OBSIDIAN_GIT": 1 }).subModule(["foreach", "--recursive", `tracking=$(git for-each-ref --format='%(upstream:short)' "$(git symbolic-ref -q HEAD)"); echo $tracking; if [ ! -z "$(git diff --shortstat $tracking)" ]; then git push; fi`], (err) => this.onError(err));
|
|
}
|
|
await this.git.env({ ...process.env, "OBSIDIAN_GIT": 1 }).push((err) => this.onError(err));
|
|
return remoteChangedFiles;
|
|
}
|
|
async canPush() {
|
|
if (this.plugin.settings.updateSubmodules === true) {
|
|
return true;
|
|
}
|
|
const status2 = await this.git.status((err) => this.onError(err));
|
|
const trackingBranch = status2.tracking;
|
|
const currentBranch2 = status2.current;
|
|
const remoteChangedFiles = (await this.git.diffSummary([currentBranch2, trackingBranch, "--"])).changed;
|
|
return remoteChangedFiles !== 0;
|
|
}
|
|
async checkRequirements() {
|
|
if (!this.isGitInstalled()) {
|
|
return "missing-git";
|
|
}
|
|
if (!await this.git.checkIsRepo()) {
|
|
return "missing-repo";
|
|
}
|
|
return "valid";
|
|
}
|
|
async branchInfo() {
|
|
const status2 = await this.git.status((err) => this.onError(err));
|
|
const branches = await this.git.branch(["--no-color"], (err) => this.onError(err));
|
|
return {
|
|
current: status2.current || void 0,
|
|
tracking: status2.tracking || void 0,
|
|
branches: branches.all
|
|
};
|
|
}
|
|
async getRemoteUrl(remote) {
|
|
return await this.git.remote(["get-url", remote], (err, url) => this.onError(err)) || void 0;
|
|
}
|
|
async log(file, relativeToVault = true) {
|
|
const path2 = this.getPath(file, relativeToVault);
|
|
const res = await this.git.log({ file: path2 }, (err) => this.onError(err));
|
|
return res.all;
|
|
}
|
|
async show(commitHash, file, relativeToVault = true) {
|
|
const path2 = this.getPath(file, relativeToVault);
|
|
return this.git.show([commitHash + ":" + path2], (err) => this.onError(err));
|
|
}
|
|
async checkout(branch2) {
|
|
await this.git.checkout(branch2, (err) => this.onError(err));
|
|
}
|
|
async createBranch(branch2) {
|
|
await this.git.checkout(["-b", branch2], (err) => this.onError(err));
|
|
}
|
|
async deleteBranch(branch2, force) {
|
|
await this.git.branch([force ? "-D" : "-d", branch2], (err) => this.onError(err));
|
|
}
|
|
async branchIsMerged(branch2) {
|
|
const notMergedBranches = await this.git.branch(["--no-merged"], (err) => this.onError(err));
|
|
return !notMergedBranches.all.contains(branch2);
|
|
}
|
|
async init() {
|
|
await this.git.init(false, (err) => this.onError(err));
|
|
}
|
|
async clone(url, dir) {
|
|
await this.git.clone(url, path.join(this.app.vault.adapter.getBasePath(), dir), [], (err) => this.onError(err));
|
|
}
|
|
async setConfig(path2, value) {
|
|
await this.git.addConfig(path2, value, (err) => this.onError(err));
|
|
}
|
|
async getConfig(path2) {
|
|
const config = await this.git.listConfig((err) => this.onError(err));
|
|
return config.all[path2];
|
|
}
|
|
async fetch(remote) {
|
|
await this.git.fetch(remote != void 0 ? [remote] : [], (err) => this.onError(err));
|
|
}
|
|
async setRemote(name, url) {
|
|
if ((await this.getRemotes()).includes(name))
|
|
await this.git.remote(["set-url", name, url], (err) => this.onError(err));
|
|
else {
|
|
await this.git.remote(["add", name, url], (err) => this.onError(err));
|
|
}
|
|
}
|
|
async getRemoteBranches(remote) {
|
|
const res = await this.git.branch(["-r", "--list", `${remote}*`], (err) => this.onError(err));
|
|
console.log(remote);
|
|
console.log(res);
|
|
const list = [];
|
|
for (const item in res.branches) {
|
|
list.push(res.branches[item].name);
|
|
}
|
|
return list;
|
|
}
|
|
async getRemotes() {
|
|
const res = await this.git.remote([], (err) => this.onError(err));
|
|
if (res) {
|
|
return res.trim().split("\n");
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
async removeRemote(remoteName) {
|
|
await this.git.removeRemote(remoteName);
|
|
}
|
|
async updateUpstreamBranch(remoteBranch) {
|
|
try {
|
|
await this.git.branch(["--set-upstream-to", remoteBranch]);
|
|
} catch (e) {
|
|
console.error(e);
|
|
try {
|
|
await this.git.branch(["--set-upstream", remoteBranch]);
|
|
} catch (e2) {
|
|
console.error(e2);
|
|
await this.git.push(["--set-upstream", ...remoteBranch.split("/")], (err) => this.onError(err));
|
|
}
|
|
}
|
|
}
|
|
updateGitPath(gitPath) {
|
|
this.setGitInstance();
|
|
}
|
|
updateBasePath(basePath) {
|
|
this.setGitInstance(true);
|
|
}
|
|
async getDiffString(filePath, stagedChanges = false) {
|
|
if (stagedChanges)
|
|
return await this.git.diff(["--cached", "--", filePath]);
|
|
else
|
|
return await this.git.diff(["--", filePath]);
|
|
}
|
|
async diff(file, commit1, commit2) {
|
|
return await this.git.diff([`${commit1}..${commit2}`, "--", file]);
|
|
}
|
|
isGitInstalled() {
|
|
const command = (0, import_child_process2.spawnSync)(this.plugin.localStorage.getGitPath() || "git", ["--version"], {
|
|
stdio: "ignore"
|
|
});
|
|
if (command.error) {
|
|
console.error(command.error);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
onError(error) {
|
|
if (error) {
|
|
const networkFailure = error.message.contains("Could not resolve host") || error.message.match(/ssh: connect to host .*? port .*?: Operation timed out/);
|
|
if (!networkFailure) {
|
|
this.plugin.displayError(error.message);
|
|
this.plugin.setState(PluginState.idle);
|
|
} else if (!this.plugin.offlineMode) {
|
|
this.plugin.displayError("Git: Going into offline mode. Future network errors will no longer be displayed.", 2e3);
|
|
}
|
|
if (networkFailure) {
|
|
this.plugin.offlineMode = true;
|
|
this.plugin.setState(PluginState.idle);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/settings.ts
|
|
var ObsidianGitSettingsTab = class extends import_obsidian7.PluginSettingTab {
|
|
display() {
|
|
const { containerEl } = this;
|
|
const plugin = this.plugin;
|
|
const commitOrBackup = plugin.settings.differentIntervalCommitAndPush ? "commit" : "backup";
|
|
const gitReady = plugin.gitReady;
|
|
containerEl.empty();
|
|
containerEl.createEl("h2", { text: "Git Backup settings" });
|
|
if (!gitReady) {
|
|
containerEl.createEl("p", { text: "Git is not ready. When all settings are correct you can configure auto backup, etc." });
|
|
}
|
|
if (gitReady) {
|
|
containerEl.createEl("br");
|
|
containerEl.createEl("h3", { text: "Automatic" });
|
|
new import_obsidian7.Setting(containerEl).setName("Split automatic commit and push").setDesc("Enable to use separate timer for commit and push").addToggle((toggle) => toggle.setValue(plugin.settings.differentIntervalCommitAndPush).onChange((value) => {
|
|
plugin.settings.differentIntervalCommitAndPush = value;
|
|
plugin.saveSettings();
|
|
plugin.clearAutoBackup();
|
|
plugin.clearAutoPush();
|
|
if (plugin.settings.autoSaveInterval > 0) {
|
|
plugin.startAutoBackup(plugin.settings.autoSaveInterval);
|
|
}
|
|
if (value && plugin.settings.autoPushInterval > 0) {
|
|
plugin.startAutoPush(plugin.settings.autoPushInterval);
|
|
}
|
|
this.display();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName(`Vault ${commitOrBackup} interval (minutes)`).setDesc(`${plugin.settings.differentIntervalCommitAndPush ? "Commit" : "Commit and push"} changes every X minutes. Set to 0 (default) to disable. (See below setting for further configuration!)`).addText((text2) => text2.setValue(String(plugin.settings.autoSaveInterval)).onChange((value) => {
|
|
if (!isNaN(Number(value))) {
|
|
plugin.settings.autoSaveInterval = Number(value);
|
|
plugin.saveSettings();
|
|
if (plugin.settings.autoSaveInterval > 0) {
|
|
plugin.clearAutoBackup();
|
|
plugin.startAutoBackup(plugin.settings.autoSaveInterval);
|
|
new import_obsidian7.Notice(`Automatic ${commitOrBackup} enabled! Every ${plugin.settings.autoSaveInterval} minutes.`);
|
|
} else if (plugin.settings.autoSaveInterval <= 0) {
|
|
plugin.clearAutoBackup() && new import_obsidian7.Notice(`Automatic ${commitOrBackup} disabled!`);
|
|
}
|
|
} else {
|
|
new import_obsidian7.Notice("Please specify a valid number.");
|
|
}
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName(`If turned on, do auto ${commitOrBackup} every X minutes after last change. Prevents auto ${commitOrBackup} while editing a file. If turned off, do auto ${commitOrBackup} every X minutes. It's independent from last change.`).addToggle((toggle) => toggle.setValue(plugin.settings.autoBackupAfterFileChange).onChange((value) => {
|
|
plugin.settings.autoBackupAfterFileChange = value;
|
|
plugin.saveSettings();
|
|
plugin.clearAutoBackup();
|
|
if (plugin.settings.autoSaveInterval > 0) {
|
|
plugin.startAutoBackup(plugin.settings.autoSaveInterval);
|
|
}
|
|
}));
|
|
if (plugin.settings.differentIntervalCommitAndPush) {
|
|
new import_obsidian7.Setting(containerEl).setName(`Vault push interval (minutes)`).setDesc("Push changes every X minutes. Set to 0 (default) to disable.").addText((text2) => text2.setValue(String(plugin.settings.autoPushInterval)).onChange((value) => {
|
|
if (!isNaN(Number(value))) {
|
|
plugin.settings.autoPushInterval = Number(value);
|
|
plugin.saveSettings();
|
|
if (plugin.settings.autoPushInterval > 0) {
|
|
plugin.clearAutoPush();
|
|
plugin.startAutoPush(plugin.settings.autoPushInterval);
|
|
new import_obsidian7.Notice(`Automatic push enabled! Every ${plugin.settings.autoPushInterval} minutes.`);
|
|
} else if (plugin.settings.autoPushInterval <= 0) {
|
|
plugin.clearAutoPush() && new import_obsidian7.Notice("Automatic push disabled!");
|
|
}
|
|
} else {
|
|
new import_obsidian7.Notice("Please specify a valid number.");
|
|
}
|
|
}));
|
|
}
|
|
new import_obsidian7.Setting(containerEl).setName("Auto pull interval (minutes)").setDesc("Pull changes every X minutes. Set to 0 (default) to disable.").addText((text2) => text2.setValue(String(plugin.settings.autoPullInterval)).onChange((value) => {
|
|
if (!isNaN(Number(value))) {
|
|
plugin.settings.autoPullInterval = Number(value);
|
|
plugin.saveSettings();
|
|
if (plugin.settings.autoPullInterval > 0) {
|
|
plugin.clearAutoPull();
|
|
plugin.startAutoPull(plugin.settings.autoPullInterval);
|
|
new import_obsidian7.Notice(`Automatic pull enabled! Every ${plugin.settings.autoPullInterval} minutes.`);
|
|
} else if (plugin.settings.autoPullInterval <= 0) {
|
|
plugin.clearAutoPull() && new import_obsidian7.Notice("Automatic pull disabled!");
|
|
}
|
|
} else {
|
|
new import_obsidian7.Notice("Please specify a valid number.");
|
|
}
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Commit message on manual backup/commit").setDesc("Available placeholders: {{date}} (see below), {{hostname}} (see below) and {{numFiles}} (number of changed files in the commit)").addText((text2) => text2.setPlaceholder("vault backup: {{date}}").setValue(plugin.settings.commitMessage ? plugin.settings.commitMessage : "").onChange((value) => {
|
|
plugin.settings.commitMessage = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Specify custom commit message on auto backup").setDesc("You will get a pop up to specify your message").addToggle((toggle) => toggle.setValue(plugin.settings.customMessageOnAutoBackup).onChange((value) => {
|
|
plugin.settings.customMessageOnAutoBackup = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Commit message on auto backup/commit").setDesc("Available placeholders: {{date}} (see below), {{hostname}} (see below) and {{numFiles}} (number of changed files in the commit)").addText((text2) => text2.setPlaceholder("vault backup: {{date}}").setValue(plugin.settings.autoCommitMessage).onChange((value) => {
|
|
plugin.settings.autoCommitMessage = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
containerEl.createEl("br");
|
|
containerEl.createEl("h3", { text: "Commit message" });
|
|
new import_obsidian7.Setting(containerEl).setName("{{date}} placeholder format").setDesc('Specify custom date format. E.g. "YYYY-MM-DD HH:mm:ss"').addText((text2) => text2.setPlaceholder(plugin.settings.commitDateFormat).setValue(plugin.settings.commitDateFormat).onChange(async (value) => {
|
|
plugin.settings.commitDateFormat = value;
|
|
await plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("{{hostname}} placeholder replacement").setDesc("Specify custom hostname for every device.").addText((text2) => {
|
|
var _a2;
|
|
return text2.setValue((_a2 = plugin.localStorage.getHostname()) != null ? _a2 : "").onChange(async (value) => {
|
|
plugin.localStorage.setHostname(value);
|
|
});
|
|
});
|
|
new import_obsidian7.Setting(containerEl).setName("Preview commit message").addButton((button) => button.setButtonText("Preview").onClick(async () => {
|
|
const commitMessagePreview = await plugin.gitManager.formatCommitMessage(plugin.settings.commitMessage);
|
|
new import_obsidian7.Notice(`${commitMessagePreview}`);
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("List filenames affected by commit in the commit body").addToggle((toggle) => toggle.setValue(plugin.settings.listChangedFilesInMessageBody).onChange((value) => {
|
|
plugin.settings.listChangedFilesInMessageBody = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
containerEl.createEl("br");
|
|
containerEl.createEl("h3", { text: "Backup" });
|
|
if (plugin.gitManager instanceof SimpleGit)
|
|
new import_obsidian7.Setting(containerEl).setName("Sync Method").setDesc("Selects the method used for handling new changes found in your remote git repository.").addDropdown((dropdown) => {
|
|
const options = {
|
|
"merge": "Merge",
|
|
"rebase": "Rebase",
|
|
"reset": "Other sync service (Only updates the HEAD without touching the working directory)"
|
|
};
|
|
dropdown.addOptions(options);
|
|
dropdown.setValue(plugin.settings.syncMethod);
|
|
dropdown.onChange(async (option) => {
|
|
plugin.settings.syncMethod = option;
|
|
plugin.saveSettings();
|
|
});
|
|
});
|
|
new import_obsidian7.Setting(containerEl).setName("Pull updates on startup").setDesc("Automatically pull updates when Obsidian starts").addToggle((toggle) => toggle.setValue(plugin.settings.autoPullOnBoot).onChange((value) => {
|
|
plugin.settings.autoPullOnBoot = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Push on backup").setDesc("Disable to only commit changes").addToggle((toggle) => toggle.setValue(!plugin.settings.disablePush).onChange((value) => {
|
|
plugin.settings.disablePush = !value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Pull changes before push").setDesc("Commit -> pull -> push (Only if pushing is enabled)").addToggle((toggle) => toggle.setValue(plugin.settings.pullBeforePush).onChange((value) => {
|
|
plugin.settings.pullBeforePush = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
}
|
|
containerEl.createEl("br");
|
|
containerEl.createEl("h3", { text: "Miscellaneous" });
|
|
new import_obsidian7.Setting(containerEl).setName("Automatically refresh Source Control View on file changes").setDesc("On slower machines this may cause lags. If so, just disable this option").addToggle((toggle) => toggle.setValue(plugin.settings.refreshSourceControl).onChange((value) => {
|
|
plugin.settings.refreshSourceControl = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Source Control View refresh interval").setDesc("Milliseconds to wait after file change before refreshing the Source Control View").addText((toggle) => toggle.setValue(plugin.settings.refreshSourceControlTimer.toString()).setPlaceholder("7000").onChange((value) => {
|
|
plugin.settings.refreshSourceControlTimer = Math.max(parseInt(value), 500);
|
|
plugin.saveSettings();
|
|
plugin.setRefreshDebouncer();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Disable notifications").setDesc("Disable notifications for git operations to minimize distraction (refer to status bar for updates). Errors are still shown as notifications even if you enable this setting").addToggle((toggle) => toggle.setValue(plugin.settings.disablePopups).onChange((value) => {
|
|
plugin.settings.disablePopups = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Show status bar").setDesc("Obsidian must be restarted for the changes to take affect").addToggle((toggle) => toggle.setValue(plugin.settings.showStatusBar).onChange((value) => {
|
|
plugin.settings.showStatusBar = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Show branch status bar").setDesc("Obsidian must be restarted for the changes to take affect").addToggle((toggle) => toggle.setValue(plugin.settings.showBranchStatusBar).onChange((value) => {
|
|
plugin.settings.showBranchStatusBar = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Show changes files count in status bar").addToggle((toggle) => toggle.setValue(plugin.settings.changedFilesInStatusBar).onChange((value) => {
|
|
plugin.settings.changedFilesInStatusBar = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
containerEl.createEl("br");
|
|
containerEl.createEl("h3", { text: "Advanced" });
|
|
if (plugin.gitManager instanceof SimpleGit)
|
|
new import_obsidian7.Setting(containerEl).setName("Update submodules").setDesc('"Create backup" and "pull" takes care of submodules. Missing features: Conflicted files, count of pulled/pushed/committed files. Tracking branch needs to be set for each submodule').addToggle((toggle) => toggle.setValue(plugin.settings.updateSubmodules).onChange((value) => {
|
|
plugin.settings.updateSubmodules = value;
|
|
plugin.saveSettings();
|
|
}));
|
|
if (plugin.gitManager instanceof SimpleGit)
|
|
new import_obsidian7.Setting(containerEl).setName("Custom Git binary path").addText((cb) => {
|
|
var _a2;
|
|
cb.setValue((_a2 = plugin.localStorage.getGitPath()) != null ? _a2 : "");
|
|
cb.setPlaceholder("git");
|
|
cb.onChange((value) => {
|
|
plugin.localStorage.setGitPath(value);
|
|
plugin.gitManager.updateGitPath(value || "git");
|
|
});
|
|
});
|
|
if (plugin.gitManager instanceof IsomorphicGit)
|
|
new import_obsidian7.Setting(containerEl).setName("Username on your git server. E.g. your username on GitHub").addText((cb) => {
|
|
cb.setValue(plugin.settings.username);
|
|
cb.onChange((value) => {
|
|
plugin.settings.username = value;
|
|
plugin.saveSettings();
|
|
});
|
|
});
|
|
if (plugin.gitManager instanceof IsomorphicGit)
|
|
new import_obsidian7.Setting(containerEl).setName("Password/Personal access token").setDesc("Type in your password. You won't be able to see it again.").addText((cb) => {
|
|
cb.inputEl.autocapitalize = "off";
|
|
cb.inputEl.autocomplete = "off";
|
|
cb.inputEl.spellcheck = false;
|
|
cb.onChange((value) => {
|
|
plugin.localStorage.setPassword(value);
|
|
});
|
|
});
|
|
if (gitReady)
|
|
new import_obsidian7.Setting(containerEl).setName("Author name for commit").addText(async (cb) => {
|
|
cb.setValue(await plugin.gitManager.getConfig("user.name"));
|
|
cb.onChange((value) => {
|
|
plugin.gitManager.setConfig("user.name", value);
|
|
});
|
|
});
|
|
if (gitReady)
|
|
new import_obsidian7.Setting(containerEl).setName("Author email for commit").addText(async (cb) => {
|
|
cb.setValue(await plugin.gitManager.getConfig("user.email"));
|
|
cb.onChange((value) => {
|
|
plugin.gitManager.setConfig("user.email", value);
|
|
});
|
|
});
|
|
new import_obsidian7.Setting(containerEl).setName("Custom base path (Git repository path)").setDesc(`
|
|
Sets the relative path to the vault from which the Git binary should be executed.
|
|
Mostly used to set the path to the Git repository, which is only required if the Git repository is below the vault root directory. Use "\\" instead of "/" on Windows.
|
|
`).addText((cb) => {
|
|
cb.setValue(plugin.settings.basePath);
|
|
cb.setPlaceholder("directory/directory-with-git-repo");
|
|
cb.onChange((value) => {
|
|
plugin.settings.basePath = value;
|
|
plugin.saveSettings();
|
|
plugin.gitManager.updateBasePath(value || "");
|
|
});
|
|
});
|
|
new import_obsidian7.Setting(containerEl).setName("Disable on this device").addToggle((toggle) => toggle.setValue(plugin.localStorage.getPluginDisabled()).onChange((value) => {
|
|
plugin.localStorage.setPluginDisabled(value);
|
|
if (value) {
|
|
plugin.unloadPlugin();
|
|
} else {
|
|
plugin.loadPlugin();
|
|
}
|
|
new import_obsidian7.Notice("Obsidian must be restarted for the changes to take affect");
|
|
}));
|
|
new import_obsidian7.Setting(containerEl).setName("Donate").setDesc("If you like this Plugin, consider donating to support continued development.").addButton((bt) => {
|
|
bt.buttonEl.outerHTML = "<a href='https://ko-fi.com/F1F195IQ5' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://cdn.ko-fi.com/cdn/kofi3.png?v=3' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>";
|
|
});
|
|
const info = containerEl.createDiv();
|
|
info.setAttr("align", "center");
|
|
info.setText("Debugging and logging:\nYou can always see the logs of this and every other plugin by opening the console with");
|
|
const keys = containerEl.createDiv();
|
|
keys.setAttr("align", "center");
|
|
keys.addClass("obsidian-git-shortcuts");
|
|
if (import_obsidian7.Platform.isMacOS === true) {
|
|
keys.createEl("kbd", { text: "CMD (\u2318) + OPTION (\u2325) + I" });
|
|
} else {
|
|
keys.createEl("kbd", { text: "CTRL + SHIFT + I" });
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/statusBar.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian8 = __toModule(require("obsidian"));
|
|
var StatusBar = class {
|
|
constructor(statusBarEl, plugin) {
|
|
this.statusBarEl = statusBarEl;
|
|
this.plugin = plugin;
|
|
this.messages = [];
|
|
this.base = "obsidian-git-statusbar-";
|
|
this.statusBarEl.setAttribute("aria-label-position", "top");
|
|
}
|
|
displayMessage(message, timeout) {
|
|
this.messages.push({
|
|
message: `Git: ${message.slice(0, 100)}`,
|
|
timeout
|
|
});
|
|
this.display();
|
|
}
|
|
display() {
|
|
if (this.messages.length > 0 && !this.currentMessage) {
|
|
this.currentMessage = this.messages.shift();
|
|
this.statusBarEl.addClass(this.base + "message");
|
|
this.statusBarEl.ariaLabel = "";
|
|
this.statusBarEl.setText(this.currentMessage.message);
|
|
this.lastMessageTimestamp = Date.now();
|
|
} else if (this.currentMessage) {
|
|
const messageAge = Date.now() - this.lastMessageTimestamp;
|
|
if (messageAge >= this.currentMessage.timeout) {
|
|
this.currentMessage = null;
|
|
this.lastMessageTimestamp = null;
|
|
}
|
|
} else {
|
|
this.displayState();
|
|
}
|
|
}
|
|
displayState() {
|
|
if (this.statusBarEl.getText().length > 3 || !this.statusBarEl.hasChildNodes()) {
|
|
this.statusBarEl.empty();
|
|
this.iconEl = this.statusBarEl.createDiv();
|
|
this.textEl = this.statusBarEl.createDiv();
|
|
this.textEl.style.float = "right";
|
|
this.textEl.style.marginLeft = "5px";
|
|
this.iconEl.style.float = "left";
|
|
}
|
|
switch (this.plugin.state) {
|
|
case PluginState.idle:
|
|
this.displayFromNow(this.plugin.lastUpdate);
|
|
break;
|
|
case PluginState.status:
|
|
this.statusBarEl.ariaLabel = "Checking repository status...";
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "refresh-cw");
|
|
this.statusBarEl.addClass(this.base + "status");
|
|
break;
|
|
case PluginState.add:
|
|
this.statusBarEl.ariaLabel = "Adding files...";
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "refresh-w");
|
|
this.statusBarEl.addClass(this.base + "add");
|
|
break;
|
|
case PluginState.commit:
|
|
this.statusBarEl.ariaLabel = "Committing changes...";
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "git-commit");
|
|
this.statusBarEl.addClass(this.base + "commit");
|
|
break;
|
|
case PluginState.push:
|
|
this.statusBarEl.ariaLabel = "Pushing changes...";
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "upload");
|
|
this.statusBarEl.addClass(this.base + "push");
|
|
break;
|
|
case PluginState.pull:
|
|
this.statusBarEl.ariaLabel = "Pulling changes...";
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "download");
|
|
this.statusBarEl.addClass(this.base + "pull");
|
|
break;
|
|
case PluginState.conflicted:
|
|
this.statusBarEl.ariaLabel = "You have conflict files...";
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "alert-circle");
|
|
this.statusBarEl.addClass(this.base + "conflict");
|
|
break;
|
|
default:
|
|
this.statusBarEl.ariaLabel = "Failed on initialization!";
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "alert-triangle");
|
|
this.statusBarEl.addClass(this.base + "failed-init");
|
|
break;
|
|
}
|
|
}
|
|
displayFromNow(timestamp) {
|
|
if (timestamp) {
|
|
const moment = window.moment;
|
|
const fromNow = moment(timestamp).fromNow();
|
|
this.statusBarEl.ariaLabel = `${this.plugin.offlineMode ? "Offline: " : ""}Last Git update: ${fromNow}`;
|
|
} else {
|
|
this.statusBarEl.ariaLabel = this.plugin.offlineMode ? "Git is offline" : "Git is ready";
|
|
}
|
|
if (this.plugin.offlineMode) {
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "globe");
|
|
} else {
|
|
(0, import_obsidian8.setIcon)(this.iconEl, "check");
|
|
}
|
|
if (this.plugin.settings.changedFilesInStatusBar && this.plugin.cachedStatus) {
|
|
this.textEl.setText(this.plugin.cachedStatus.changed.length.toString());
|
|
}
|
|
this.statusBarEl.addClass(this.base + "idle");
|
|
}
|
|
};
|
|
|
|
// src/ui/modals/changedFilesModal.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian9 = __toModule(require("obsidian"));
|
|
var ChangedFilesModal = class extends import_obsidian9.FuzzySuggestModal {
|
|
constructor(plugin, changedFiles) {
|
|
super(plugin.app);
|
|
this.plugin = plugin;
|
|
this.changedFiles = changedFiles;
|
|
this.setPlaceholder("Not supported files will be opened by default app!");
|
|
}
|
|
getItems() {
|
|
return this.changedFiles;
|
|
}
|
|
getItemText(item) {
|
|
if (item.index == "U" && item.working_dir == "U") {
|
|
return `Untracked | ${item.vault_path}`;
|
|
}
|
|
let working_dir = "";
|
|
let index2 = "";
|
|
if (item.working_dir != " ")
|
|
working_dir = `Working dir: ${item.working_dir} `;
|
|
if (item.index != " ")
|
|
index2 = `Index: ${item.index}`;
|
|
return `${working_dir}${index2} | ${item.vault_path}`;
|
|
}
|
|
onChooseItem(item, _) {
|
|
if (this.plugin.app.metadataCache.getFirstLinkpathDest(item.vault_path, "") == null) {
|
|
this.app.openWithDefaultApp(item.vault_path);
|
|
} else {
|
|
this.plugin.app.workspace.openLinkText(item.vault_path, "/");
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/ui/modals/customMessageModal.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian10 = __toModule(require("obsidian"));
|
|
var CustomMessageModal = class extends import_obsidian10.SuggestModal {
|
|
constructor(plugin, fromAutoBackup) {
|
|
super(plugin.app);
|
|
this.fromAutoBackup = fromAutoBackup;
|
|
this.resolve = null;
|
|
this.plugin = plugin;
|
|
this.setPlaceholder("Type your message and select optional the version with the added date.");
|
|
}
|
|
open() {
|
|
super.open();
|
|
return new Promise((resolve) => {
|
|
this.resolve = resolve;
|
|
});
|
|
}
|
|
onClose() {
|
|
if (this.resolve)
|
|
this.resolve(void 0);
|
|
}
|
|
selectSuggestion(value, evt) {
|
|
if (this.resolve)
|
|
this.resolve(value);
|
|
super.selectSuggestion(value, evt);
|
|
}
|
|
getSuggestions(query) {
|
|
const date = window.moment().format(this.plugin.settings.commitDateFormat);
|
|
if (query == "")
|
|
query = "...";
|
|
return [query, `${date}: ${query}`, `${query}: ${date}`];
|
|
}
|
|
renderSuggestion(value, el) {
|
|
el.innerText = value;
|
|
}
|
|
onChooseSuggestion(item, _) {
|
|
}
|
|
};
|
|
|
|
// src/constants.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian11 = __toModule(require("obsidian"));
|
|
var DEFAULT_SETTINGS = {
|
|
commitMessage: "vault backup: {{date}}",
|
|
autoCommitMessage: void 0,
|
|
commitDateFormat: "YYYY-MM-DD HH:mm:ss",
|
|
autoSaveInterval: 0,
|
|
autoPushInterval: 0,
|
|
autoPullInterval: 0,
|
|
autoPullOnBoot: false,
|
|
disablePush: false,
|
|
pullBeforePush: true,
|
|
disablePopups: false,
|
|
listChangedFilesInMessageBody: false,
|
|
showStatusBar: true,
|
|
updateSubmodules: false,
|
|
syncMethod: "merge",
|
|
customMessageOnAutoBackup: false,
|
|
autoBackupAfterFileChange: false,
|
|
treeStructure: false,
|
|
refreshSourceControl: import_obsidian11.Platform.isDesktopApp,
|
|
basePath: "",
|
|
differentIntervalCommitAndPush: false,
|
|
changedFilesInStatusBar: false,
|
|
username: "",
|
|
showedMobileNotice: false,
|
|
refreshSourceControlTimer: 7e3,
|
|
showBranchStatusBar: true
|
|
};
|
|
var GIT_VIEW_CONFIG = {
|
|
type: "git-view",
|
|
name: "Source Control",
|
|
icon: "git-pull-request"
|
|
};
|
|
var DIFF_VIEW_CONFIG = {
|
|
type: "diff-view",
|
|
name: "Diff View",
|
|
icon: "git-pull-request"
|
|
};
|
|
|
|
// src/localStorageSettings.ts
|
|
init_polyfill_buffer();
|
|
var LocalStorageSettings = class {
|
|
constructor(plugin) {
|
|
this.plugin = plugin;
|
|
this.prefix = this.plugin.manifest.id + ":";
|
|
}
|
|
migrate() {
|
|
const keys = ["password", "hostname", "conflict", "lastAutoPull", "lastAutoBackup", "lastAutoPush", "gitPath", "pluginDisabled"];
|
|
for (const key2 of keys) {
|
|
const old = localStorage.getItem(this.prefix + key2);
|
|
if (app.loadLocalStorage(this.prefix + key2) == null && old != null) {
|
|
if (old != null) {
|
|
app.saveLocalStorage(this.prefix + key2, old);
|
|
localStorage.removeItem(this.prefix + key2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
getPassword() {
|
|
return app.loadLocalStorage(this.prefix + "password");
|
|
}
|
|
setPassword(value) {
|
|
return app.saveLocalStorage(this.prefix + "password", value);
|
|
}
|
|
getHostname() {
|
|
return app.loadLocalStorage(this.prefix + "hostname");
|
|
}
|
|
setHostname(value) {
|
|
return app.saveLocalStorage(this.prefix + "hostname", value);
|
|
}
|
|
getConflict() {
|
|
return app.loadLocalStorage(this.prefix + "conflict");
|
|
}
|
|
setConflict(value) {
|
|
return app.saveLocalStorage(this.prefix + "conflict", value);
|
|
}
|
|
getLastAutoPull() {
|
|
return app.loadLocalStorage(this.prefix + "lastAutoPull");
|
|
}
|
|
setLastAutoPull(value) {
|
|
return app.saveLocalStorage(this.prefix + "lastAutoPull", value);
|
|
}
|
|
getLastAutoBackup() {
|
|
return app.loadLocalStorage(this.prefix + "lastAutoBackup");
|
|
}
|
|
setLastAutoBackup(value) {
|
|
return app.saveLocalStorage(this.prefix + "lastAutoBackup", value);
|
|
}
|
|
getLastAutoPush() {
|
|
return app.loadLocalStorage(this.prefix + "lastAutoPush");
|
|
}
|
|
setLastAutoPush(value) {
|
|
return app.saveLocalStorage(this.prefix + "lastAutoPush", value);
|
|
}
|
|
getGitPath() {
|
|
return app.loadLocalStorage(this.prefix + "gitPath");
|
|
}
|
|
setGitPath(value) {
|
|
return app.saveLocalStorage(this.prefix + "gitPath", value);
|
|
}
|
|
getPluginDisabled() {
|
|
return app.loadLocalStorage(this.prefix + "pluginDisabled") == "true";
|
|
}
|
|
setPluginDisabled(value) {
|
|
return app.saveLocalStorage(this.prefix + "pluginDisabled", `${value}`);
|
|
}
|
|
};
|
|
|
|
// src/openInGitHub.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian12 = __toModule(require("obsidian"));
|
|
async function openLineInGitHub(editor, file, manager) {
|
|
const { isGitHub, branch: branch2, repo, user } = await getData(manager);
|
|
if (isGitHub) {
|
|
const path2 = manager.getPath(file.path, true);
|
|
const from = editor.getCursor("from").line + 1;
|
|
const to = editor.getCursor("to").line + 1;
|
|
if (from === to) {
|
|
window.open(`https://github.com/${user}/${repo}/blob/${branch2}/${path2}?plain=1#L${from}`);
|
|
} else {
|
|
window.open(`https://github.com/${user}/${repo}/blob/${branch2}/${path2}?plain=1#L${from}-L${to}`);
|
|
}
|
|
} else {
|
|
new import_obsidian12.Notice("It seems like you are not using GitHub");
|
|
}
|
|
}
|
|
async function openHistoryInGitHub(file, manager) {
|
|
const { isGitHub, branch: branch2, repo, user } = await getData(manager);
|
|
const path2 = manager.getPath(file.path, true);
|
|
if (isGitHub) {
|
|
window.open(`https://github.com/${user}/${repo}/commits/${branch2}/${path2}`);
|
|
} else {
|
|
new import_obsidian12.Notice("It seems like you are not using GitHub");
|
|
}
|
|
}
|
|
async function getData(manager) {
|
|
const branchInfo = await manager.branchInfo();
|
|
const remoteBranch = branchInfo.tracking;
|
|
const branch2 = branchInfo.current;
|
|
const remote = remoteBranch.substring(0, remoteBranch.indexOf("/"));
|
|
const remoteUrl = await manager.getConfig(`remote.${remote}.url`);
|
|
const [isGitHub, httpsUser, httpsRepo, sshUser, sshRepo] = remoteUrl.match(/(?:^https:\/\/github\.com\/(.*)\/(.*)\.git$)|(?:^git@github\.com:(.*)\/(.*)\.git$)/);
|
|
return {
|
|
isGitHub: !!isGitHub,
|
|
repo: httpsRepo || sshRepo,
|
|
user: httpsUser || sshUser,
|
|
branch: branch2
|
|
};
|
|
}
|
|
|
|
// src/ui/diff/diffView.ts
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/diff2html/lib-esm/diff2html.js
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/diff2html/lib-esm/diff-parser.js
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/diff2html/lib-esm/types.js
|
|
init_polyfill_buffer();
|
|
var LineType;
|
|
(function(LineType2) {
|
|
LineType2["INSERT"] = "insert";
|
|
LineType2["DELETE"] = "delete";
|
|
LineType2["CONTEXT"] = "context";
|
|
})(LineType || (LineType = {}));
|
|
var OutputFormatType = {
|
|
LINE_BY_LINE: "line-by-line",
|
|
SIDE_BY_SIDE: "side-by-side"
|
|
};
|
|
var LineMatchingType = {
|
|
LINES: "lines",
|
|
WORDS: "words",
|
|
NONE: "none"
|
|
};
|
|
var DiffStyleType = {
|
|
WORD: "word",
|
|
CHAR: "char"
|
|
};
|
|
|
|
// node_modules/diff2html/lib-esm/utils.js
|
|
init_polyfill_buffer();
|
|
var specials = [
|
|
"-",
|
|
"[",
|
|
"]",
|
|
"/",
|
|
"{",
|
|
"}",
|
|
"(",
|
|
")",
|
|
"*",
|
|
"+",
|
|
"?",
|
|
".",
|
|
"\\",
|
|
"^",
|
|
"$",
|
|
"|"
|
|
];
|
|
var regex = RegExp("[" + specials.join("\\") + "]", "g");
|
|
function escapeForRegExp(str) {
|
|
return str.replace(regex, "\\$&");
|
|
}
|
|
function unifyPath(path2) {
|
|
return path2 ? path2.replace(/\\/g, "/") : path2;
|
|
}
|
|
function hashCode(text2) {
|
|
var i, chr, len;
|
|
var hash2 = 0;
|
|
for (i = 0, len = text2.length; i < len; i++) {
|
|
chr = text2.charCodeAt(i);
|
|
hash2 = (hash2 << 5) - hash2 + chr;
|
|
hash2 |= 0;
|
|
}
|
|
return hash2;
|
|
}
|
|
|
|
// node_modules/diff2html/lib-esm/diff-parser.js
|
|
var __spreadArray = function(to, from, pack) {
|
|
if (pack || arguments.length === 2)
|
|
for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar)
|
|
ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
function getExtension(filename, language) {
|
|
var filenameParts = filename.split(".");
|
|
return filenameParts.length > 1 ? filenameParts[filenameParts.length - 1] : language;
|
|
}
|
|
function startsWithAny(str, prefixes) {
|
|
return prefixes.reduce(function(startsWith, prefix) {
|
|
return startsWith || str.startsWith(prefix);
|
|
}, false);
|
|
}
|
|
var baseDiffFilenamePrefixes = ["a/", "b/", "i/", "w/", "c/", "o/"];
|
|
function getFilename(line, linePrefix, extraPrefix) {
|
|
var prefixes = extraPrefix !== void 0 ? __spreadArray(__spreadArray([], baseDiffFilenamePrefixes, true), [extraPrefix], false) : baseDiffFilenamePrefixes;
|
|
var FilenameRegExp = linePrefix ? new RegExp("^".concat(escapeForRegExp(linePrefix), ' "?(.+?)"?$')) : new RegExp('^"?(.+?)"?$');
|
|
var _a2 = FilenameRegExp.exec(line) || [], _b = _a2[1], filename = _b === void 0 ? "" : _b;
|
|
var matchingPrefix = prefixes.find(function(p) {
|
|
return filename.indexOf(p) === 0;
|
|
});
|
|
var fnameWithoutPrefix = matchingPrefix ? filename.slice(matchingPrefix.length) : filename;
|
|
return fnameWithoutPrefix.replace(/\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)? [+-]\d{4}.*$/, "");
|
|
}
|
|
function getSrcFilename(line, srcPrefix) {
|
|
return getFilename(line, "---", srcPrefix);
|
|
}
|
|
function getDstFilename(line, dstPrefix) {
|
|
return getFilename(line, "+++", dstPrefix);
|
|
}
|
|
function parse(diffInput, config) {
|
|
if (config === void 0) {
|
|
config = {};
|
|
}
|
|
var files = [];
|
|
var currentFile = null;
|
|
var currentBlock = null;
|
|
var oldLine = null;
|
|
var oldLine2 = null;
|
|
var newLine = null;
|
|
var possibleOldName = null;
|
|
var possibleNewName = null;
|
|
var oldFileNameHeader = "--- ";
|
|
var newFileNameHeader = "+++ ";
|
|
var hunkHeaderPrefix = "@@";
|
|
var oldMode = /^old mode (\d{6})/;
|
|
var newMode = /^new mode (\d{6})/;
|
|
var deletedFileMode = /^deleted file mode (\d{6})/;
|
|
var newFileMode = /^new file mode (\d{6})/;
|
|
var copyFrom = /^copy from "?(.+)"?/;
|
|
var copyTo = /^copy to "?(.+)"?/;
|
|
var renameFrom = /^rename from "?(.+)"?/;
|
|
var renameTo = /^rename to "?(.+)"?/;
|
|
var similarityIndex = /^similarity index (\d+)%/;
|
|
var dissimilarityIndex = /^dissimilarity index (\d+)%/;
|
|
var index2 = /^index ([\da-z]+)\.\.([\da-z]+)\s*(\d{6})?/;
|
|
var binaryFiles = /^Binary files (.*) and (.*) differ/;
|
|
var binaryDiff = /^GIT binary patch/;
|
|
var combinedIndex = /^index ([\da-z]+),([\da-z]+)\.\.([\da-z]+)/;
|
|
var combinedMode = /^mode (\d{6}),(\d{6})\.\.(\d{6})/;
|
|
var combinedNewFile = /^new file mode (\d{6})/;
|
|
var combinedDeletedFile = /^deleted file mode (\d{6}),(\d{6})/;
|
|
var diffLines2 = diffInput.replace(/\\ No newline at end of file/g, "").replace(/\r\n?/g, "\n").split("\n");
|
|
function saveBlock() {
|
|
if (currentBlock !== null && currentFile !== null) {
|
|
currentFile.blocks.push(currentBlock);
|
|
currentBlock = null;
|
|
}
|
|
}
|
|
function saveFile() {
|
|
if (currentFile !== null) {
|
|
if (!currentFile.oldName && possibleOldName !== null) {
|
|
currentFile.oldName = possibleOldName;
|
|
}
|
|
if (!currentFile.newName && possibleNewName !== null) {
|
|
currentFile.newName = possibleNewName;
|
|
}
|
|
if (currentFile.newName) {
|
|
files.push(currentFile);
|
|
currentFile = null;
|
|
}
|
|
}
|
|
possibleOldName = null;
|
|
possibleNewName = null;
|
|
}
|
|
function startFile() {
|
|
saveBlock();
|
|
saveFile();
|
|
currentFile = {
|
|
blocks: [],
|
|
deletedLines: 0,
|
|
addedLines: 0
|
|
};
|
|
}
|
|
function startBlock(line) {
|
|
saveBlock();
|
|
var values;
|
|
if (currentFile !== null) {
|
|
if (values = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@.*/.exec(line)) {
|
|
currentFile.isCombined = false;
|
|
oldLine = parseInt(values[1], 10);
|
|
newLine = parseInt(values[2], 10);
|
|
} else if (values = /^@@@ -(\d+)(?:,\d+)? -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@@.*/.exec(line)) {
|
|
currentFile.isCombined = true;
|
|
oldLine = parseInt(values[1], 10);
|
|
oldLine2 = parseInt(values[2], 10);
|
|
newLine = parseInt(values[3], 10);
|
|
} else {
|
|
if (line.startsWith(hunkHeaderPrefix)) {
|
|
console.error("Failed to parse lines, starting in 0!");
|
|
}
|
|
oldLine = 0;
|
|
newLine = 0;
|
|
currentFile.isCombined = false;
|
|
}
|
|
}
|
|
currentBlock = {
|
|
lines: [],
|
|
oldStartLine: oldLine,
|
|
oldStartLine2: oldLine2,
|
|
newStartLine: newLine,
|
|
header: line
|
|
};
|
|
}
|
|
function createLine(line) {
|
|
if (currentFile === null || currentBlock === null || oldLine === null || newLine === null)
|
|
return;
|
|
var currentLine = {
|
|
content: line
|
|
};
|
|
var addedPrefixes = currentFile.isCombined ? ["+ ", " +", "++"] : ["+"];
|
|
var deletedPrefixes = currentFile.isCombined ? ["- ", " -", "--"] : ["-"];
|
|
if (startsWithAny(line, addedPrefixes)) {
|
|
currentFile.addedLines++;
|
|
currentLine.type = LineType.INSERT;
|
|
currentLine.oldNumber = void 0;
|
|
currentLine.newNumber = newLine++;
|
|
} else if (startsWithAny(line, deletedPrefixes)) {
|
|
currentFile.deletedLines++;
|
|
currentLine.type = LineType.DELETE;
|
|
currentLine.oldNumber = oldLine++;
|
|
currentLine.newNumber = void 0;
|
|
} else {
|
|
currentLine.type = LineType.CONTEXT;
|
|
currentLine.oldNumber = oldLine++;
|
|
currentLine.newNumber = newLine++;
|
|
}
|
|
currentBlock.lines.push(currentLine);
|
|
}
|
|
function existHunkHeader(line, lineIdx) {
|
|
var idx = lineIdx;
|
|
while (idx < diffLines2.length - 3) {
|
|
if (line.startsWith("diff")) {
|
|
return false;
|
|
}
|
|
if (diffLines2[idx].startsWith(oldFileNameHeader) && diffLines2[idx + 1].startsWith(newFileNameHeader) && diffLines2[idx + 2].startsWith(hunkHeaderPrefix)) {
|
|
return true;
|
|
}
|
|
idx++;
|
|
}
|
|
return false;
|
|
}
|
|
diffLines2.forEach(function(line, lineIndex) {
|
|
if (!line || line.startsWith("*")) {
|
|
return;
|
|
}
|
|
var values;
|
|
var prevLine = diffLines2[lineIndex - 1];
|
|
var nxtLine = diffLines2[lineIndex + 1];
|
|
var afterNxtLine = diffLines2[lineIndex + 2];
|
|
if (line.startsWith("diff")) {
|
|
startFile();
|
|
var gitDiffStart = /^diff --git "?([a-ciow]\/.+)"? "?([a-ciow]\/.+)"?/;
|
|
if (values = gitDiffStart.exec(line)) {
|
|
possibleOldName = getFilename(values[1], void 0, config.dstPrefix);
|
|
possibleNewName = getFilename(values[2], void 0, config.srcPrefix);
|
|
}
|
|
if (currentFile === null) {
|
|
throw new Error("Where is my file !!!");
|
|
}
|
|
currentFile.isGitDiff = true;
|
|
return;
|
|
}
|
|
if (!currentFile || !currentFile.isGitDiff && currentFile && line.startsWith(oldFileNameHeader) && nxtLine.startsWith(newFileNameHeader) && afterNxtLine.startsWith(hunkHeaderPrefix)) {
|
|
startFile();
|
|
}
|
|
if (currentFile === null || currentFile === void 0 ? void 0 : currentFile.isTooBig) {
|
|
return;
|
|
}
|
|
if (currentFile && (typeof config.diffMaxChanges === "number" && currentFile.addedLines + currentFile.deletedLines > config.diffMaxChanges || typeof config.diffMaxLineLength === "number" && line.length > config.diffMaxLineLength)) {
|
|
currentFile.isTooBig = true;
|
|
currentFile.addedLines = 0;
|
|
currentFile.deletedLines = 0;
|
|
currentFile.blocks = [];
|
|
currentBlock = null;
|
|
var message = typeof config.diffTooBigMessage === "function" ? config.diffTooBigMessage(files.length) : "Diff too big to be displayed";
|
|
startBlock(message);
|
|
return;
|
|
}
|
|
if (line.startsWith(oldFileNameHeader) && nxtLine.startsWith(newFileNameHeader) || line.startsWith(newFileNameHeader) && prevLine.startsWith(oldFileNameHeader)) {
|
|
if (currentFile && !currentFile.oldName && line.startsWith("--- ") && (values = getSrcFilename(line, config.srcPrefix))) {
|
|
currentFile.oldName = values;
|
|
currentFile.language = getExtension(currentFile.oldName, currentFile.language);
|
|
return;
|
|
}
|
|
if (currentFile && !currentFile.newName && line.startsWith("+++ ") && (values = getDstFilename(line, config.dstPrefix))) {
|
|
currentFile.newName = values;
|
|
currentFile.language = getExtension(currentFile.newName, currentFile.language);
|
|
return;
|
|
}
|
|
}
|
|
if (currentFile && (line.startsWith(hunkHeaderPrefix) || currentFile.isGitDiff && currentFile.oldName && currentFile.newName && !currentBlock)) {
|
|
startBlock(line);
|
|
return;
|
|
}
|
|
if (currentBlock && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
|
|
createLine(line);
|
|
return;
|
|
}
|
|
var doesNotExistHunkHeader = !existHunkHeader(line, lineIndex);
|
|
if (currentFile === null) {
|
|
throw new Error("Where is my file !!!");
|
|
}
|
|
if (values = oldMode.exec(line)) {
|
|
currentFile.oldMode = values[1];
|
|
} else if (values = newMode.exec(line)) {
|
|
currentFile.newMode = values[1];
|
|
} else if (values = deletedFileMode.exec(line)) {
|
|
currentFile.deletedFileMode = values[1];
|
|
currentFile.isDeleted = true;
|
|
} else if (values = newFileMode.exec(line)) {
|
|
currentFile.newFileMode = values[1];
|
|
currentFile.isNew = true;
|
|
} else if (values = copyFrom.exec(line)) {
|
|
if (doesNotExistHunkHeader) {
|
|
currentFile.oldName = values[1];
|
|
}
|
|
currentFile.isCopy = true;
|
|
} else if (values = copyTo.exec(line)) {
|
|
if (doesNotExistHunkHeader) {
|
|
currentFile.newName = values[1];
|
|
}
|
|
currentFile.isCopy = true;
|
|
} else if (values = renameFrom.exec(line)) {
|
|
if (doesNotExistHunkHeader) {
|
|
currentFile.oldName = values[1];
|
|
}
|
|
currentFile.isRename = true;
|
|
} else if (values = renameTo.exec(line)) {
|
|
if (doesNotExistHunkHeader) {
|
|
currentFile.newName = values[1];
|
|
}
|
|
currentFile.isRename = true;
|
|
} else if (values = binaryFiles.exec(line)) {
|
|
currentFile.isBinary = true;
|
|
currentFile.oldName = getFilename(values[1], void 0, config.srcPrefix);
|
|
currentFile.newName = getFilename(values[2], void 0, config.dstPrefix);
|
|
startBlock("Binary file");
|
|
} else if (binaryDiff.test(line)) {
|
|
currentFile.isBinary = true;
|
|
startBlock(line);
|
|
} else if (values = similarityIndex.exec(line)) {
|
|
currentFile.unchangedPercentage = parseInt(values[1], 10);
|
|
} else if (values = dissimilarityIndex.exec(line)) {
|
|
currentFile.changedPercentage = parseInt(values[1], 10);
|
|
} else if (values = index2.exec(line)) {
|
|
currentFile.checksumBefore = values[1];
|
|
currentFile.checksumAfter = values[2];
|
|
values[3] && (currentFile.mode = values[3]);
|
|
} else if (values = combinedIndex.exec(line)) {
|
|
currentFile.checksumBefore = [values[2], values[3]];
|
|
currentFile.checksumAfter = values[1];
|
|
} else if (values = combinedMode.exec(line)) {
|
|
currentFile.oldMode = [values[2], values[3]];
|
|
currentFile.newMode = values[1];
|
|
} else if (values = combinedNewFile.exec(line)) {
|
|
currentFile.newFileMode = values[1];
|
|
currentFile.isNew = true;
|
|
} else if (values = combinedDeletedFile.exec(line)) {
|
|
currentFile.deletedFileMode = values[1];
|
|
currentFile.isDeleted = true;
|
|
}
|
|
});
|
|
saveBlock();
|
|
saveFile();
|
|
return files;
|
|
}
|
|
|
|
// node_modules/diff2html/lib-esm/file-list-renderer.js
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/diff2html/lib-esm/render-utils.js
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/diff2html/lib-esm/rematch.js
|
|
init_polyfill_buffer();
|
|
function levenshtein(a, b) {
|
|
if (a.length === 0) {
|
|
return b.length;
|
|
}
|
|
if (b.length === 0) {
|
|
return a.length;
|
|
}
|
|
var matrix = [];
|
|
var i;
|
|
for (i = 0; i <= b.length; i++) {
|
|
matrix[i] = [i];
|
|
}
|
|
var j;
|
|
for (j = 0; j <= a.length; j++) {
|
|
matrix[0][j] = j;
|
|
}
|
|
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];
|
|
} else {
|
|
matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
|
|
}
|
|
}
|
|
}
|
|
return matrix[b.length][a.length];
|
|
}
|
|
function newDistanceFn(str) {
|
|
return function(x, y) {
|
|
var xValue = str(x).trim();
|
|
var yValue = str(y).trim();
|
|
var lev = levenshtein(xValue, yValue);
|
|
return lev / (xValue.length + yValue.length);
|
|
};
|
|
}
|
|
function newMatcherFn(distance2) {
|
|
function findBestMatch(a, b, cache) {
|
|
if (cache === void 0) {
|
|
cache = new Map();
|
|
}
|
|
var bestMatchDist = Infinity;
|
|
var bestMatch;
|
|
for (var i = 0; i < a.length; ++i) {
|
|
for (var j = 0; j < b.length; ++j) {
|
|
var cacheKey = JSON.stringify([a[i], b[j]]);
|
|
var md = void 0;
|
|
if (!(cache.has(cacheKey) && (md = cache.get(cacheKey)))) {
|
|
md = distance2(a[i], b[j]);
|
|
cache.set(cacheKey, md);
|
|
}
|
|
if (md < bestMatchDist) {
|
|
bestMatchDist = md;
|
|
bestMatch = { indexA: i, indexB: j, score: bestMatchDist };
|
|
}
|
|
}
|
|
}
|
|
return bestMatch;
|
|
}
|
|
function group(a, b, level, cache) {
|
|
if (level === void 0) {
|
|
level = 0;
|
|
}
|
|
if (cache === void 0) {
|
|
cache = new Map();
|
|
}
|
|
var bm = findBestMatch(a, b, cache);
|
|
if (!bm || a.length + b.length < 3) {
|
|
return [[a, b]];
|
|
}
|
|
var a1 = a.slice(0, bm.indexA);
|
|
var b1 = b.slice(0, bm.indexB);
|
|
var aMatch = [a[bm.indexA]];
|
|
var bMatch = [b[bm.indexB]];
|
|
var tailA = bm.indexA + 1;
|
|
var tailB = bm.indexB + 1;
|
|
var a2 = a.slice(tailA);
|
|
var b2 = b.slice(tailB);
|
|
var group1 = group(a1, b1, level + 1, cache);
|
|
var groupMatch = group(aMatch, bMatch, level + 1, cache);
|
|
var group2 = group(a2, b2, level + 1, cache);
|
|
var result = groupMatch;
|
|
if (bm.indexA > 0 || bm.indexB > 0) {
|
|
result = group1.concat(result);
|
|
}
|
|
if (a.length > tailA || b.length > tailB) {
|
|
result = result.concat(group2);
|
|
}
|
|
return result;
|
|
}
|
|
return group;
|
|
}
|
|
|
|
// node_modules/diff2html/lib-esm/render-utils.js
|
|
var __assign = function() {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
var CSSLineClass = {
|
|
INSERTS: "d2h-ins",
|
|
DELETES: "d2h-del",
|
|
CONTEXT: "d2h-cntx",
|
|
INFO: "d2h-info",
|
|
INSERT_CHANGES: "d2h-ins d2h-change",
|
|
DELETE_CHANGES: "d2h-del d2h-change"
|
|
};
|
|
var defaultRenderConfig = {
|
|
matching: LineMatchingType.NONE,
|
|
matchWordsThreshold: 0.25,
|
|
maxLineLengthHighlight: 1e4,
|
|
diffStyle: DiffStyleType.WORD
|
|
};
|
|
var separator = "/";
|
|
var distance = newDistanceFn(function(change) {
|
|
return change.value;
|
|
});
|
|
var matcher = newMatcherFn(distance);
|
|
function isDevNullName(name) {
|
|
return name.indexOf("dev/null") !== -1;
|
|
}
|
|
function removeInsElements(line) {
|
|
return line.replace(/(<ins[^>]*>((.|\n)*?)<\/ins>)/g, "");
|
|
}
|
|
function removeDelElements(line) {
|
|
return line.replace(/(<del[^>]*>((.|\n)*?)<\/del>)/g, "");
|
|
}
|
|
function toCSSClass(lineType) {
|
|
switch (lineType) {
|
|
case LineType.CONTEXT:
|
|
return CSSLineClass.CONTEXT;
|
|
case LineType.INSERT:
|
|
return CSSLineClass.INSERTS;
|
|
case LineType.DELETE:
|
|
return CSSLineClass.DELETES;
|
|
}
|
|
}
|
|
function prefixLength(isCombined) {
|
|
return isCombined ? 2 : 1;
|
|
}
|
|
function escapeForHtml(str) {
|
|
return str.slice(0).replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """).replace(/'/g, "'").replace(/\//g, "/");
|
|
}
|
|
function deconstructLine(line, isCombined, escape) {
|
|
if (escape === void 0) {
|
|
escape = true;
|
|
}
|
|
var indexToSplit = prefixLength(isCombined);
|
|
return {
|
|
prefix: line.substring(0, indexToSplit),
|
|
content: escape ? escapeForHtml(line.substring(indexToSplit)) : line.substring(indexToSplit)
|
|
};
|
|
}
|
|
function filenameDiff(file) {
|
|
var oldFilename = unifyPath(file.oldName);
|
|
var newFilename = unifyPath(file.newName);
|
|
if (oldFilename !== newFilename && !isDevNullName(oldFilename) && !isDevNullName(newFilename)) {
|
|
var prefixPaths = [];
|
|
var suffixPaths = [];
|
|
var oldFilenameParts = oldFilename.split(separator);
|
|
var newFilenameParts = newFilename.split(separator);
|
|
var oldFilenamePartsSize = oldFilenameParts.length;
|
|
var newFilenamePartsSize = newFilenameParts.length;
|
|
var i = 0;
|
|
var j = oldFilenamePartsSize - 1;
|
|
var k = newFilenamePartsSize - 1;
|
|
while (i < j && i < k) {
|
|
if (oldFilenameParts[i] === newFilenameParts[i]) {
|
|
prefixPaths.push(newFilenameParts[i]);
|
|
i += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
while (j > i && k > i) {
|
|
if (oldFilenameParts[j] === newFilenameParts[k]) {
|
|
suffixPaths.unshift(newFilenameParts[k]);
|
|
j -= 1;
|
|
k -= 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
var finalPrefix = prefixPaths.join(separator);
|
|
var finalSuffix = suffixPaths.join(separator);
|
|
var oldRemainingPath = oldFilenameParts.slice(i, j + 1).join(separator);
|
|
var newRemainingPath = newFilenameParts.slice(i, k + 1).join(separator);
|
|
if (finalPrefix.length && finalSuffix.length) {
|
|
return finalPrefix + separator + "{" + oldRemainingPath + " \u2192 " + newRemainingPath + "}" + separator + finalSuffix;
|
|
} else if (finalPrefix.length) {
|
|
return finalPrefix + separator + "{" + oldRemainingPath + " \u2192 " + newRemainingPath + "}";
|
|
} else if (finalSuffix.length) {
|
|
return "{" + oldRemainingPath + " \u2192 " + newRemainingPath + "}" + separator + finalSuffix;
|
|
}
|
|
return oldFilename + " \u2192 " + newFilename;
|
|
} else if (!isDevNullName(newFilename)) {
|
|
return newFilename;
|
|
} else {
|
|
return oldFilename;
|
|
}
|
|
}
|
|
function getHtmlId(file) {
|
|
return "d2h-".concat(hashCode(filenameDiff(file)).toString().slice(-6));
|
|
}
|
|
function getFileIcon(file) {
|
|
var templateName = "file-changed";
|
|
if (file.isRename) {
|
|
templateName = "file-renamed";
|
|
} else if (file.isCopy) {
|
|
templateName = "file-renamed";
|
|
} else if (file.isNew) {
|
|
templateName = "file-added";
|
|
} else if (file.isDeleted) {
|
|
templateName = "file-deleted";
|
|
} else if (file.newName !== file.oldName) {
|
|
templateName = "file-renamed";
|
|
}
|
|
return templateName;
|
|
}
|
|
function diffHighlight(diffLine1, diffLine2, isCombined, config) {
|
|
if (config === void 0) {
|
|
config = {};
|
|
}
|
|
var _a2 = __assign(__assign({}, defaultRenderConfig), config), matching = _a2.matching, maxLineLengthHighlight = _a2.maxLineLengthHighlight, matchWordsThreshold = _a2.matchWordsThreshold, diffStyle = _a2.diffStyle;
|
|
var line1 = deconstructLine(diffLine1, isCombined, false);
|
|
var line2 = deconstructLine(diffLine2, isCombined, false);
|
|
if (line1.content.length > maxLineLengthHighlight || line2.content.length > maxLineLengthHighlight) {
|
|
return {
|
|
oldLine: {
|
|
prefix: line1.prefix,
|
|
content: escapeForHtml(line1.content)
|
|
},
|
|
newLine: {
|
|
prefix: line2.prefix,
|
|
content: escapeForHtml(line2.content)
|
|
}
|
|
};
|
|
}
|
|
var diff2 = diffStyle === "char" ? diffChars(line1.content, line2.content) : diffWordsWithSpace(line1.content, line2.content);
|
|
var changedWords = [];
|
|
if (diffStyle === "word" && matching === "words") {
|
|
var removed = diff2.filter(function(element2) {
|
|
return element2.removed;
|
|
});
|
|
var added = diff2.filter(function(element2) {
|
|
return element2.added;
|
|
});
|
|
var chunks = matcher(added, removed);
|
|
chunks.forEach(function(chunk) {
|
|
if (chunk[0].length === 1 && chunk[1].length === 1) {
|
|
var dist = distance(chunk[0][0], chunk[1][0]);
|
|
if (dist < matchWordsThreshold) {
|
|
changedWords.push(chunk[0][0]);
|
|
changedWords.push(chunk[1][0]);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
var highlightedLine = diff2.reduce(function(highlightedLine2, part) {
|
|
var elemType = part.added ? "ins" : part.removed ? "del" : null;
|
|
var addClass = changedWords.indexOf(part) > -1 ? ' class="d2h-change"' : "";
|
|
var escapedValue = escapeForHtml(part.value);
|
|
return elemType !== null ? "".concat(highlightedLine2, "<").concat(elemType).concat(addClass, ">").concat(escapedValue, "</").concat(elemType, ">") : "".concat(highlightedLine2).concat(escapedValue);
|
|
}, "");
|
|
return {
|
|
oldLine: {
|
|
prefix: line1.prefix,
|
|
content: removeInsElements(highlightedLine)
|
|
},
|
|
newLine: {
|
|
prefix: line2.prefix,
|
|
content: removeDelElements(highlightedLine)
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/diff2html/lib-esm/file-list-renderer.js
|
|
var baseTemplatesPath = "file-summary";
|
|
var iconsBaseTemplatesPath = "icon";
|
|
function render(diffFiles, hoganUtils) {
|
|
var files = diffFiles.map(function(file) {
|
|
return hoganUtils.render(baseTemplatesPath, "line", {
|
|
fileHtmlId: getHtmlId(file),
|
|
oldName: file.oldName,
|
|
newName: file.newName,
|
|
fileName: filenameDiff(file),
|
|
deletedLines: "-" + file.deletedLines,
|
|
addedLines: "+" + file.addedLines
|
|
}, {
|
|
fileIcon: hoganUtils.template(iconsBaseTemplatesPath, getFileIcon(file))
|
|
});
|
|
}).join("\n");
|
|
return hoganUtils.render(baseTemplatesPath, "wrapper", {
|
|
filesNumber: diffFiles.length,
|
|
files
|
|
});
|
|
}
|
|
|
|
// node_modules/diff2html/lib-esm/line-by-line-renderer.js
|
|
init_polyfill_buffer();
|
|
var __assign2 = function() {
|
|
__assign2 = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign2.apply(this, arguments);
|
|
};
|
|
var defaultLineByLineRendererConfig = __assign2(__assign2({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 });
|
|
var genericTemplatesPath = "generic";
|
|
var baseTemplatesPath2 = "line-by-line";
|
|
var iconsBaseTemplatesPath2 = "icon";
|
|
var tagsBaseTemplatesPath = "tag";
|
|
var LineByLineRenderer = function() {
|
|
function LineByLineRenderer2(hoganUtils, config) {
|
|
if (config === void 0) {
|
|
config = {};
|
|
}
|
|
this.hoganUtils = hoganUtils;
|
|
this.config = __assign2(__assign2({}, defaultLineByLineRendererConfig), config);
|
|
}
|
|
LineByLineRenderer2.prototype.render = function(diffFiles) {
|
|
var _this = this;
|
|
var diffsHtml = diffFiles.map(function(file) {
|
|
var diffs;
|
|
if (file.blocks.length) {
|
|
diffs = _this.generateFileHtml(file);
|
|
} else {
|
|
diffs = _this.generateEmptyDiff();
|
|
}
|
|
return _this.makeFileDiffHtml(file, diffs);
|
|
}).join("\n");
|
|
return this.hoganUtils.render(genericTemplatesPath, "wrapper", { content: diffsHtml });
|
|
};
|
|
LineByLineRenderer2.prototype.makeFileDiffHtml = function(file, diffs) {
|
|
if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0)
|
|
return "";
|
|
var fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath2, "file-diff");
|
|
var filePathTemplate = this.hoganUtils.template(genericTemplatesPath, "file-path");
|
|
var fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath2, "file");
|
|
var fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath, getFileIcon(file));
|
|
return fileDiffTemplate.render({
|
|
file,
|
|
fileHtmlId: getHtmlId(file),
|
|
diffs,
|
|
filePath: filePathTemplate.render({
|
|
fileDiffName: filenameDiff(file)
|
|
}, {
|
|
fileIcon: fileIconTemplate,
|
|
fileTag: fileTagTemplate
|
|
})
|
|
});
|
|
};
|
|
LineByLineRenderer2.prototype.generateEmptyDiff = function() {
|
|
return this.hoganUtils.render(genericTemplatesPath, "empty-diff", {
|
|
contentClass: "d2h-code-line",
|
|
CSSLineClass
|
|
});
|
|
};
|
|
LineByLineRenderer2.prototype.generateFileHtml = function(file) {
|
|
var _this = this;
|
|
var matcher2 = newMatcherFn(newDistanceFn(function(e) {
|
|
return deconstructLine(e.content, file.isCombined).content;
|
|
}));
|
|
return file.blocks.map(function(block) {
|
|
var lines = _this.hoganUtils.render(genericTemplatesPath, "block-header", {
|
|
CSSLineClass,
|
|
blockHeader: file.isTooBig ? block.header : escapeForHtml(block.header),
|
|
lineClass: "d2h-code-linenumber",
|
|
contentClass: "d2h-code-line"
|
|
});
|
|
_this.applyLineGroupping(block).forEach(function(_a2) {
|
|
var contextLines = _a2[0], oldLines = _a2[1], newLines = _a2[2];
|
|
if (oldLines.length && newLines.length && !contextLines.length) {
|
|
_this.applyRematchMatching(oldLines, newLines, matcher2).map(function(_a3) {
|
|
var oldLines2 = _a3[0], newLines2 = _a3[1];
|
|
var _b2 = _this.processChangedLines(file.isCombined, oldLines2, newLines2), left2 = _b2.left, right2 = _b2.right;
|
|
lines += left2;
|
|
lines += right2;
|
|
});
|
|
} else if (contextLines.length) {
|
|
contextLines.forEach(function(line) {
|
|
var _a3 = deconstructLine(line.content, file.isCombined), prefix = _a3.prefix, content = _a3.content;
|
|
lines += _this.generateSingleLineHtml({
|
|
type: CSSLineClass.CONTEXT,
|
|
prefix,
|
|
content,
|
|
oldNumber: line.oldNumber,
|
|
newNumber: line.newNumber
|
|
});
|
|
});
|
|
} else if (oldLines.length || newLines.length) {
|
|
var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right;
|
|
lines += left;
|
|
lines += right;
|
|
} else {
|
|
console.error("Unknown state reached while processing groups of lines", contextLines, oldLines, newLines);
|
|
}
|
|
});
|
|
return lines;
|
|
}).join("\n");
|
|
};
|
|
LineByLineRenderer2.prototype.applyLineGroupping = function(block) {
|
|
var blockLinesGroups = [];
|
|
var oldLines = [];
|
|
var newLines = [];
|
|
for (var i = 0; i < block.lines.length; i++) {
|
|
var diffLine = block.lines[i];
|
|
if (diffLine.type !== LineType.INSERT && newLines.length || diffLine.type === LineType.CONTEXT && oldLines.length > 0) {
|
|
blockLinesGroups.push([[], oldLines, newLines]);
|
|
oldLines = [];
|
|
newLines = [];
|
|
}
|
|
if (diffLine.type === LineType.CONTEXT) {
|
|
blockLinesGroups.push([[diffLine], [], []]);
|
|
} else if (diffLine.type === LineType.INSERT && oldLines.length === 0) {
|
|
blockLinesGroups.push([[], [], [diffLine]]);
|
|
} else if (diffLine.type === LineType.INSERT && oldLines.length > 0) {
|
|
newLines.push(diffLine);
|
|
} else if (diffLine.type === LineType.DELETE) {
|
|
oldLines.push(diffLine);
|
|
}
|
|
}
|
|
if (oldLines.length || newLines.length) {
|
|
blockLinesGroups.push([[], oldLines, newLines]);
|
|
oldLines = [];
|
|
newLines = [];
|
|
}
|
|
return blockLinesGroups;
|
|
};
|
|
LineByLineRenderer2.prototype.applyRematchMatching = function(oldLines, newLines, matcher2) {
|
|
var comparisons = oldLines.length * newLines.length;
|
|
var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function(elem) {
|
|
return elem.content.length;
|
|
})));
|
|
var doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words");
|
|
return doMatching ? matcher2(oldLines, newLines) : [[oldLines, newLines]];
|
|
};
|
|
LineByLineRenderer2.prototype.processChangedLines = function(isCombined, oldLines, newLines) {
|
|
var fileHtml = {
|
|
right: "",
|
|
left: ""
|
|
};
|
|
var maxLinesNumber = Math.max(oldLines.length, newLines.length);
|
|
for (var i = 0; i < maxLinesNumber; i++) {
|
|
var oldLine = oldLines[i];
|
|
var newLine = newLines[i];
|
|
var diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0;
|
|
var preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? __assign2(__assign2({}, diff2 !== void 0 ? {
|
|
prefix: diff2.oldLine.prefix,
|
|
content: diff2.oldLine.content,
|
|
type: CSSLineClass.DELETE_CHANGES
|
|
} : __assign2(__assign2({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { oldNumber: oldLine.oldNumber, newNumber: oldLine.newNumber }) : void 0;
|
|
var preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? __assign2(__assign2({}, diff2 !== void 0 ? {
|
|
prefix: diff2.newLine.prefix,
|
|
content: diff2.newLine.content,
|
|
type: CSSLineClass.INSERT_CHANGES
|
|
} : __assign2(__assign2({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { oldNumber: newLine.oldNumber, newNumber: newLine.newNumber }) : void 0;
|
|
var _a2 = this.generateLineHtml(preparedOldLine, preparedNewLine), left = _a2.left, right = _a2.right;
|
|
fileHtml.left += left;
|
|
fileHtml.right += right;
|
|
}
|
|
return fileHtml;
|
|
};
|
|
LineByLineRenderer2.prototype.generateLineHtml = function(oldLine, newLine) {
|
|
return {
|
|
left: this.generateSingleLineHtml(oldLine),
|
|
right: this.generateSingleLineHtml(newLine)
|
|
};
|
|
};
|
|
LineByLineRenderer2.prototype.generateSingleLineHtml = function(line) {
|
|
if (line === void 0)
|
|
return "";
|
|
var lineNumberHtml = this.hoganUtils.render(baseTemplatesPath2, "numbers", {
|
|
oldNumber: line.oldNumber || "",
|
|
newNumber: line.newNumber || ""
|
|
});
|
|
return this.hoganUtils.render(genericTemplatesPath, "line", {
|
|
type: line.type,
|
|
lineClass: "d2h-code-linenumber",
|
|
contentClass: "d2h-code-line",
|
|
prefix: line.prefix === " " ? " " : line.prefix,
|
|
content: line.content,
|
|
lineNumber: lineNumberHtml
|
|
});
|
|
};
|
|
return LineByLineRenderer2;
|
|
}();
|
|
var line_by_line_renderer_default = LineByLineRenderer;
|
|
|
|
// node_modules/diff2html/lib-esm/side-by-side-renderer.js
|
|
init_polyfill_buffer();
|
|
var __assign3 = function() {
|
|
__assign3 = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign3.apply(this, arguments);
|
|
};
|
|
var defaultSideBySideRendererConfig = __assign3(__assign3({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 });
|
|
var genericTemplatesPath2 = "generic";
|
|
var baseTemplatesPath3 = "side-by-side";
|
|
var iconsBaseTemplatesPath3 = "icon";
|
|
var tagsBaseTemplatesPath2 = "tag";
|
|
var SideBySideRenderer = function() {
|
|
function SideBySideRenderer2(hoganUtils, config) {
|
|
if (config === void 0) {
|
|
config = {};
|
|
}
|
|
this.hoganUtils = hoganUtils;
|
|
this.config = __assign3(__assign3({}, defaultSideBySideRendererConfig), config);
|
|
}
|
|
SideBySideRenderer2.prototype.render = function(diffFiles) {
|
|
var _this = this;
|
|
var diffsHtml = diffFiles.map(function(file) {
|
|
var diffs;
|
|
if (file.blocks.length) {
|
|
diffs = _this.generateFileHtml(file);
|
|
} else {
|
|
diffs = _this.generateEmptyDiff();
|
|
}
|
|
return _this.makeFileDiffHtml(file, diffs);
|
|
}).join("\n");
|
|
return this.hoganUtils.render(genericTemplatesPath2, "wrapper", { content: diffsHtml });
|
|
};
|
|
SideBySideRenderer2.prototype.makeFileDiffHtml = function(file, diffs) {
|
|
if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0)
|
|
return "";
|
|
var fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath3, "file-diff");
|
|
var filePathTemplate = this.hoganUtils.template(genericTemplatesPath2, "file-path");
|
|
var fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath3, "file");
|
|
var fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath2, getFileIcon(file));
|
|
return fileDiffTemplate.render({
|
|
file,
|
|
fileHtmlId: getHtmlId(file),
|
|
diffs,
|
|
filePath: filePathTemplate.render({
|
|
fileDiffName: filenameDiff(file)
|
|
}, {
|
|
fileIcon: fileIconTemplate,
|
|
fileTag: fileTagTemplate
|
|
})
|
|
});
|
|
};
|
|
SideBySideRenderer2.prototype.generateEmptyDiff = function() {
|
|
return {
|
|
right: "",
|
|
left: this.hoganUtils.render(genericTemplatesPath2, "empty-diff", {
|
|
contentClass: "d2h-code-side-line",
|
|
CSSLineClass
|
|
})
|
|
};
|
|
};
|
|
SideBySideRenderer2.prototype.generateFileHtml = function(file) {
|
|
var _this = this;
|
|
var matcher2 = newMatcherFn(newDistanceFn(function(e) {
|
|
return deconstructLine(e.content, file.isCombined).content;
|
|
}));
|
|
return file.blocks.map(function(block) {
|
|
var fileHtml = {
|
|
left: _this.makeHeaderHtml(block.header, file),
|
|
right: _this.makeHeaderHtml("")
|
|
};
|
|
_this.applyLineGroupping(block).forEach(function(_a2) {
|
|
var contextLines = _a2[0], oldLines = _a2[1], newLines = _a2[2];
|
|
if (oldLines.length && newLines.length && !contextLines.length) {
|
|
_this.applyRematchMatching(oldLines, newLines, matcher2).map(function(_a3) {
|
|
var oldLines2 = _a3[0], newLines2 = _a3[1];
|
|
var _b2 = _this.processChangedLines(file.isCombined, oldLines2, newLines2), left2 = _b2.left, right2 = _b2.right;
|
|
fileHtml.left += left2;
|
|
fileHtml.right += right2;
|
|
});
|
|
} else if (contextLines.length) {
|
|
contextLines.forEach(function(line) {
|
|
var _a3 = deconstructLine(line.content, file.isCombined), prefix = _a3.prefix, content = _a3.content;
|
|
var _b2 = _this.generateLineHtml({
|
|
type: CSSLineClass.CONTEXT,
|
|
prefix,
|
|
content,
|
|
number: line.oldNumber
|
|
}, {
|
|
type: CSSLineClass.CONTEXT,
|
|
prefix,
|
|
content,
|
|
number: line.newNumber
|
|
}), left2 = _b2.left, right2 = _b2.right;
|
|
fileHtml.left += left2;
|
|
fileHtml.right += right2;
|
|
});
|
|
} else if (oldLines.length || newLines.length) {
|
|
var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right;
|
|
fileHtml.left += left;
|
|
fileHtml.right += right;
|
|
} else {
|
|
console.error("Unknown state reached while processing groups of lines", contextLines, oldLines, newLines);
|
|
}
|
|
});
|
|
return fileHtml;
|
|
}).reduce(function(accomulated, html2) {
|
|
return { left: accomulated.left + html2.left, right: accomulated.right + html2.right };
|
|
}, { left: "", right: "" });
|
|
};
|
|
SideBySideRenderer2.prototype.applyLineGroupping = function(block) {
|
|
var blockLinesGroups = [];
|
|
var oldLines = [];
|
|
var newLines = [];
|
|
for (var i = 0; i < block.lines.length; i++) {
|
|
var diffLine = block.lines[i];
|
|
if (diffLine.type !== LineType.INSERT && newLines.length || diffLine.type === LineType.CONTEXT && oldLines.length > 0) {
|
|
blockLinesGroups.push([[], oldLines, newLines]);
|
|
oldLines = [];
|
|
newLines = [];
|
|
}
|
|
if (diffLine.type === LineType.CONTEXT) {
|
|
blockLinesGroups.push([[diffLine], [], []]);
|
|
} else if (diffLine.type === LineType.INSERT && oldLines.length === 0) {
|
|
blockLinesGroups.push([[], [], [diffLine]]);
|
|
} else if (diffLine.type === LineType.INSERT && oldLines.length > 0) {
|
|
newLines.push(diffLine);
|
|
} else if (diffLine.type === LineType.DELETE) {
|
|
oldLines.push(diffLine);
|
|
}
|
|
}
|
|
if (oldLines.length || newLines.length) {
|
|
blockLinesGroups.push([[], oldLines, newLines]);
|
|
oldLines = [];
|
|
newLines = [];
|
|
}
|
|
return blockLinesGroups;
|
|
};
|
|
SideBySideRenderer2.prototype.applyRematchMatching = function(oldLines, newLines, matcher2) {
|
|
var comparisons = oldLines.length * newLines.length;
|
|
var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function(elem) {
|
|
return elem.content.length;
|
|
})));
|
|
var doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words");
|
|
return doMatching ? matcher2(oldLines, newLines) : [[oldLines, newLines]];
|
|
};
|
|
SideBySideRenderer2.prototype.makeHeaderHtml = function(blockHeader, file) {
|
|
return this.hoganUtils.render(genericTemplatesPath2, "block-header", {
|
|
CSSLineClass,
|
|
blockHeader: (file === null || file === void 0 ? void 0 : file.isTooBig) ? blockHeader : escapeForHtml(blockHeader),
|
|
lineClass: "d2h-code-side-linenumber",
|
|
contentClass: "d2h-code-side-line"
|
|
});
|
|
};
|
|
SideBySideRenderer2.prototype.processChangedLines = function(isCombined, oldLines, newLines) {
|
|
var fileHtml = {
|
|
right: "",
|
|
left: ""
|
|
};
|
|
var maxLinesNumber = Math.max(oldLines.length, newLines.length);
|
|
for (var i = 0; i < maxLinesNumber; i++) {
|
|
var oldLine = oldLines[i];
|
|
var newLine = newLines[i];
|
|
var diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0;
|
|
var preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? __assign3(__assign3({}, diff2 !== void 0 ? {
|
|
prefix: diff2.oldLine.prefix,
|
|
content: diff2.oldLine.content,
|
|
type: CSSLineClass.DELETE_CHANGES
|
|
} : __assign3(__assign3({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { number: oldLine.oldNumber }) : void 0;
|
|
var preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? __assign3(__assign3({}, diff2 !== void 0 ? {
|
|
prefix: diff2.newLine.prefix,
|
|
content: diff2.newLine.content,
|
|
type: CSSLineClass.INSERT_CHANGES
|
|
} : __assign3(__assign3({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { number: newLine.newNumber }) : void 0;
|
|
var _a2 = this.generateLineHtml(preparedOldLine, preparedNewLine), left = _a2.left, right = _a2.right;
|
|
fileHtml.left += left;
|
|
fileHtml.right += right;
|
|
}
|
|
return fileHtml;
|
|
};
|
|
SideBySideRenderer2.prototype.generateLineHtml = function(oldLine, newLine) {
|
|
return {
|
|
left: this.generateSingleHtml(oldLine),
|
|
right: this.generateSingleHtml(newLine)
|
|
};
|
|
};
|
|
SideBySideRenderer2.prototype.generateSingleHtml = function(line) {
|
|
var lineClass = "d2h-code-side-linenumber";
|
|
var contentClass = "d2h-code-side-line";
|
|
return this.hoganUtils.render(genericTemplatesPath2, "line", {
|
|
type: (line === null || line === void 0 ? void 0 : line.type) || "".concat(CSSLineClass.CONTEXT, " d2h-emptyplaceholder"),
|
|
lineClass: line !== void 0 ? lineClass : "".concat(lineClass, " d2h-code-side-emptyplaceholder"),
|
|
contentClass: line !== void 0 ? contentClass : "".concat(contentClass, " d2h-code-side-emptyplaceholder"),
|
|
prefix: (line === null || line === void 0 ? void 0 : line.prefix) === " " ? " " : line === null || line === void 0 ? void 0 : line.prefix,
|
|
content: line === null || line === void 0 ? void 0 : line.content,
|
|
lineNumber: line === null || line === void 0 ? void 0 : line.number
|
|
});
|
|
};
|
|
return SideBySideRenderer2;
|
|
}();
|
|
var side_by_side_renderer_default = SideBySideRenderer;
|
|
|
|
// node_modules/diff2html/lib-esm/hoganjs-utils.js
|
|
init_polyfill_buffer();
|
|
var Hogan3 = __toModule(require_hogan());
|
|
|
|
// node_modules/diff2html/lib-esm/diff2html-templates.js
|
|
init_polyfill_buffer();
|
|
var Hogan2 = __toModule(require_hogan());
|
|
var defaultTemplates = {};
|
|
defaultTemplates["file-summary-line"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<li class="d2h-file-list-line">');
|
|
t.b("\n" + i);
|
|
t.b(' <span class="d2h-file-name-wrapper">');
|
|
t.b("\n" + i);
|
|
t.b(t.rp("<fileIcon0", c, p, " "));
|
|
t.b(' <a href="#');
|
|
t.b(t.v(t.f("fileHtmlId", c, p, 0)));
|
|
t.b('" class="d2h-file-name">');
|
|
t.b(t.v(t.f("fileName", c, p, 0)));
|
|
t.b("</a>");
|
|
t.b("\n" + i);
|
|
t.b(' <span class="d2h-file-stats">');
|
|
t.b("\n" + i);
|
|
t.b(' <span class="d2h-lines-added">');
|
|
t.b(t.v(t.f("addedLines", c, p, 0)));
|
|
t.b("</span>");
|
|
t.b("\n" + i);
|
|
t.b(' <span class="d2h-lines-deleted">');
|
|
t.b(t.v(t.f("deletedLines", c, p, 0)));
|
|
t.b("</span>");
|
|
t.b("\n" + i);
|
|
t.b(" </span>");
|
|
t.b("\n" + i);
|
|
t.b(" </span>");
|
|
t.b("\n" + i);
|
|
t.b("</li>");
|
|
return t.fl();
|
|
}, partials: { "<fileIcon0": { name: "fileIcon", partials: {}, subs: {} } }, subs: {} });
|
|
defaultTemplates["file-summary-wrapper"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<div class="d2h-file-list-wrapper">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-file-list-header">');
|
|
t.b("\n" + i);
|
|
t.b(' <span class="d2h-file-list-title">Files changed (');
|
|
t.b(t.v(t.f("filesNumber", c, p, 0)));
|
|
t.b(")</span>");
|
|
t.b("\n" + i);
|
|
t.b(' <a class="d2h-file-switch d2h-hide">hide</a>');
|
|
t.b("\n" + i);
|
|
t.b(' <a class="d2h-file-switch d2h-show">show</a>');
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(' <ol class="d2h-file-list">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.f("files", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b(" </ol>");
|
|
t.b("\n" + i);
|
|
t.b("</div>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["generic-block-header"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b("<tr>");
|
|
t.b("\n" + i);
|
|
t.b(' <td class="');
|
|
t.b(t.v(t.f("lineClass", c, p, 0)));
|
|
t.b(" ");
|
|
t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0)));
|
|
t.b('"></td>');
|
|
t.b("\n" + i);
|
|
t.b(' <td class="');
|
|
t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="');
|
|
t.b(t.v(t.f("contentClass", c, p, 0)));
|
|
t.b('">');
|
|
t.b(t.t(t.f("blockHeader", c, p, 0)));
|
|
t.b("</div>");
|
|
t.b("\n" + i);
|
|
t.b(" </td>");
|
|
t.b("\n" + i);
|
|
t.b("</tr>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["generic-empty-diff"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b("<tr>");
|
|
t.b("\n" + i);
|
|
t.b(' <td class="');
|
|
t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="');
|
|
t.b(t.v(t.f("contentClass", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
t.b(" File without changes");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(" </td>");
|
|
t.b("\n" + i);
|
|
t.b("</tr>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["generic-file-path"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<span class="d2h-file-name-wrapper">');
|
|
t.b("\n" + i);
|
|
t.b(t.rp("<fileIcon0", c, p, " "));
|
|
t.b(' <span class="d2h-file-name">');
|
|
t.b(t.v(t.f("fileDiffName", c, p, 0)));
|
|
t.b("</span>");
|
|
t.b("\n" + i);
|
|
t.b(t.rp("<fileTag1", c, p, " "));
|
|
t.b("</span>");
|
|
t.b("\n" + i);
|
|
t.b('<label class="d2h-file-collapse">');
|
|
t.b("\n" + i);
|
|
t.b(' <input class="d2h-file-collapse-input" type="checkbox" name="viewed" value="viewed">');
|
|
t.b("\n" + i);
|
|
t.b(" Viewed");
|
|
t.b("\n" + i);
|
|
t.b("</label>");
|
|
return t.fl();
|
|
}, partials: { "<fileIcon0": { name: "fileIcon", partials: {}, subs: {} }, "<fileTag1": { name: "fileTag", partials: {}, subs: {} } }, subs: {} });
|
|
defaultTemplates["generic-line"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b("<tr>");
|
|
t.b("\n" + i);
|
|
t.b(' <td class="');
|
|
t.b(t.v(t.f("lineClass", c, p, 0)));
|
|
t.b(" ");
|
|
t.b(t.v(t.f("type", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.f("lineNumber", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b(" </td>");
|
|
t.b("\n" + i);
|
|
t.b(' <td class="');
|
|
t.b(t.v(t.f("type", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="');
|
|
t.b(t.v(t.f("contentClass", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
if (t.s(t.f("prefix", c, p, 1), c, p, 0, 162, 238, "{{ }}")) {
|
|
t.rs(c, p, function(c2, p2, t2) {
|
|
t2.b(' <span class="d2h-code-line-prefix">');
|
|
t2.b(t2.t(t2.f("prefix", c2, p2, 0)));
|
|
t2.b("</span>");
|
|
t2.b("\n" + i);
|
|
});
|
|
c.pop();
|
|
}
|
|
if (!t.s(t.f("prefix", c, p, 1), c, p, 1, 0, 0, "")) {
|
|
t.b(' <span class="d2h-code-line-prefix"> </span>');
|
|
t.b("\n" + i);
|
|
}
|
|
;
|
|
if (t.s(t.f("content", c, p, 1), c, p, 0, 371, 445, "{{ }}")) {
|
|
t.rs(c, p, function(c2, p2, t2) {
|
|
t2.b(' <span class="d2h-code-line-ctn">');
|
|
t2.b(t2.t(t2.f("content", c2, p2, 0)));
|
|
t2.b("</span>");
|
|
t2.b("\n" + i);
|
|
});
|
|
c.pop();
|
|
}
|
|
if (!t.s(t.f("content", c, p, 1), c, p, 1, 0, 0, "")) {
|
|
t.b(' <span class="d2h-code-line-ctn"><br></span>');
|
|
t.b("\n" + i);
|
|
}
|
|
;
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(" </td>");
|
|
t.b("\n" + i);
|
|
t.b("</tr>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["generic-wrapper"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<div class="d2h-wrapper">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.f("content", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b("</div>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["icon-file-added"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<svg aria-hidden="true" class="d2h-icon d2h-added" height="16" title="added" version="1.1" viewBox="0 0 14 16"');
|
|
t.b("\n" + i);
|
|
t.b(' width="14">');
|
|
t.b("\n" + i);
|
|
t.b(' <path d="M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM6 9H3V7h3V4h2v3h3v2H8v3H6V9z"></path>');
|
|
t.b("\n" + i);
|
|
t.b("</svg>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["icon-file-changed"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<svg aria-hidden="true" class="d2h-icon d2h-changed" height="16" title="modified" version="1.1"');
|
|
t.b("\n" + i);
|
|
t.b(' viewBox="0 0 14 16" width="14">');
|
|
t.b("\n" + i);
|
|
t.b(' <path d="M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM4 8c0-1.66 1.34-3 3-3s3 1.34 3 3-1.34 3-3 3-3-1.34-3-3z"></path>');
|
|
t.b("\n" + i);
|
|
t.b("</svg>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["icon-file-deleted"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<svg aria-hidden="true" class="d2h-icon d2h-deleted" height="16" title="removed" version="1.1"');
|
|
t.b("\n" + i);
|
|
t.b(' viewBox="0 0 14 16" width="14">');
|
|
t.b("\n" + i);
|
|
t.b(' <path d="M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM11 9H3V7h8v2z"></path>');
|
|
t.b("\n" + i);
|
|
t.b("</svg>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["icon-file-renamed"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<svg aria-hidden="true" class="d2h-icon d2h-moved" height="16" title="renamed" version="1.1"');
|
|
t.b("\n" + i);
|
|
t.b(' viewBox="0 0 14 16" width="14">');
|
|
t.b("\n" + i);
|
|
t.b(' <path d="M6 9H3V7h3V4l5 4-5 4V9z m8-7v12c0 0.55-0.45 1-1 1H1c-0.55 0-1-0.45-1-1V2c0-0.55 0.45-1 1-1h12c0.55 0 1 0.45 1 1z m-1 0H1v12h12V2z"></path>');
|
|
t.b("\n" + i);
|
|
t.b("</svg>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["icon-file"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<svg aria-hidden="true" class="d2h-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12">');
|
|
t.b("\n" + i);
|
|
t.b(' <path d="M6 5H2v-1h4v1zM2 8h7v-1H2v1z m0 2h7v-1H2v1z m0 2h7v-1H2v1z m10-7.5v9.5c0 0.55-0.45 1-1 1H1c-0.55 0-1-0.45-1-1V2c0-0.55 0.45-1 1-1h7.5l3.5 3.5z m-1 0.5L8 2H1v12h10V5z"></path>');
|
|
t.b("\n" + i);
|
|
t.b("</svg>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["line-by-line-file-diff"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<div id="');
|
|
t.b(t.v(t.f("fileHtmlId", c, p, 0)));
|
|
t.b('" class="d2h-file-wrapper" data-lang="');
|
|
t.b(t.v(t.d("file.language", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-file-header">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.f("filePath", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-file-diff">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-code-wrapper">');
|
|
t.b("\n" + i);
|
|
t.b(' <table class="d2h-diff-table">');
|
|
t.b("\n" + i);
|
|
t.b(' <tbody class="d2h-diff-tbody">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.f("diffs", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b(" </tbody>");
|
|
t.b("\n" + i);
|
|
t.b(" </table>");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b("</div>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["line-by-line-numbers"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<div class="line-num1">');
|
|
t.b(t.v(t.f("oldNumber", c, p, 0)));
|
|
t.b("</div>");
|
|
t.b("\n" + i);
|
|
t.b('<div class="line-num2">');
|
|
t.b(t.v(t.f("newNumber", c, p, 0)));
|
|
t.b("</div>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["side-by-side-file-diff"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<div id="');
|
|
t.b(t.v(t.f("fileHtmlId", c, p, 0)));
|
|
t.b('" class="d2h-file-wrapper" data-lang="');
|
|
t.b(t.v(t.d("file.language", c, p, 0)));
|
|
t.b('">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-file-header">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.f("filePath", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-files-diff">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-file-side-diff">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-code-wrapper">');
|
|
t.b("\n" + i);
|
|
t.b(' <table class="d2h-diff-table">');
|
|
t.b("\n" + i);
|
|
t.b(' <tbody class="d2h-diff-tbody">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.d("diffs.left", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b(" </tbody>");
|
|
t.b("\n" + i);
|
|
t.b(" </table>");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-file-side-diff">');
|
|
t.b("\n" + i);
|
|
t.b(' <div class="d2h-code-wrapper">');
|
|
t.b("\n" + i);
|
|
t.b(' <table class="d2h-diff-table">');
|
|
t.b("\n" + i);
|
|
t.b(' <tbody class="d2h-diff-tbody">');
|
|
t.b("\n" + i);
|
|
t.b(" ");
|
|
t.b(t.t(t.d("diffs.right", c, p, 0)));
|
|
t.b("\n" + i);
|
|
t.b(" </tbody>");
|
|
t.b("\n" + i);
|
|
t.b(" </table>");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b(" </div>");
|
|
t.b("\n" + i);
|
|
t.b("</div>");
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["tag-file-added"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<span class="d2h-tag d2h-added d2h-added-tag">ADDED</span>');
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["tag-file-changed"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<span class="d2h-tag d2h-changed d2h-changed-tag">CHANGED</span>');
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["tag-file-deleted"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<span class="d2h-tag d2h-deleted d2h-deleted-tag">DELETED</span>');
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
defaultTemplates["tag-file-renamed"] = new Hogan2.Template({ code: function(c, p, i) {
|
|
var t = this;
|
|
t.b(i = i || "");
|
|
t.b('<span class="d2h-tag d2h-moved d2h-moved-tag">RENAMED</span>');
|
|
return t.fl();
|
|
}, partials: {}, subs: {} });
|
|
|
|
// node_modules/diff2html/lib-esm/hoganjs-utils.js
|
|
var __assign4 = function() {
|
|
__assign4 = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign4.apply(this, arguments);
|
|
};
|
|
var HoganJsUtils = function() {
|
|
function HoganJsUtils2(_a2) {
|
|
var _b = _a2.compiledTemplates, compiledTemplates = _b === void 0 ? {} : _b, _c = _a2.rawTemplates, rawTemplates = _c === void 0 ? {} : _c;
|
|
var compiledRawTemplates = Object.entries(rawTemplates).reduce(function(previousTemplates, _a3) {
|
|
var _b2;
|
|
var name = _a3[0], templateString = _a3[1];
|
|
var compiledTemplate = Hogan3.compile(templateString, { asString: false });
|
|
return __assign4(__assign4({}, previousTemplates), (_b2 = {}, _b2[name] = compiledTemplate, _b2));
|
|
}, {});
|
|
this.preCompiledTemplates = __assign4(__assign4(__assign4({}, defaultTemplates), compiledTemplates), compiledRawTemplates);
|
|
}
|
|
HoganJsUtils2.compile = function(templateString) {
|
|
return Hogan3.compile(templateString, { asString: false });
|
|
};
|
|
HoganJsUtils2.prototype.render = function(namespace, view, params, partials, indent2) {
|
|
var templateKey = this.templateKey(namespace, view);
|
|
try {
|
|
var template = this.preCompiledTemplates[templateKey];
|
|
return template.render(params, partials, indent2);
|
|
} catch (e) {
|
|
throw new Error("Could not find template to render '".concat(templateKey, "'"));
|
|
}
|
|
};
|
|
HoganJsUtils2.prototype.template = function(namespace, view) {
|
|
return this.preCompiledTemplates[this.templateKey(namespace, view)];
|
|
};
|
|
HoganJsUtils2.prototype.templateKey = function(namespace, view) {
|
|
return "".concat(namespace, "-").concat(view);
|
|
};
|
|
return HoganJsUtils2;
|
|
}();
|
|
var hoganjs_utils_default = HoganJsUtils;
|
|
|
|
// node_modules/diff2html/lib-esm/diff2html.js
|
|
var __assign5 = function() {
|
|
__assign5 = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign5.apply(this, arguments);
|
|
};
|
|
var defaultDiff2HtmlConfig = __assign5(__assign5(__assign5({}, defaultLineByLineRendererConfig), defaultSideBySideRendererConfig), { outputFormat: OutputFormatType.LINE_BY_LINE, drawFileList: true });
|
|
function html(diffInput, configuration) {
|
|
if (configuration === void 0) {
|
|
configuration = {};
|
|
}
|
|
var config = __assign5(__assign5({}, defaultDiff2HtmlConfig), configuration);
|
|
var diffJson = typeof diffInput === "string" ? parse(diffInput, config) : diffInput;
|
|
var hoganUtils = new hoganjs_utils_default(config);
|
|
var fileList = config.drawFileList ? render(diffJson, hoganUtils) : "";
|
|
var diffOutput = config.outputFormat === "side-by-side" ? new side_by_side_renderer_default(hoganUtils, config).render(diffJson) : new line_by_line_renderer_default(hoganUtils, config).render(diffJson);
|
|
return fileList + diffOutput;
|
|
}
|
|
|
|
// src/ui/diff/diffView.ts
|
|
var import_obsidian13 = __toModule(require("obsidian"));
|
|
var DiffView = class extends import_obsidian13.ItemView {
|
|
constructor(leaf, plugin) {
|
|
super(leaf);
|
|
this.plugin = plugin;
|
|
this.gettingDiff = false;
|
|
this.parser = new DOMParser();
|
|
this.navigation = true;
|
|
addEventListener("git-refresh", this.refresh.bind(this));
|
|
}
|
|
getViewType() {
|
|
return DIFF_VIEW_CONFIG.type;
|
|
}
|
|
getDisplayText() {
|
|
return DIFF_VIEW_CONFIG.name;
|
|
}
|
|
getIcon() {
|
|
return DIFF_VIEW_CONFIG.icon;
|
|
}
|
|
async setState(state, result) {
|
|
this.state = state;
|
|
await this.refresh();
|
|
return;
|
|
}
|
|
getState() {
|
|
return this.state;
|
|
}
|
|
onClose() {
|
|
removeEventListener("git-refresh", this.refresh.bind(this));
|
|
return super.onClose();
|
|
}
|
|
onOpen() {
|
|
this.refresh();
|
|
return super.onOpen();
|
|
}
|
|
async refresh() {
|
|
var _a2;
|
|
if (((_a2 = this.state) == null ? void 0 : _a2.file) && !this.gettingDiff && this.plugin.gitManager) {
|
|
this.gettingDiff = true;
|
|
let diff2 = await this.plugin.gitManager.getDiffString(this.state.file, this.state.staged);
|
|
this.contentEl.empty();
|
|
if (!diff2) {
|
|
const content = await this.app.vault.adapter.read(this.plugin.gitManager.getVaultPath(this.state.file));
|
|
const header = `--- /dev/null
|
|
+++ ${this.state.file}
|
|
@@ -0,0 +1,${content.split("\n").length} @@`;
|
|
diff2 = [...header.split("\n"), ...content.split("\n").map((line) => `+${line}`)].join("\n");
|
|
}
|
|
const diffEl = this.parser.parseFromString(html(diff2), "text/html").querySelector(".d2h-file-diff");
|
|
this.contentEl.append(diffEl);
|
|
this.gettingDiff = false;
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/ui/modals/branchModal.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian14 = __toModule(require("obsidian"));
|
|
var BranchModal = class extends import_obsidian14.FuzzySuggestModal {
|
|
constructor(branches) {
|
|
super(app);
|
|
this.branches = branches;
|
|
this.setPlaceholder("Select branch to checkout");
|
|
}
|
|
getItems() {
|
|
return this.branches;
|
|
}
|
|
getItemText(item) {
|
|
return item;
|
|
}
|
|
onChooseItem(item, evt) {
|
|
this.resolve(item);
|
|
}
|
|
open() {
|
|
super.open();
|
|
return new Promise((resolve) => {
|
|
this.resolve = resolve;
|
|
});
|
|
}
|
|
async onClose() {
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
if (this.resolve)
|
|
this.resolve(void 0);
|
|
}
|
|
};
|
|
|
|
// src/ui/modals/ignoreModal.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian15 = __toModule(require("obsidian"));
|
|
var IgnoreModal = class extends import_obsidian15.Modal {
|
|
constructor(app2, content) {
|
|
super(app2);
|
|
this.content = content;
|
|
this.resolve = null;
|
|
}
|
|
open() {
|
|
super.open();
|
|
return new Promise((resolve) => {
|
|
this.resolve = resolve;
|
|
});
|
|
}
|
|
onOpen() {
|
|
const { contentEl, titleEl } = this;
|
|
titleEl.setText("Edit .gitignore");
|
|
const div = contentEl.createDiv();
|
|
const text2 = div.createEl("textarea", {
|
|
text: this.content,
|
|
cls: ["obsidian-git-textarea"],
|
|
attr: { rows: 10, cols: 30, wrap: "off" }
|
|
});
|
|
div.createEl("button", {
|
|
cls: ["mod-cta", "obsidian-git-center-button"],
|
|
text: "Save"
|
|
}).addEventListener("click", async () => {
|
|
this.resolve(text2.value);
|
|
this.close();
|
|
});
|
|
}
|
|
onClose() {
|
|
const { contentEl } = this;
|
|
this.resolve(void 0);
|
|
contentEl.empty();
|
|
}
|
|
};
|
|
|
|
// src/ui/sidebar/sidebarView.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian22 = __toModule(require("obsidian"));
|
|
|
|
// src/ui/sidebar/gitView.svelte
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/svelte/internal/index.mjs
|
|
init_polyfill_buffer();
|
|
function noop() {
|
|
}
|
|
var identity = (x) => x;
|
|
function run(fn) {
|
|
return fn();
|
|
}
|
|
function blank_object() {
|
|
return Object.create(null);
|
|
}
|
|
function run_all(fns) {
|
|
fns.forEach(run);
|
|
}
|
|
function is_function(thing) {
|
|
return typeof thing === "function";
|
|
}
|
|
function safe_not_equal(a, b) {
|
|
return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");
|
|
}
|
|
function is_empty(obj) {
|
|
return Object.keys(obj).length === 0;
|
|
}
|
|
var is_client = typeof window !== "undefined";
|
|
var now = is_client ? () => window.performance.now() : () => Date.now();
|
|
var raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;
|
|
var tasks = new Set();
|
|
function run_tasks(now2) {
|
|
tasks.forEach((task) => {
|
|
if (!task.c(now2)) {
|
|
tasks.delete(task);
|
|
task.f();
|
|
}
|
|
});
|
|
if (tasks.size !== 0)
|
|
raf(run_tasks);
|
|
}
|
|
function loop(callback) {
|
|
let task;
|
|
if (tasks.size === 0)
|
|
raf(run_tasks);
|
|
return {
|
|
promise: new Promise((fulfill) => {
|
|
tasks.add(task = { c: callback, f: fulfill });
|
|
}),
|
|
abort() {
|
|
tasks.delete(task);
|
|
}
|
|
};
|
|
}
|
|
var is_hydrating = false;
|
|
function start_hydrating() {
|
|
is_hydrating = true;
|
|
}
|
|
function end_hydrating() {
|
|
is_hydrating = false;
|
|
}
|
|
function append2(target, node) {
|
|
target.appendChild(node);
|
|
}
|
|
function append_styles(target, style_sheet_id, styles) {
|
|
const append_styles_to = get_root_for_style(target);
|
|
if (!append_styles_to.getElementById(style_sheet_id)) {
|
|
const style = element("style");
|
|
style.id = style_sheet_id;
|
|
style.textContent = styles;
|
|
append_stylesheet(append_styles_to, style);
|
|
}
|
|
}
|
|
function get_root_for_style(node) {
|
|
if (!node)
|
|
return document;
|
|
const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
|
|
if (root && root.host) {
|
|
return root;
|
|
}
|
|
return node.ownerDocument;
|
|
}
|
|
function append_empty_stylesheet(node) {
|
|
const style_element = element("style");
|
|
append_stylesheet(get_root_for_style(node), style_element);
|
|
return style_element.sheet;
|
|
}
|
|
function append_stylesheet(node, style) {
|
|
append2(node.head || node, style);
|
|
return style.sheet;
|
|
}
|
|
function insert(target, node, anchor) {
|
|
target.insertBefore(node, anchor || null);
|
|
}
|
|
function detach(node) {
|
|
node.parentNode.removeChild(node);
|
|
}
|
|
function destroy_each(iterations, detaching) {
|
|
for (let i = 0; i < iterations.length; i += 1) {
|
|
if (iterations[i])
|
|
iterations[i].d(detaching);
|
|
}
|
|
}
|
|
function element(name) {
|
|
return document.createElement(name);
|
|
}
|
|
function text(data) {
|
|
return document.createTextNode(data);
|
|
}
|
|
function space() {
|
|
return text(" ");
|
|
}
|
|
function empty() {
|
|
return text("");
|
|
}
|
|
function listen(node, event, handler, options) {
|
|
node.addEventListener(event, handler, options);
|
|
return () => node.removeEventListener(event, handler, options);
|
|
}
|
|
function self2(fn) {
|
|
return function(event) {
|
|
if (event.target === this)
|
|
fn.call(this, event);
|
|
};
|
|
}
|
|
function attr(node, attribute, value) {
|
|
if (value == null)
|
|
node.removeAttribute(attribute);
|
|
else if (node.getAttribute(attribute) !== value)
|
|
node.setAttribute(attribute, value);
|
|
}
|
|
function children(element2) {
|
|
return Array.from(element2.childNodes);
|
|
}
|
|
function set_data(text2, data) {
|
|
data = "" + data;
|
|
if (text2.wholeText !== data)
|
|
text2.data = data;
|
|
}
|
|
function set_input_value(input, value) {
|
|
input.value = value == null ? "" : value;
|
|
}
|
|
function set_style(node, key2, value, important) {
|
|
if (value === null) {
|
|
node.style.removeProperty(key2);
|
|
} else {
|
|
node.style.setProperty(key2, value, important ? "important" : "");
|
|
}
|
|
}
|
|
function toggle_class(element2, name, toggle) {
|
|
element2.classList[toggle ? "add" : "remove"](name);
|
|
}
|
|
function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
|
|
const e = document.createEvent("CustomEvent");
|
|
e.initCustomEvent(type, bubbles, cancelable, detail);
|
|
return e;
|
|
}
|
|
var managed_styles = new Map();
|
|
var active = 0;
|
|
function hash(str) {
|
|
let hash2 = 5381;
|
|
let i = str.length;
|
|
while (i--)
|
|
hash2 = (hash2 << 5) - hash2 ^ str.charCodeAt(i);
|
|
return hash2 >>> 0;
|
|
}
|
|
function create_style_information(doc, node) {
|
|
const info = { stylesheet: append_empty_stylesheet(node), rules: {} };
|
|
managed_styles.set(doc, info);
|
|
return info;
|
|
}
|
|
function create_rule(node, a, b, duration, delay2, ease, fn, uid = 0) {
|
|
const step = 16.666 / duration;
|
|
let keyframes = "{\n";
|
|
for (let p = 0; p <= 1; p += step) {
|
|
const t = a + (b - a) * ease(p);
|
|
keyframes += p * 100 + `%{${fn(t, 1 - t)}}
|
|
`;
|
|
}
|
|
const rule = keyframes + `100% {${fn(b, 1 - b)}}
|
|
}`;
|
|
const name = `__svelte_${hash(rule)}_${uid}`;
|
|
const doc = get_root_for_style(node);
|
|
const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node);
|
|
if (!rules[name]) {
|
|
rules[name] = true;
|
|
stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
|
|
}
|
|
const animation = node.style.animation || "";
|
|
node.style.animation = `${animation ? `${animation}, ` : ""}${name} ${duration}ms linear ${delay2}ms 1 both`;
|
|
active += 1;
|
|
return name;
|
|
}
|
|
function delete_rule(node, name) {
|
|
const previous = (node.style.animation || "").split(", ");
|
|
const next = previous.filter(name ? (anim) => anim.indexOf(name) < 0 : (anim) => anim.indexOf("__svelte") === -1);
|
|
const deleted = previous.length - next.length;
|
|
if (deleted) {
|
|
node.style.animation = next.join(", ");
|
|
active -= deleted;
|
|
if (!active)
|
|
clear_rules();
|
|
}
|
|
}
|
|
function clear_rules() {
|
|
raf(() => {
|
|
if (active)
|
|
return;
|
|
managed_styles.forEach((info) => {
|
|
const { ownerNode } = info.stylesheet;
|
|
if (ownerNode)
|
|
detach(ownerNode);
|
|
});
|
|
managed_styles.clear();
|
|
});
|
|
}
|
|
var current_component;
|
|
function set_current_component(component) {
|
|
current_component = component;
|
|
}
|
|
function get_current_component() {
|
|
if (!current_component)
|
|
throw new Error("Function called outside component initialization");
|
|
return current_component;
|
|
}
|
|
function onDestroy(fn) {
|
|
get_current_component().$$.on_destroy.push(fn);
|
|
}
|
|
function bubble(component, event) {
|
|
const callbacks = component.$$.callbacks[event.type];
|
|
if (callbacks) {
|
|
callbacks.slice().forEach((fn) => fn.call(this, event));
|
|
}
|
|
}
|
|
var dirty_components = [];
|
|
var binding_callbacks = [];
|
|
var render_callbacks = [];
|
|
var flush_callbacks = [];
|
|
var resolved_promise = Promise.resolve();
|
|
var update_scheduled = false;
|
|
function schedule_update() {
|
|
if (!update_scheduled) {
|
|
update_scheduled = true;
|
|
resolved_promise.then(flush);
|
|
}
|
|
}
|
|
function add_render_callback(fn) {
|
|
render_callbacks.push(fn);
|
|
}
|
|
var seen_callbacks = new Set();
|
|
var flushidx = 0;
|
|
function flush() {
|
|
const saved_component = current_component;
|
|
do {
|
|
while (flushidx < dirty_components.length) {
|
|
const component = dirty_components[flushidx];
|
|
flushidx++;
|
|
set_current_component(component);
|
|
update(component.$$);
|
|
}
|
|
set_current_component(null);
|
|
dirty_components.length = 0;
|
|
flushidx = 0;
|
|
while (binding_callbacks.length)
|
|
binding_callbacks.pop()();
|
|
for (let i = 0; i < render_callbacks.length; i += 1) {
|
|
const callback = render_callbacks[i];
|
|
if (!seen_callbacks.has(callback)) {
|
|
seen_callbacks.add(callback);
|
|
callback();
|
|
}
|
|
}
|
|
render_callbacks.length = 0;
|
|
} while (dirty_components.length);
|
|
while (flush_callbacks.length) {
|
|
flush_callbacks.pop()();
|
|
}
|
|
update_scheduled = false;
|
|
seen_callbacks.clear();
|
|
set_current_component(saved_component);
|
|
}
|
|
function update($$) {
|
|
if ($$.fragment !== null) {
|
|
$$.update();
|
|
run_all($$.before_update);
|
|
const dirty = $$.dirty;
|
|
$$.dirty = [-1];
|
|
$$.fragment && $$.fragment.p($$.ctx, dirty);
|
|
$$.after_update.forEach(add_render_callback);
|
|
}
|
|
}
|
|
var promise;
|
|
function wait() {
|
|
if (!promise) {
|
|
promise = Promise.resolve();
|
|
promise.then(() => {
|
|
promise = null;
|
|
});
|
|
}
|
|
return promise;
|
|
}
|
|
function dispatch(node, direction, kind) {
|
|
node.dispatchEvent(custom_event(`${direction ? "intro" : "outro"}${kind}`));
|
|
}
|
|
var outroing = new Set();
|
|
var outros;
|
|
function group_outros() {
|
|
outros = {
|
|
r: 0,
|
|
c: [],
|
|
p: outros
|
|
};
|
|
}
|
|
function check_outros() {
|
|
if (!outros.r) {
|
|
run_all(outros.c);
|
|
}
|
|
outros = outros.p;
|
|
}
|
|
function transition_in(block, local) {
|
|
if (block && block.i) {
|
|
outroing.delete(block);
|
|
block.i(local);
|
|
}
|
|
}
|
|
function transition_out(block, local, detach2, callback) {
|
|
if (block && block.o) {
|
|
if (outroing.has(block))
|
|
return;
|
|
outroing.add(block);
|
|
outros.c.push(() => {
|
|
outroing.delete(block);
|
|
if (callback) {
|
|
if (detach2)
|
|
block.d(1);
|
|
callback();
|
|
}
|
|
});
|
|
block.o(local);
|
|
} else if (callback) {
|
|
callback();
|
|
}
|
|
}
|
|
var null_transition = { duration: 0 };
|
|
function create_bidirectional_transition(node, fn, params, intro) {
|
|
let config = fn(node, params);
|
|
let t = intro ? 0 : 1;
|
|
let running_program = null;
|
|
let pending_program = null;
|
|
let animation_name = null;
|
|
function clear_animation() {
|
|
if (animation_name)
|
|
delete_rule(node, animation_name);
|
|
}
|
|
function init3(program, duration) {
|
|
const d = program.b - t;
|
|
duration *= Math.abs(d);
|
|
return {
|
|
a: t,
|
|
b: program.b,
|
|
d,
|
|
duration,
|
|
start: program.start,
|
|
end: program.start + duration,
|
|
group: program.group
|
|
};
|
|
}
|
|
function go(b) {
|
|
const { delay: delay2 = 0, duration = 300, easing = identity, tick: tick2 = noop, css } = config || null_transition;
|
|
const program = {
|
|
start: now() + delay2,
|
|
b
|
|
};
|
|
if (!b) {
|
|
program.group = outros;
|
|
outros.r += 1;
|
|
}
|
|
if (running_program || pending_program) {
|
|
pending_program = program;
|
|
} else {
|
|
if (css) {
|
|
clear_animation();
|
|
animation_name = create_rule(node, t, b, duration, delay2, easing, css);
|
|
}
|
|
if (b)
|
|
tick2(0, 1);
|
|
running_program = init3(program, duration);
|
|
add_render_callback(() => dispatch(node, b, "start"));
|
|
loop((now2) => {
|
|
if (pending_program && now2 > pending_program.start) {
|
|
running_program = init3(pending_program, duration);
|
|
pending_program = null;
|
|
dispatch(node, running_program.b, "start");
|
|
if (css) {
|
|
clear_animation();
|
|
animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
|
|
}
|
|
}
|
|
if (running_program) {
|
|
if (now2 >= running_program.end) {
|
|
tick2(t = running_program.b, 1 - t);
|
|
dispatch(node, running_program.b, "end");
|
|
if (!pending_program) {
|
|
if (running_program.b) {
|
|
clear_animation();
|
|
} else {
|
|
if (!--running_program.group.r)
|
|
run_all(running_program.group.c);
|
|
}
|
|
}
|
|
running_program = null;
|
|
} else if (now2 >= running_program.start) {
|
|
const p = now2 - running_program.start;
|
|
t = running_program.a + running_program.d * easing(p / running_program.duration);
|
|
tick2(t, 1 - t);
|
|
}
|
|
}
|
|
return !!(running_program || pending_program);
|
|
});
|
|
}
|
|
}
|
|
return {
|
|
run(b) {
|
|
if (is_function(config)) {
|
|
wait().then(() => {
|
|
config = config();
|
|
go(b);
|
|
});
|
|
} else {
|
|
go(b);
|
|
}
|
|
},
|
|
end() {
|
|
clear_animation();
|
|
running_program = pending_program = null;
|
|
}
|
|
};
|
|
}
|
|
var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : global;
|
|
var boolean_attributes = new Set([
|
|
"allowfullscreen",
|
|
"allowpaymentrequest",
|
|
"async",
|
|
"autofocus",
|
|
"autoplay",
|
|
"checked",
|
|
"controls",
|
|
"default",
|
|
"defer",
|
|
"disabled",
|
|
"formnovalidate",
|
|
"hidden",
|
|
"inert",
|
|
"ismap",
|
|
"itemscope",
|
|
"loop",
|
|
"multiple",
|
|
"muted",
|
|
"nomodule",
|
|
"novalidate",
|
|
"open",
|
|
"playsinline",
|
|
"readonly",
|
|
"required",
|
|
"reversed",
|
|
"selected"
|
|
]);
|
|
function create_component(block) {
|
|
block && block.c();
|
|
}
|
|
function mount_component(component, target, anchor, customElement) {
|
|
const { fragment, after_update } = component.$$;
|
|
fragment && fragment.m(target, anchor);
|
|
if (!customElement) {
|
|
add_render_callback(() => {
|
|
const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
|
|
if (component.$$.on_destroy) {
|
|
component.$$.on_destroy.push(...new_on_destroy);
|
|
} else {
|
|
run_all(new_on_destroy);
|
|
}
|
|
component.$$.on_mount = [];
|
|
});
|
|
}
|
|
after_update.forEach(add_render_callback);
|
|
}
|
|
function destroy_component(component, detaching) {
|
|
const $$ = component.$$;
|
|
if ($$.fragment !== null) {
|
|
run_all($$.on_destroy);
|
|
$$.fragment && $$.fragment.d(detaching);
|
|
$$.on_destroy = $$.fragment = null;
|
|
$$.ctx = [];
|
|
}
|
|
}
|
|
function make_dirty(component, i) {
|
|
if (component.$$.dirty[0] === -1) {
|
|
dirty_components.push(component);
|
|
schedule_update();
|
|
component.$$.dirty.fill(0);
|
|
}
|
|
component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
|
|
}
|
|
function init2(component, options, instance6, create_fragment6, not_equal, props, append_styles2, dirty = [-1]) {
|
|
const parent_component = current_component;
|
|
set_current_component(component);
|
|
const $$ = component.$$ = {
|
|
fragment: null,
|
|
ctx: [],
|
|
props,
|
|
update: noop,
|
|
not_equal,
|
|
bound: blank_object(),
|
|
on_mount: [],
|
|
on_destroy: [],
|
|
on_disconnect: [],
|
|
before_update: [],
|
|
after_update: [],
|
|
context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
|
|
callbacks: blank_object(),
|
|
dirty,
|
|
skip_bound: false,
|
|
root: options.target || parent_component.$$.root
|
|
};
|
|
append_styles2 && append_styles2($$.root);
|
|
let ready = false;
|
|
$$.ctx = instance6 ? instance6(component, options.props || {}, (i, ret, ...rest) => {
|
|
const value = rest.length ? rest[0] : ret;
|
|
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
|
|
if (!$$.skip_bound && $$.bound[i])
|
|
$$.bound[i](value);
|
|
if (ready)
|
|
make_dirty(component, i);
|
|
}
|
|
return ret;
|
|
}) : [];
|
|
$$.update();
|
|
ready = true;
|
|
run_all($$.before_update);
|
|
$$.fragment = create_fragment6 ? create_fragment6($$.ctx) : false;
|
|
if (options.target) {
|
|
if (options.hydrate) {
|
|
start_hydrating();
|
|
const nodes = children(options.target);
|
|
$$.fragment && $$.fragment.l(nodes);
|
|
nodes.forEach(detach);
|
|
} else {
|
|
$$.fragment && $$.fragment.c();
|
|
}
|
|
if (options.intro)
|
|
transition_in(component.$$.fragment);
|
|
mount_component(component, options.target, options.anchor, options.customElement);
|
|
end_hydrating();
|
|
flush();
|
|
}
|
|
set_current_component(parent_component);
|
|
}
|
|
var SvelteElement;
|
|
if (typeof HTMLElement === "function") {
|
|
SvelteElement = class extends HTMLElement {
|
|
constructor() {
|
|
super();
|
|
this.attachShadow({ mode: "open" });
|
|
}
|
|
connectedCallback() {
|
|
const { on_mount } = this.$$;
|
|
this.$$.on_disconnect = on_mount.map(run).filter(is_function);
|
|
for (const key2 in this.$$.slotted) {
|
|
this.appendChild(this.$$.slotted[key2]);
|
|
}
|
|
}
|
|
attributeChangedCallback(attr2, _oldValue, newValue) {
|
|
this[attr2] = newValue;
|
|
}
|
|
disconnectedCallback() {
|
|
run_all(this.$$.on_disconnect);
|
|
}
|
|
$destroy() {
|
|
destroy_component(this, 1);
|
|
this.$destroy = noop;
|
|
}
|
|
$on(type, callback) {
|
|
if (!is_function(callback)) {
|
|
return noop;
|
|
}
|
|
const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
|
|
callbacks.push(callback);
|
|
return () => {
|
|
const index2 = callbacks.indexOf(callback);
|
|
if (index2 !== -1)
|
|
callbacks.splice(index2, 1);
|
|
};
|
|
}
|
|
$set($$props) {
|
|
if (this.$$set && !is_empty($$props)) {
|
|
this.$$.skip_bound = true;
|
|
this.$$set($$props);
|
|
this.$$.skip_bound = false;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
var SvelteComponent = class {
|
|
$destroy() {
|
|
destroy_component(this, 1);
|
|
this.$destroy = noop;
|
|
}
|
|
$on(type, callback) {
|
|
if (!is_function(callback)) {
|
|
return noop;
|
|
}
|
|
const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
|
|
callbacks.push(callback);
|
|
return () => {
|
|
const index2 = callbacks.indexOf(callback);
|
|
if (index2 !== -1)
|
|
callbacks.splice(index2, 1);
|
|
};
|
|
}
|
|
$set($$props) {
|
|
if (this.$$set && !is_empty($$props)) {
|
|
this.$$.skip_bound = true;
|
|
this.$$set($$props);
|
|
this.$$.skip_bound = false;
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/ui/sidebar/gitView.svelte
|
|
var import_obsidian21 = __toModule(require("obsidian"));
|
|
|
|
// node_modules/svelte/index.mjs
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/svelte/transition/index.mjs
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/svelte/easing/index.mjs
|
|
init_polyfill_buffer();
|
|
function cubicOut(t) {
|
|
const f = t - 1;
|
|
return f * f * f + 1;
|
|
}
|
|
|
|
// node_modules/svelte/transition/index.mjs
|
|
function slide(node, { delay: delay2 = 0, duration = 400, easing = cubicOut } = {}) {
|
|
const style = getComputedStyle(node);
|
|
const opacity = +style.opacity;
|
|
const height = parseFloat(style.height);
|
|
const padding_top = parseFloat(style.paddingTop);
|
|
const padding_bottom = parseFloat(style.paddingBottom);
|
|
const margin_top = parseFloat(style.marginTop);
|
|
const margin_bottom = parseFloat(style.marginBottom);
|
|
const border_top_width = parseFloat(style.borderTopWidth);
|
|
const border_bottom_width = parseFloat(style.borderBottomWidth);
|
|
return {
|
|
delay: delay2,
|
|
duration,
|
|
easing,
|
|
css: (t) => `overflow: hidden;opacity: ${Math.min(t * 20, 1) * opacity};height: ${t * height}px;padding-top: ${t * padding_top}px;padding-bottom: ${t * padding_bottom}px;margin-top: ${t * margin_top}px;margin-bottom: ${t * margin_bottom}px;border-top-width: ${t * border_top_width}px;border-bottom-width: ${t * border_bottom_width}px;`
|
|
};
|
|
}
|
|
|
|
// src/ui/sidebar/components/fileComponent.svelte
|
|
init_polyfill_buffer();
|
|
var import_obsidian18 = __toModule(require("obsidian"));
|
|
|
|
// node_modules/obsidian-community-lib/dist/index.js
|
|
init_polyfill_buffer();
|
|
|
|
// node_modules/obsidian-community-lib/dist/utils.js
|
|
init_polyfill_buffer();
|
|
var feather = __toModule(require_feather());
|
|
var import_obsidian16 = __toModule(require("obsidian"));
|
|
function hoverPreview(event, view, to) {
|
|
const targetEl = event.target;
|
|
app.workspace.trigger("hover-link", {
|
|
event,
|
|
source: view.getViewType(),
|
|
hoverParent: view,
|
|
targetEl,
|
|
linktext: to
|
|
});
|
|
}
|
|
|
|
// src/ui/modals/discardModal.ts
|
|
init_polyfill_buffer();
|
|
var import_obsidian17 = __toModule(require("obsidian"));
|
|
var DiscardModal = class extends import_obsidian17.Modal {
|
|
constructor(app2, deletion, filename) {
|
|
super(app2);
|
|
this.deletion = deletion;
|
|
this.filename = filename;
|
|
this.resolve = null;
|
|
}
|
|
myOpen() {
|
|
this.open();
|
|
return new Promise((resolve) => {
|
|
this.resolve = resolve;
|
|
});
|
|
}
|
|
onOpen() {
|
|
const { contentEl, titleEl } = this;
|
|
titleEl.setText(`${this.deletion ? "Delete" : "Discard"} this file?`);
|
|
contentEl.createEl("h4").setText(`Do you really want to ${this.deletion ? "delete" : "discard the changes of"} "${this.filename}"`);
|
|
const div = contentEl.createDiv();
|
|
div.addClass("obsidian-git-center");
|
|
div.createEl("button", { text: "Cancel" }).addEventListener("click", () => {
|
|
if (this.resolve)
|
|
this.resolve(false);
|
|
return this.close();
|
|
});
|
|
div.createEl("button", {
|
|
cls: "mod-cta",
|
|
text: "Confirm"
|
|
}).addEventListener("click", async () => {
|
|
if (this.resolve)
|
|
this.resolve(true);
|
|
this.close();
|
|
});
|
|
}
|
|
onClose() {
|
|
const { contentEl } = this;
|
|
contentEl.empty();
|
|
}
|
|
};
|
|
|
|
// src/ui/sidebar/components/fileComponent.svelte
|
|
function add_css(target) {
|
|
append_styles(target, "svelte-1o25zf2", "main.svelte-1o25zf2 .nav-file-title-content.svelte-1o25zf2.svelte-1o25zf2{display:flex;align-items:center}main.svelte-1o25zf2 .tools.svelte-1o25zf2.svelte-1o25zf2{display:flex;margin-left:auto}main.svelte-1o25zf2 .tools .type.svelte-1o25zf2.svelte-1o25zf2{padding-left:var(--size-2-1);display:flex;align-items:center;justify-content:center}main.svelte-1o25zf2 .tools .type[data-type=M].svelte-1o25zf2.svelte-1o25zf2{color:orange}main.svelte-1o25zf2 .tools .type[data-type=D].svelte-1o25zf2.svelte-1o25zf2{color:red}main.svelte-1o25zf2 .tools .buttons.svelte-1o25zf2.svelte-1o25zf2{display:flex}main.svelte-1o25zf2 .tools .buttons.svelte-1o25zf2>.svelte-1o25zf2{padding:0 0;height:auto}");
|
|
}
|
|
function create_if_block(ctx) {
|
|
let div;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
attr(div, "data-icon", "go-to-file");
|
|
attr(div, "aria-label", "Open File");
|
|
attr(div, "class", "clickable-icon svelte-1o25zf2");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
ctx[11](div);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(div, "auxclick", ctx[5]),
|
|
listen(div, "click", ctx[5])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
ctx[11](null);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment(ctx) {
|
|
var _a2;
|
|
let main;
|
|
let div6;
|
|
let div0;
|
|
let t0_value = ((_a2 = ctx[0].vault_path.split("/").last()) == null ? void 0 : _a2.replace(".md", "")) + "";
|
|
let t0;
|
|
let t1;
|
|
let div5;
|
|
let div3;
|
|
let show_if = ctx[1].app.vault.getAbstractFileByPath(ctx[0].vault_path);
|
|
let t2;
|
|
let div1;
|
|
let t3;
|
|
let div2;
|
|
let t4;
|
|
let div4;
|
|
let t5_value = ctx[0].working_dir + "";
|
|
let t5;
|
|
let div4_data_type_value;
|
|
let div6_aria_label_value;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block = show_if && create_if_block(ctx);
|
|
return {
|
|
c() {
|
|
main = element("main");
|
|
div6 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
div5 = element("div");
|
|
div3 = element("div");
|
|
if (if_block)
|
|
if_block.c();
|
|
t2 = space();
|
|
div1 = element("div");
|
|
t3 = space();
|
|
div2 = element("div");
|
|
t4 = space();
|
|
div4 = element("div");
|
|
t5 = text(t5_value);
|
|
attr(div0, "class", "nav-file-title-content svelte-1o25zf2");
|
|
attr(div1, "data-icon", "skip-back");
|
|
attr(div1, "aria-label", "Discard");
|
|
attr(div1, "class", "clickable-icon svelte-1o25zf2");
|
|
attr(div2, "data-icon", "plus");
|
|
attr(div2, "aria-label", "Stage");
|
|
attr(div2, "class", "clickable-icon svelte-1o25zf2");
|
|
attr(div3, "class", "buttons svelte-1o25zf2");
|
|
attr(div4, "class", "type svelte-1o25zf2");
|
|
attr(div4, "data-type", div4_data_type_value = ctx[0].working_dir);
|
|
attr(div5, "class", "tools svelte-1o25zf2");
|
|
attr(div6, "class", "nav-file-title");
|
|
attr(div6, "aria-label-position", ctx[3]);
|
|
attr(div6, "aria-label", div6_aria_label_value = ctx[0].vault_path.split("/").last() != ctx[0].vault_path ? ctx[0].vault_path : "");
|
|
attr(main, "class", "nav-file svelte-1o25zf2");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, main, anchor);
|
|
append2(main, div6);
|
|
append2(div6, div0);
|
|
append2(div0, t0);
|
|
append2(div6, t1);
|
|
append2(div6, div5);
|
|
append2(div5, div3);
|
|
if (if_block)
|
|
if_block.m(div3, null);
|
|
append2(div3, t2);
|
|
append2(div3, div1);
|
|
ctx[12](div1);
|
|
append2(div3, t3);
|
|
append2(div3, div2);
|
|
ctx[13](div2);
|
|
append2(div5, t4);
|
|
append2(div5, div4);
|
|
append2(div4, t5);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(div0, "click", ctx[7]),
|
|
listen(div0, "auxclick", ctx[7]),
|
|
listen(div1, "click", ctx[8]),
|
|
listen(div2, "click", ctx[6]),
|
|
listen(div6, "click", self2(ctx[7])),
|
|
listen(div6, "auxclick", self2(ctx[7])),
|
|
listen(main, "mouseover", ctx[4]),
|
|
listen(main, "click", self2(ctx[7])),
|
|
listen(main, "focus", ctx[10])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
var _a3;
|
|
if (dirty & 1 && t0_value !== (t0_value = ((_a3 = ctx2[0].vault_path.split("/").last()) == null ? void 0 : _a3.replace(".md", "")) + ""))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 3)
|
|
show_if = ctx2[1].app.vault.getAbstractFileByPath(ctx2[0].vault_path);
|
|
if (show_if) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block(ctx2);
|
|
if_block.c();
|
|
if_block.m(div3, t2);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
if (dirty & 1 && t5_value !== (t5_value = ctx2[0].working_dir + ""))
|
|
set_data(t5, t5_value);
|
|
if (dirty & 1 && div4_data_type_value !== (div4_data_type_value = ctx2[0].working_dir)) {
|
|
attr(div4, "data-type", div4_data_type_value);
|
|
}
|
|
if (dirty & 8) {
|
|
attr(div6, "aria-label-position", ctx2[3]);
|
|
}
|
|
if (dirty & 1 && div6_aria_label_value !== (div6_aria_label_value = ctx2[0].vault_path.split("/").last() != ctx2[0].vault_path ? ctx2[0].vault_path : "")) {
|
|
attr(div6, "aria-label", div6_aria_label_value);
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(main);
|
|
if (if_block)
|
|
if_block.d();
|
|
ctx[12](null);
|
|
ctx[13](null);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function instance($$self, $$props, $$invalidate) {
|
|
let side;
|
|
let { change } = $$props;
|
|
let { view } = $$props;
|
|
let { manager } = $$props;
|
|
let buttons = [];
|
|
window.setTimeout(() => buttons.forEach((b) => (0, import_obsidian18.setIcon)(b, b.getAttr("data-icon"))), 0);
|
|
function hover(event) {
|
|
if (!change.path.startsWith(view.app.vault.configDir) || !change.path.startsWith(".")) {
|
|
hoverPreview(event, view, change.vault_path.split("/").last().replace(".md", ""));
|
|
}
|
|
}
|
|
function open(event) {
|
|
var _a2;
|
|
const file = view.app.vault.getAbstractFileByPath(change.vault_path);
|
|
console.log(event);
|
|
if (file instanceof import_obsidian18.TFile) {
|
|
(_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.openFile(file);
|
|
}
|
|
}
|
|
function stage() {
|
|
manager.stage(change.path, false).finally(() => {
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
});
|
|
}
|
|
function showDiff(event) {
|
|
var _a2;
|
|
(_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.setViewState({
|
|
type: DIFF_VIEW_CONFIG.type,
|
|
active: true,
|
|
state: { file: change.path, staged: false }
|
|
});
|
|
}
|
|
function discard() {
|
|
const deleteFile = change.working_dir == "U";
|
|
new DiscardModal(view.app, deleteFile, change.vault_path).myOpen().then((shouldDiscard) => {
|
|
if (shouldDiscard === true) {
|
|
if (deleteFile) {
|
|
view.app.vault.adapter.remove(change.vault_path).finally(() => {
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
});
|
|
} else {
|
|
manager.discard(change.path).finally(() => {
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function focus_handler(event) {
|
|
bubble.call(this, $$self, event);
|
|
}
|
|
function div_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[1] = $$value;
|
|
$$invalidate(2, buttons);
|
|
});
|
|
}
|
|
function div1_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[0] = $$value;
|
|
$$invalidate(2, buttons);
|
|
});
|
|
}
|
|
function div2_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[2] = $$value;
|
|
$$invalidate(2, buttons);
|
|
});
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("change" in $$props2)
|
|
$$invalidate(0, change = $$props2.change);
|
|
if ("view" in $$props2)
|
|
$$invalidate(1, view = $$props2.view);
|
|
if ("manager" in $$props2)
|
|
$$invalidate(9, manager = $$props2.manager);
|
|
};
|
|
$$self.$$.update = () => {
|
|
if ($$self.$$.dirty & 2) {
|
|
$:
|
|
$$invalidate(3, side = view.leaf.getRoot().side == "left" ? "right" : "left");
|
|
}
|
|
};
|
|
return [
|
|
change,
|
|
view,
|
|
buttons,
|
|
side,
|
|
hover,
|
|
open,
|
|
stage,
|
|
showDiff,
|
|
discard,
|
|
manager,
|
|
focus_handler,
|
|
div_binding,
|
|
div1_binding,
|
|
div2_binding
|
|
];
|
|
}
|
|
var FileComponent = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init2(this, options, instance, create_fragment, safe_not_equal, { change: 0, view: 1, manager: 9 }, add_css);
|
|
}
|
|
};
|
|
var fileComponent_default = FileComponent;
|
|
|
|
// src/ui/sidebar/components/pulledFileComponent.svelte
|
|
init_polyfill_buffer();
|
|
var import_obsidian19 = __toModule(require("obsidian"));
|
|
function add_css2(target) {
|
|
append_styles(target, "svelte-sajhpp", "main.svelte-sajhpp .nav-file-title-content.svelte-sajhpp{display:flex;align-items:center}main.svelte-sajhpp .tools.svelte-sajhpp{display:flex;margin-left:auto}main.svelte-sajhpp .tools .type.svelte-sajhpp{padding-left:var(--size-2-1);display:flex;align-items:center;justify-content:center}main.svelte-sajhpp .tools .type[data-type=M].svelte-sajhpp{color:orange}main.svelte-sajhpp .tools .type[data-type=D].svelte-sajhpp{color:red}");
|
|
}
|
|
function create_fragment2(ctx) {
|
|
var _a2;
|
|
let main;
|
|
let div2;
|
|
let div0;
|
|
let t0_value = ((_a2 = ctx[0].vault_path.split("/").last()) == null ? void 0 : _a2.replace(".md", "")) + "";
|
|
let t0;
|
|
let t1;
|
|
let div1;
|
|
let span;
|
|
let t2_value = ctx[0].working_dir + "";
|
|
let t2;
|
|
let span_data_type_value;
|
|
let div2_aria_label_value;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
main = element("main");
|
|
div2 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
div1 = element("div");
|
|
span = element("span");
|
|
t2 = text(t2_value);
|
|
attr(div0, "class", "nav-file-title-content svelte-sajhpp");
|
|
attr(span, "class", "type svelte-sajhpp");
|
|
attr(span, "data-type", span_data_type_value = ctx[0].working_dir);
|
|
attr(div1, "class", "tools svelte-sajhpp");
|
|
attr(div2, "class", "nav-file-title");
|
|
attr(div2, "aria-label-position", ctx[1]);
|
|
attr(div2, "aria-label", div2_aria_label_value = ctx[0].vault_path.split("/").last() != ctx[0].vault_path ? ctx[0].vault_path : "");
|
|
attr(main, "class", "nav-file svelte-sajhpp");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, main, anchor);
|
|
append2(main, div2);
|
|
append2(div2, div0);
|
|
append2(div0, t0);
|
|
append2(div2, t1);
|
|
append2(div2, div1);
|
|
append2(div1, span);
|
|
append2(span, t2);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(main, "mouseover", ctx[2]),
|
|
listen(main, "click", ctx[3]),
|
|
listen(main, "focus", ctx[5])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
var _a3;
|
|
if (dirty & 1 && t0_value !== (t0_value = ((_a3 = ctx2[0].vault_path.split("/").last()) == null ? void 0 : _a3.replace(".md", "")) + ""))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 1 && t2_value !== (t2_value = ctx2[0].working_dir + ""))
|
|
set_data(t2, t2_value);
|
|
if (dirty & 1 && span_data_type_value !== (span_data_type_value = ctx2[0].working_dir)) {
|
|
attr(span, "data-type", span_data_type_value);
|
|
}
|
|
if (dirty & 2) {
|
|
attr(div2, "aria-label-position", ctx2[1]);
|
|
}
|
|
if (dirty & 1 && div2_aria_label_value !== (div2_aria_label_value = ctx2[0].vault_path.split("/").last() != ctx2[0].vault_path ? ctx2[0].vault_path : "")) {
|
|
attr(div2, "aria-label", div2_aria_label_value);
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(main);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function instance2($$self, $$props, $$invalidate) {
|
|
let side;
|
|
let { change } = $$props;
|
|
let { view } = $$props;
|
|
function hover(event) {
|
|
if (!change.path.startsWith(view.app.vault.configDir) || !change.path.startsWith(".")) {
|
|
hoverPreview(event, view, change.vault_path.split("/").last().replace(".md", ""));
|
|
}
|
|
}
|
|
function open(event) {
|
|
var _a2;
|
|
const file = view.app.vault.getAbstractFileByPath(change.vault_path);
|
|
if (file instanceof import_obsidian19.TFile) {
|
|
(_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.openFile(file);
|
|
}
|
|
}
|
|
function focus_handler(event) {
|
|
bubble.call(this, $$self, event);
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("change" in $$props2)
|
|
$$invalidate(0, change = $$props2.change);
|
|
if ("view" in $$props2)
|
|
$$invalidate(4, view = $$props2.view);
|
|
};
|
|
$$self.$$.update = () => {
|
|
if ($$self.$$.dirty & 16) {
|
|
$:
|
|
$$invalidate(1, side = view.leaf.getRoot().side == "left" ? "right" : "left");
|
|
}
|
|
};
|
|
return [change, side, hover, open, view, focus_handler];
|
|
}
|
|
var PulledFileComponent = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init2(this, options, instance2, create_fragment2, safe_not_equal, { change: 0, view: 4 }, add_css2);
|
|
}
|
|
};
|
|
var pulledFileComponent_default = PulledFileComponent;
|
|
|
|
// src/ui/sidebar/components/stagedFileComponent.svelte
|
|
init_polyfill_buffer();
|
|
var import_obsidian20 = __toModule(require("obsidian"));
|
|
function add_css3(target) {
|
|
append_styles(target, "svelte-1o25zf2", "main.svelte-1o25zf2 .nav-file-title-content.svelte-1o25zf2.svelte-1o25zf2{display:flex;align-items:center}main.svelte-1o25zf2 .tools.svelte-1o25zf2.svelte-1o25zf2{display:flex;margin-left:auto}main.svelte-1o25zf2 .tools .type.svelte-1o25zf2.svelte-1o25zf2{padding-left:var(--size-2-1);display:flex;align-items:center;justify-content:center}main.svelte-1o25zf2 .tools .type[data-type=M].svelte-1o25zf2.svelte-1o25zf2{color:orange}main.svelte-1o25zf2 .tools .type[data-type=D].svelte-1o25zf2.svelte-1o25zf2{color:red}main.svelte-1o25zf2 .tools .buttons.svelte-1o25zf2.svelte-1o25zf2{display:flex}main.svelte-1o25zf2 .tools .buttons.svelte-1o25zf2>.svelte-1o25zf2{padding:0 0;height:auto}");
|
|
}
|
|
function create_if_block2(ctx) {
|
|
let div;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
attr(div, "data-icon", "go-to-file");
|
|
attr(div, "aria-label", "Open File");
|
|
attr(div, "class", "clickable-icon svelte-1o25zf2");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
ctx[11](div);
|
|
if (!mounted) {
|
|
dispose = listen(div, "click", ctx[6]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
ctx[11](null);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_fragment3(ctx) {
|
|
var _a2;
|
|
let main;
|
|
let div5;
|
|
let div0;
|
|
let t0_value = ((_a2 = ctx[3].split("/").last()) == null ? void 0 : _a2.replace(".md", "")) + "";
|
|
let t0;
|
|
let t1;
|
|
let div4;
|
|
let div2;
|
|
let show_if = ctx[1].app.vault.getAbstractFileByPath(ctx[3]);
|
|
let t2;
|
|
let div1;
|
|
let t3;
|
|
let div3;
|
|
let t4_value = ctx[0].index + "";
|
|
let t4;
|
|
let div3_data_type_value;
|
|
let div5_aria_label_value;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block = show_if && create_if_block2(ctx);
|
|
return {
|
|
c() {
|
|
main = element("main");
|
|
div5 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
div4 = element("div");
|
|
div2 = element("div");
|
|
if (if_block)
|
|
if_block.c();
|
|
t2 = space();
|
|
div1 = element("div");
|
|
t3 = space();
|
|
div3 = element("div");
|
|
t4 = text(t4_value);
|
|
attr(div0, "class", "nav-file-title-content svelte-1o25zf2");
|
|
attr(div1, "data-icon", "minus");
|
|
attr(div1, "aria-label", "Unstage");
|
|
attr(div1, "class", "clickable-icon svelte-1o25zf2");
|
|
attr(div2, "class", "buttons svelte-1o25zf2");
|
|
attr(div3, "class", "type svelte-1o25zf2");
|
|
attr(div3, "data-type", div3_data_type_value = ctx[0].index);
|
|
attr(div4, "class", "tools svelte-1o25zf2");
|
|
attr(div5, "class", "nav-file-title");
|
|
attr(div5, "aria-label-position", ctx[4]);
|
|
attr(div5, "aria-label", div5_aria_label_value = ctx[3].split("/").last() != ctx[3] ? ctx[3] : "");
|
|
attr(main, "class", "nav-file svelte-1o25zf2");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, main, anchor);
|
|
append2(main, div5);
|
|
append2(div5, div0);
|
|
append2(div0, t0);
|
|
append2(div5, t1);
|
|
append2(div5, div4);
|
|
append2(div4, div2);
|
|
if (if_block)
|
|
if_block.m(div2, null);
|
|
append2(div2, t2);
|
|
append2(div2, div1);
|
|
ctx[12](div1);
|
|
append2(div4, t3);
|
|
append2(div4, div3);
|
|
append2(div3, t4);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(div0, "click", ctx[7]),
|
|
listen(div0, "auxclick", ctx[7]),
|
|
listen(div1, "click", ctx[8]),
|
|
listen(div5, "click", self2(ctx[7])),
|
|
listen(main, "mouseover", ctx[5]),
|
|
listen(main, "focus", ctx[10]),
|
|
listen(main, "click", self2(ctx[7]))
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
var _a3;
|
|
if (dirty & 8 && t0_value !== (t0_value = ((_a3 = ctx2[3].split("/").last()) == null ? void 0 : _a3.replace(".md", "")) + ""))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 10)
|
|
show_if = ctx2[1].app.vault.getAbstractFileByPath(ctx2[3]);
|
|
if (show_if) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block2(ctx2);
|
|
if_block.c();
|
|
if_block.m(div2, t2);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
if (dirty & 1 && t4_value !== (t4_value = ctx2[0].index + ""))
|
|
set_data(t4, t4_value);
|
|
if (dirty & 1 && div3_data_type_value !== (div3_data_type_value = ctx2[0].index)) {
|
|
attr(div3, "data-type", div3_data_type_value);
|
|
}
|
|
if (dirty & 16) {
|
|
attr(div5, "aria-label-position", ctx2[4]);
|
|
}
|
|
if (dirty & 8 && div5_aria_label_value !== (div5_aria_label_value = ctx2[3].split("/").last() != ctx2[3] ? ctx2[3] : "")) {
|
|
attr(div5, "aria-label", div5_aria_label_value);
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(main);
|
|
if (if_block)
|
|
if_block.d();
|
|
ctx[12](null);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function instance3($$self, $$props, $$invalidate) {
|
|
let formattedPath;
|
|
let side;
|
|
let { change } = $$props;
|
|
let { view } = $$props;
|
|
let { manager } = $$props;
|
|
let buttons = [];
|
|
window.setTimeout(() => buttons.forEach((b) => (0, import_obsidian20.setIcon)(b, b.getAttr("data-icon"), 16)), 0);
|
|
function hover(event) {
|
|
if (!change.path.startsWith(view.app.vault.configDir) || !change.path.startsWith(".")) {
|
|
hoverPreview(event, view, formattedPath.split("/").last().replace(".md", ""));
|
|
}
|
|
}
|
|
function open(event) {
|
|
var _a2;
|
|
const file = view.app.vault.getAbstractFileByPath(change.vault_path);
|
|
if (file instanceof import_obsidian20.TFile) {
|
|
(_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.openFile(file);
|
|
}
|
|
}
|
|
function showDiff(event) {
|
|
var _a2;
|
|
(_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.setViewState({
|
|
type: DIFF_VIEW_CONFIG.type,
|
|
active: true,
|
|
state: { file: change.path, staged: true }
|
|
});
|
|
}
|
|
function unstage() {
|
|
manager.unstage(change.path, false).finally(() => {
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
});
|
|
}
|
|
function focus_handler(event) {
|
|
bubble.call(this, $$self, event);
|
|
}
|
|
function div_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[1] = $$value;
|
|
$$invalidate(2, buttons);
|
|
});
|
|
}
|
|
function div1_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[0] = $$value;
|
|
$$invalidate(2, buttons);
|
|
});
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("change" in $$props2)
|
|
$$invalidate(0, change = $$props2.change);
|
|
if ("view" in $$props2)
|
|
$$invalidate(1, view = $$props2.view);
|
|
if ("manager" in $$props2)
|
|
$$invalidate(9, manager = $$props2.manager);
|
|
};
|
|
$$self.$$.update = () => {
|
|
if ($$self.$$.dirty & 1) {
|
|
$:
|
|
$$invalidate(3, formattedPath = change.vault_path);
|
|
}
|
|
if ($$self.$$.dirty & 2) {
|
|
$:
|
|
$$invalidate(4, side = view.leaf.getRoot().side == "left" ? "right" : "left");
|
|
}
|
|
};
|
|
return [
|
|
change,
|
|
view,
|
|
buttons,
|
|
formattedPath,
|
|
side,
|
|
hover,
|
|
open,
|
|
showDiff,
|
|
unstage,
|
|
manager,
|
|
focus_handler,
|
|
div_binding,
|
|
div1_binding
|
|
];
|
|
}
|
|
var StagedFileComponent = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init2(this, options, instance3, create_fragment3, safe_not_equal, { change: 0, view: 1, manager: 9 }, add_css3);
|
|
}
|
|
};
|
|
var stagedFileComponent_default = StagedFileComponent;
|
|
|
|
// src/ui/sidebar/components/treeComponent.svelte
|
|
init_polyfill_buffer();
|
|
function add_css4(target) {
|
|
append_styles(target, "svelte-148wteu", "main.svelte-148wteu .nav-folder-title-content.svelte-148wteu.svelte-148wteu{display:flex;align-items:center}main.svelte-148wteu .tools.svelte-148wteu.svelte-148wteu{display:flex;margin-left:auto}main.svelte-148wteu .tools .buttons.svelte-148wteu.svelte-148wteu{display:flex}main.svelte-148wteu .tools .buttons.svelte-148wteu>.svelte-148wteu{padding:0 0;height:auto}");
|
|
}
|
|
function get_each_context(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[14] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function create_else_block(ctx) {
|
|
let div5;
|
|
let div4;
|
|
let div0;
|
|
let t0;
|
|
let div1;
|
|
let t1_value = ctx[14].title + "";
|
|
let t1;
|
|
let t2;
|
|
let div3;
|
|
let div2;
|
|
let t3;
|
|
let t4;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
function click_handler() {
|
|
return ctx[9](ctx[14]);
|
|
}
|
|
function click_handler_1() {
|
|
return ctx[10](ctx[14]);
|
|
}
|
|
function select_block_type_2(ctx2, dirty) {
|
|
if (ctx2[3] == FileType.staged)
|
|
return create_if_block_5;
|
|
return create_else_block_1;
|
|
}
|
|
let current_block_type = select_block_type_2(ctx, -1);
|
|
let if_block0 = current_block_type(ctx);
|
|
function click_handler_4() {
|
|
return ctx[13](ctx[14]);
|
|
}
|
|
let if_block1 = !ctx[5][ctx[14].title] && create_if_block_4(ctx);
|
|
return {
|
|
c() {
|
|
div5 = element("div");
|
|
div4 = element("div");
|
|
div0 = element("div");
|
|
div0.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="svg-icon right-triangle"><path d="M3 8L12 17L21 8"></path></svg>`;
|
|
t0 = space();
|
|
div1 = element("div");
|
|
t1 = text(t1_value);
|
|
t2 = space();
|
|
div3 = element("div");
|
|
div2 = element("div");
|
|
if_block0.c();
|
|
t3 = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
t4 = space();
|
|
attr(div0, "class", "nav-folder-collapse-indicator collapse-icon");
|
|
attr(div1, "class", "nav-folder-title-content svelte-148wteu");
|
|
attr(div2, "class", "buttons svelte-148wteu");
|
|
attr(div3, "class", "tools svelte-148wteu");
|
|
attr(div4, "class", "nav-folder-title");
|
|
attr(div5, "class", "nav-folder");
|
|
toggle_class(div5, "is-collapsed", ctx[5][ctx[14].title]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div5, anchor);
|
|
append2(div5, div4);
|
|
append2(div4, div0);
|
|
append2(div4, t0);
|
|
append2(div4, div1);
|
|
append2(div1, t1);
|
|
append2(div4, t2);
|
|
append2(div4, div3);
|
|
append2(div3, div2);
|
|
if_block0.m(div2, null);
|
|
append2(div5, t3);
|
|
if (if_block1)
|
|
if_block1.m(div5, null);
|
|
append2(div5, t4);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(div0, "click", click_handler),
|
|
listen(div1, "click", click_handler_1),
|
|
listen(div4, "click", self2(click_handler_4))
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
if ((!current || dirty & 1) && t1_value !== (t1_value = ctx[14].title + ""))
|
|
set_data(t1, t1_value);
|
|
if (current_block_type === (current_block_type = select_block_type_2(ctx, dirty)) && if_block0) {
|
|
if_block0.p(ctx, dirty);
|
|
} else {
|
|
if_block0.d(1);
|
|
if_block0 = current_block_type(ctx);
|
|
if (if_block0) {
|
|
if_block0.c();
|
|
if_block0.m(div2, null);
|
|
}
|
|
}
|
|
if (!ctx[5][ctx[14].title]) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx, dirty);
|
|
if (dirty & 33) {
|
|
transition_in(if_block1, 1);
|
|
}
|
|
} else {
|
|
if_block1 = create_if_block_4(ctx);
|
|
if_block1.c();
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(div5, t4);
|
|
}
|
|
} else if (if_block1) {
|
|
group_outros();
|
|
transition_out(if_block1, 1, 1, () => {
|
|
if_block1 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
if (!current || dirty & 33) {
|
|
toggle_class(div5, "is-collapsed", ctx[5][ctx[14].title]);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block1);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block1);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div5);
|
|
if_block0.d();
|
|
if (if_block1)
|
|
if_block1.d();
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block3(ctx) {
|
|
let div;
|
|
let current_block_type_index;
|
|
let if_block;
|
|
let t;
|
|
let current;
|
|
const if_block_creators = [create_if_block_1, create_if_block_2, create_if_block_3];
|
|
const if_blocks = [];
|
|
function select_block_type_1(ctx2, dirty) {
|
|
if (ctx2[3] == FileType.staged)
|
|
return 0;
|
|
if (ctx2[3] == FileType.changed)
|
|
return 1;
|
|
if (ctx2[3] == FileType.pulled)
|
|
return 2;
|
|
return -1;
|
|
}
|
|
if (~(current_block_type_index = select_block_type_1(ctx, -1))) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
}
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
if (if_block)
|
|
if_block.c();
|
|
t = space();
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (~current_block_type_index) {
|
|
if_blocks[current_block_type_index].m(div, null);
|
|
}
|
|
append2(div, t);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
let previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type_1(ctx2, dirty);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if (~current_block_type_index) {
|
|
if_blocks[current_block_type_index].p(ctx2, dirty);
|
|
}
|
|
} else {
|
|
if (if_block) {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
if (~current_block_type_index) {
|
|
if_block = if_blocks[current_block_type_index];
|
|
if (!if_block) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
|
|
if_block.c();
|
|
} else {
|
|
if_block.p(ctx2, dirty);
|
|
}
|
|
transition_in(if_block, 1);
|
|
if_block.m(div, t);
|
|
} else {
|
|
if_block = null;
|
|
}
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
if (~current_block_type_index) {
|
|
if_blocks[current_block_type_index].d();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function create_else_block_1(ctx) {
|
|
let div;
|
|
let mounted;
|
|
let dispose;
|
|
function click_handler_3() {
|
|
return ctx[12](ctx[14]);
|
|
}
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
div.innerHTML = `<svg width="18" height="18" viewBox="0 0 18 18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="svg-icon lucide-plus"><line x1="9" y1="4" x2="9" y2="14"></line><line x1="4" y1="9" x2="14" y2="9"></line></svg>`;
|
|
attr(div, "data-icon", "plus");
|
|
attr(div, "aria-label", "Stage");
|
|
attr(div, "class", "clickable-icon svelte-148wteu");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(div, "click", click_handler_3);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_5(ctx) {
|
|
let div;
|
|
let mounted;
|
|
let dispose;
|
|
function click_handler_2() {
|
|
return ctx[11](ctx[14]);
|
|
}
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
div.innerHTML = `<svg width="18" height="18" viewBox="0 0 18 18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="svg-icon lucide-minus"><line x1="4" y1="9" x2="14" y2="9"></line></svg>`;
|
|
attr(div, "data-icon", "minus");
|
|
attr(div, "aria-label", "Unstage");
|
|
attr(div, "class", "clickable-icon svelte-148wteu");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(div, "click", click_handler_2);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_4(ctx) {
|
|
let div;
|
|
let treecomponent;
|
|
let div_transition;
|
|
let current;
|
|
treecomponent = new TreeComponent({
|
|
props: {
|
|
hierarchy: ctx[14],
|
|
plugin: ctx[1],
|
|
view: ctx[2],
|
|
fileType: ctx[3]
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
create_component(treecomponent.$$.fragment);
|
|
attr(div, "class", "nav-folder-children");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(treecomponent, div, null);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const treecomponent_changes = {};
|
|
if (dirty & 1)
|
|
treecomponent_changes.hierarchy = ctx2[14];
|
|
if (dirty & 2)
|
|
treecomponent_changes.plugin = ctx2[1];
|
|
if (dirty & 4)
|
|
treecomponent_changes.view = ctx2[2];
|
|
if (dirty & 8)
|
|
treecomponent_changes.fileType = ctx2[3];
|
|
treecomponent.$set(treecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(treecomponent.$$.fragment, local);
|
|
if (local) {
|
|
add_render_callback(() => {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true);
|
|
div_transition.run(1);
|
|
});
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(treecomponent.$$.fragment, local);
|
|
if (local) {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false);
|
|
div_transition.run(0);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
destroy_component(treecomponent);
|
|
if (detaching && div_transition)
|
|
div_transition.end();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_3(ctx) {
|
|
let pulledfilecomponent;
|
|
let current;
|
|
pulledfilecomponent = new pulledFileComponent_default({
|
|
props: {
|
|
change: ctx[14].statusResult,
|
|
view: ctx[2]
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(pulledfilecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(pulledfilecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const pulledfilecomponent_changes = {};
|
|
if (dirty & 1)
|
|
pulledfilecomponent_changes.change = ctx2[14].statusResult;
|
|
if (dirty & 4)
|
|
pulledfilecomponent_changes.view = ctx2[2];
|
|
pulledfilecomponent.$set(pulledfilecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(pulledfilecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(pulledfilecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(pulledfilecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_2(ctx) {
|
|
let filecomponent;
|
|
let current;
|
|
filecomponent = new fileComponent_default({
|
|
props: {
|
|
change: ctx[14].statusResult,
|
|
manager: ctx[1].gitManager,
|
|
view: ctx[2]
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(filecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(filecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const filecomponent_changes = {};
|
|
if (dirty & 1)
|
|
filecomponent_changes.change = ctx2[14].statusResult;
|
|
if (dirty & 2)
|
|
filecomponent_changes.manager = ctx2[1].gitManager;
|
|
if (dirty & 4)
|
|
filecomponent_changes.view = ctx2[2];
|
|
filecomponent.$set(filecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(filecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(filecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(filecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_1(ctx) {
|
|
let stagedfilecomponent;
|
|
let current;
|
|
stagedfilecomponent = new stagedFileComponent_default({
|
|
props: {
|
|
change: ctx[14].statusResult,
|
|
manager: ctx[1].gitManager,
|
|
view: ctx[2]
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(stagedfilecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(stagedfilecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const stagedfilecomponent_changes = {};
|
|
if (dirty & 1)
|
|
stagedfilecomponent_changes.change = ctx2[14].statusResult;
|
|
if (dirty & 2)
|
|
stagedfilecomponent_changes.manager = ctx2[1].gitManager;
|
|
if (dirty & 4)
|
|
stagedfilecomponent_changes.view = ctx2[2];
|
|
stagedfilecomponent.$set(stagedfilecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(stagedfilecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(stagedfilecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(stagedfilecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block(ctx) {
|
|
let current_block_type_index;
|
|
let if_block;
|
|
let if_block_anchor;
|
|
let current;
|
|
const if_block_creators = [create_if_block3, create_else_block];
|
|
const if_blocks = [];
|
|
function select_block_type(ctx2, dirty) {
|
|
if (ctx2[14].statusResult)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
current_block_type_index = select_block_type(ctx, -1);
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
return {
|
|
c() {
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if_blocks[current_block_type_index].m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
let previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type(ctx2, dirty);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if_blocks[current_block_type_index].p(ctx2, dirty);
|
|
} else {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
if_block = if_blocks[current_block_type_index];
|
|
if (!if_block) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
|
|
if_block.c();
|
|
} else {
|
|
if_block.p(ctx2, dirty);
|
|
}
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if_blocks[current_block_type_index].d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment4(ctx) {
|
|
let main;
|
|
let current;
|
|
let each_value = ctx[0].children;
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
return {
|
|
c() {
|
|
main = element("main");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(main, "class", "svelte-148wteu");
|
|
toggle_class(main, "topLevel", ctx[4]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, main, anchor);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(main, null);
|
|
}
|
|
current = true;
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 495) {
|
|
each_value = ctx2[0].children;
|
|
let i;
|
|
for (i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context(ctx2, each_value, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(main, null);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value.length; i < each_blocks.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
if (!current || dirty & 16) {
|
|
toggle_class(main, "topLevel", ctx2[4]);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(main);
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
function instance4($$self, $$props, $$invalidate) {
|
|
let { hierarchy } = $$props;
|
|
let { plugin } = $$props;
|
|
let { view } = $$props;
|
|
let { fileType } = $$props;
|
|
let { topLevel = false } = $$props;
|
|
const closed = {};
|
|
function stage(path2) {
|
|
plugin.gitManager.stageAll({ dir: path2 }).finally(() => {
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
});
|
|
}
|
|
function unstage(path2) {
|
|
plugin.gitManager.unstageAll({ dir: path2 }).finally(() => {
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
});
|
|
}
|
|
function fold(item) {
|
|
$$invalidate(5, closed[item.title] = !closed[item.title], closed);
|
|
}
|
|
const click_handler = (entity) => fold(entity);
|
|
const click_handler_1 = (entity) => fold(entity);
|
|
const click_handler_2 = (entity) => unstage(entity.title);
|
|
const click_handler_3 = (entity) => stage(entity.path);
|
|
const click_handler_4 = (entity) => fold(entity);
|
|
$$self.$$set = ($$props2) => {
|
|
if ("hierarchy" in $$props2)
|
|
$$invalidate(0, hierarchy = $$props2.hierarchy);
|
|
if ("plugin" in $$props2)
|
|
$$invalidate(1, plugin = $$props2.plugin);
|
|
if ("view" in $$props2)
|
|
$$invalidate(2, view = $$props2.view);
|
|
if ("fileType" in $$props2)
|
|
$$invalidate(3, fileType = $$props2.fileType);
|
|
if ("topLevel" in $$props2)
|
|
$$invalidate(4, topLevel = $$props2.topLevel);
|
|
};
|
|
return [
|
|
hierarchy,
|
|
plugin,
|
|
view,
|
|
fileType,
|
|
topLevel,
|
|
closed,
|
|
stage,
|
|
unstage,
|
|
fold,
|
|
click_handler,
|
|
click_handler_1,
|
|
click_handler_2,
|
|
click_handler_3,
|
|
click_handler_4
|
|
];
|
|
}
|
|
var TreeComponent = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init2(this, options, instance4, create_fragment4, safe_not_equal, {
|
|
hierarchy: 0,
|
|
plugin: 1,
|
|
view: 2,
|
|
fileType: 3,
|
|
topLevel: 4
|
|
}, add_css4);
|
|
}
|
|
};
|
|
var treeComponent_default = TreeComponent;
|
|
|
|
// src/ui/sidebar/gitView.svelte
|
|
function add_css5(target) {
|
|
append_styles(target, "svelte-1u4uc91", `.commit-msg-input.svelte-1u4uc91{width:100%;min-height:33px;height:30px;resize:vertical;padding:7px 5px;background-color:var(--background-modifier-form-field)}.git-commit-msg.svelte-1u4uc91{position:relative;padding:0;width:calc(100% - var(--size-4-8));margin:4px auto}.git-commit-msg-clear-button.svelte-1u4uc91{position:absolute;background:transparent;border-radius:50%;color:var(--search-clear-button-color);cursor:var(--cursor);top:0px;right:2px;bottom:0px;line-height:0;height:var(--input-height);width:28px;margin:auto;padding:0 0;text-align:center;display:flex;justify-content:center;align-items:center;transition:color 0.15s ease-in-out}.git-commit-msg-clear-button.svelte-1u4uc91:after{content:"";height:var(--search-clear-button-size);width:var(--search-clear-button-size);display:block;background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml,<svg viewBox='0 0 12 12' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M6 12C9.31371 12 12 9.31371 12 6C12 2.68629 9.31371 0 6 0C2.68629 0 0 2.68629 0 6C0 9.31371 2.68629 12 6 12ZM3.8705 3.09766L6.00003 5.22718L8.12955 3.09766L8.9024 3.8705L6.77287 6.00003L8.9024 8.12955L8.12955 8.9024L6.00003 6.77287L3.8705 8.9024L3.09766 8.12955L5.22718 6.00003L3.09766 3.8705L3.8705 3.09766Z' fill='currentColor'/></svg>");-webkit-mask-repeat:no-repeat}.tree-item-flair.svelte-1u4uc91{margin-left:auto;align-items:center}`);
|
|
}
|
|
function get_each_context2(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[34] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_1(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[34] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_2(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[39] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function create_if_block_8(ctx) {
|
|
let div;
|
|
let div_aria_label_value;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
attr(div, "class", "git-commit-msg-clear-button svelte-1u4uc91");
|
|
attr(div, "aria-label", div_aria_label_value = "Clear");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(div, "click", ctx[29]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block4(ctx) {
|
|
let div9;
|
|
let div8;
|
|
let div3;
|
|
let div2;
|
|
let div0;
|
|
let t0;
|
|
let div1;
|
|
let t2;
|
|
let span0;
|
|
let t3_value = ctx[5].staged.length + "";
|
|
let t3;
|
|
let t4;
|
|
let t5;
|
|
let div7;
|
|
let div6;
|
|
let div4;
|
|
let t6;
|
|
let div5;
|
|
let t8;
|
|
let span1;
|
|
let t9_value = ctx[5].changed.length + "";
|
|
let t9;
|
|
let t10;
|
|
let t11;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block0 = ctx[13] && create_if_block_6(ctx);
|
|
let if_block1 = ctx[12] && create_if_block_42(ctx);
|
|
let if_block2 = ctx[6].length > 0 && create_if_block_12(ctx);
|
|
return {
|
|
c() {
|
|
div9 = element("div");
|
|
div8 = element("div");
|
|
div3 = element("div");
|
|
div2 = element("div");
|
|
div0 = element("div");
|
|
div0.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="svg-icon right-triangle"><path d="M3 8L12 17L21 8"></path></svg>`;
|
|
t0 = space();
|
|
div1 = element("div");
|
|
div1.textContent = "Staged Changes";
|
|
t2 = space();
|
|
span0 = element("span");
|
|
t3 = text(t3_value);
|
|
t4 = space();
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t5 = space();
|
|
div7 = element("div");
|
|
div6 = element("div");
|
|
div4 = element("div");
|
|
div4.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="svg-icon right-triangle"><path d="M3 8L12 17L21 8"></path></svg>`;
|
|
t6 = space();
|
|
div5 = element("div");
|
|
div5.textContent = "Changes";
|
|
t8 = space();
|
|
span1 = element("span");
|
|
t9 = text(t9_value);
|
|
t10 = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
t11 = space();
|
|
if (if_block2)
|
|
if_block2.c();
|
|
attr(div0, "class", "nav-folder-collapse-indicator collapse-icon");
|
|
attr(div1, "class", "nav-folder-title-content");
|
|
attr(span0, "class", "tree-item-flair svelte-1u4uc91");
|
|
attr(div2, "class", "nav-folder-title");
|
|
attr(div3, "class", "staged nav-folder");
|
|
toggle_class(div3, "is-collapsed", !ctx[13]);
|
|
attr(div4, "class", "nav-folder-collapse-indicator collapse-icon");
|
|
attr(div5, "class", "nav-folder-title-content");
|
|
attr(span1, "class", "tree-item-flair svelte-1u4uc91");
|
|
attr(div6, "class", "nav-folder-title");
|
|
attr(div7, "class", "changes nav-folder");
|
|
toggle_class(div7, "is-collapsed", !ctx[12]);
|
|
attr(div8, "class", "nav-folder-children");
|
|
attr(div9, "class", "nav-folder mod-root");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div9, anchor);
|
|
append2(div9, div8);
|
|
append2(div8, div3);
|
|
append2(div3, div2);
|
|
append2(div2, div0);
|
|
append2(div2, t0);
|
|
append2(div2, div1);
|
|
append2(div2, t2);
|
|
append2(div2, span0);
|
|
append2(span0, t3);
|
|
append2(div3, t4);
|
|
if (if_block0)
|
|
if_block0.m(div3, null);
|
|
append2(div8, t5);
|
|
append2(div8, div7);
|
|
append2(div7, div6);
|
|
append2(div6, div4);
|
|
append2(div6, t6);
|
|
append2(div6, div5);
|
|
append2(div6, t8);
|
|
append2(div6, span1);
|
|
append2(span1, t9);
|
|
append2(div7, t10);
|
|
if (if_block1)
|
|
if_block1.m(div7, null);
|
|
append2(div8, t11);
|
|
if (if_block2)
|
|
if_block2.m(div8, null);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(div2, "click", ctx[30]),
|
|
listen(div6, "click", ctx[31])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if ((!current || dirty[0] & 32) && t3_value !== (t3_value = ctx2[5].staged.length + ""))
|
|
set_data(t3, t3_value);
|
|
if (ctx2[13]) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
if (dirty[0] & 8192) {
|
|
transition_in(if_block0, 1);
|
|
}
|
|
} else {
|
|
if_block0 = create_if_block_6(ctx2);
|
|
if_block0.c();
|
|
transition_in(if_block0, 1);
|
|
if_block0.m(div3, null);
|
|
}
|
|
} else if (if_block0) {
|
|
group_outros();
|
|
transition_out(if_block0, 1, 1, () => {
|
|
if_block0 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
if (!current || dirty[0] & 8192) {
|
|
toggle_class(div3, "is-collapsed", !ctx2[13]);
|
|
}
|
|
if ((!current || dirty[0] & 32) && t9_value !== (t9_value = ctx2[5].changed.length + ""))
|
|
set_data(t9, t9_value);
|
|
if (ctx2[12]) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx2, dirty);
|
|
if (dirty[0] & 4096) {
|
|
transition_in(if_block1, 1);
|
|
}
|
|
} else {
|
|
if_block1 = create_if_block_42(ctx2);
|
|
if_block1.c();
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(div7, null);
|
|
}
|
|
} else if (if_block1) {
|
|
group_outros();
|
|
transition_out(if_block1, 1, 1, () => {
|
|
if_block1 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
if (!current || dirty[0] & 4096) {
|
|
toggle_class(div7, "is-collapsed", !ctx2[12]);
|
|
}
|
|
if (ctx2[6].length > 0) {
|
|
if (if_block2) {
|
|
if_block2.p(ctx2, dirty);
|
|
if (dirty[0] & 64) {
|
|
transition_in(if_block2, 1);
|
|
}
|
|
} else {
|
|
if_block2 = create_if_block_12(ctx2);
|
|
if_block2.c();
|
|
transition_in(if_block2, 1);
|
|
if_block2.m(div8, null);
|
|
}
|
|
} else if (if_block2) {
|
|
group_outros();
|
|
transition_out(if_block2, 1, 1, () => {
|
|
if_block2 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block0);
|
|
transition_in(if_block1);
|
|
transition_in(if_block2);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block0);
|
|
transition_out(if_block1);
|
|
transition_out(if_block2);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div9);
|
|
if (if_block0)
|
|
if_block0.d();
|
|
if (if_block1)
|
|
if_block1.d();
|
|
if (if_block2)
|
|
if_block2.d();
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_6(ctx) {
|
|
let div;
|
|
let current_block_type_index;
|
|
let if_block;
|
|
let div_transition;
|
|
let current;
|
|
const if_block_creators = [create_if_block_7, create_else_block_2];
|
|
const if_blocks = [];
|
|
function select_block_type(ctx2, dirty) {
|
|
if (ctx2[2])
|
|
return 0;
|
|
return 1;
|
|
}
|
|
current_block_type_index = select_block_type(ctx, [-1, -1]);
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
if_block.c();
|
|
attr(div, "class", "nav-folder-children");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if_blocks[current_block_type_index].m(div, null);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
let previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type(ctx2, dirty);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if_blocks[current_block_type_index].p(ctx2, dirty);
|
|
} else {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
if_block = if_blocks[current_block_type_index];
|
|
if (!if_block) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
|
|
if_block.c();
|
|
} else {
|
|
if_block.p(ctx2, dirty);
|
|
}
|
|
transition_in(if_block, 1);
|
|
if_block.m(div, null);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
if (local) {
|
|
add_render_callback(() => {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true);
|
|
div_transition.run(1);
|
|
});
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
if (local) {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false);
|
|
div_transition.run(0);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
if_blocks[current_block_type_index].d();
|
|
if (detaching && div_transition)
|
|
div_transition.end();
|
|
}
|
|
};
|
|
}
|
|
function create_else_block_2(ctx) {
|
|
let each_1_anchor;
|
|
let current;
|
|
let each_value_2 = ctx[5].staged;
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value_2.length; i += 1) {
|
|
each_blocks[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
return {
|
|
c() {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
each_1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
insert(target, each_1_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 35) {
|
|
each_value_2 = ctx2[5].staged;
|
|
let i;
|
|
for (i = 0; i < each_value_2.length; i += 1) {
|
|
const child_ctx = get_each_context_2(ctx2, each_value_2, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block_2(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value_2.length; i < each_blocks.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value_2.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(each_1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_7(ctx) {
|
|
let treecomponent;
|
|
let current;
|
|
treecomponent = new treeComponent_default({
|
|
props: {
|
|
hierarchy: ctx[10],
|
|
plugin: ctx[0],
|
|
view: ctx[1],
|
|
fileType: FileType.staged,
|
|
topLevel: true
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(treecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(treecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const treecomponent_changes = {};
|
|
if (dirty[0] & 1024)
|
|
treecomponent_changes.hierarchy = ctx2[10];
|
|
if (dirty[0] & 1)
|
|
treecomponent_changes.plugin = ctx2[0];
|
|
if (dirty[0] & 2)
|
|
treecomponent_changes.view = ctx2[1];
|
|
treecomponent.$set(treecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(treecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(treecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(treecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block_2(ctx) {
|
|
let stagedfilecomponent;
|
|
let current;
|
|
stagedfilecomponent = new stagedFileComponent_default({
|
|
props: {
|
|
change: ctx[39],
|
|
view: ctx[1],
|
|
manager: ctx[0].gitManager
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(stagedfilecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(stagedfilecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const stagedfilecomponent_changes = {};
|
|
if (dirty[0] & 32)
|
|
stagedfilecomponent_changes.change = ctx2[39];
|
|
if (dirty[0] & 2)
|
|
stagedfilecomponent_changes.view = ctx2[1];
|
|
if (dirty[0] & 1)
|
|
stagedfilecomponent_changes.manager = ctx2[0].gitManager;
|
|
stagedfilecomponent.$set(stagedfilecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(stagedfilecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(stagedfilecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(stagedfilecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_42(ctx) {
|
|
let div;
|
|
let current_block_type_index;
|
|
let if_block;
|
|
let div_transition;
|
|
let current;
|
|
const if_block_creators = [create_if_block_52, create_else_block_12];
|
|
const if_blocks = [];
|
|
function select_block_type_1(ctx2, dirty) {
|
|
if (ctx2[2])
|
|
return 0;
|
|
return 1;
|
|
}
|
|
current_block_type_index = select_block_type_1(ctx, [-1, -1]);
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
if_block.c();
|
|
attr(div, "class", "nav-folder-children");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if_blocks[current_block_type_index].m(div, null);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
let previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type_1(ctx2, dirty);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if_blocks[current_block_type_index].p(ctx2, dirty);
|
|
} else {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
if_block = if_blocks[current_block_type_index];
|
|
if (!if_block) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
|
|
if_block.c();
|
|
} else {
|
|
if_block.p(ctx2, dirty);
|
|
}
|
|
transition_in(if_block, 1);
|
|
if_block.m(div, null);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
if (local) {
|
|
add_render_callback(() => {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true);
|
|
div_transition.run(1);
|
|
});
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
if (local) {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false);
|
|
div_transition.run(0);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
if_blocks[current_block_type_index].d();
|
|
if (detaching && div_transition)
|
|
div_transition.end();
|
|
}
|
|
};
|
|
}
|
|
function create_else_block_12(ctx) {
|
|
let each_1_anchor;
|
|
let current;
|
|
let each_value_1 = ctx[5].changed;
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value_1.length; i += 1) {
|
|
each_blocks[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
return {
|
|
c() {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
each_1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
insert(target, each_1_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 35) {
|
|
each_value_1 = ctx2[5].changed;
|
|
let i;
|
|
for (i = 0; i < each_value_1.length; i += 1) {
|
|
const child_ctx = get_each_context_1(ctx2, each_value_1, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block_1(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value_1.length; i < each_blocks.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value_1.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(each_1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_52(ctx) {
|
|
let treecomponent;
|
|
let current;
|
|
treecomponent = new treeComponent_default({
|
|
props: {
|
|
hierarchy: ctx[9],
|
|
plugin: ctx[0],
|
|
view: ctx[1],
|
|
fileType: FileType.changed,
|
|
topLevel: true
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(treecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(treecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const treecomponent_changes = {};
|
|
if (dirty[0] & 512)
|
|
treecomponent_changes.hierarchy = ctx2[9];
|
|
if (dirty[0] & 1)
|
|
treecomponent_changes.plugin = ctx2[0];
|
|
if (dirty[0] & 2)
|
|
treecomponent_changes.view = ctx2[1];
|
|
treecomponent.$set(treecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(treecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(treecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(treecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block_1(ctx) {
|
|
let filecomponent;
|
|
let current;
|
|
filecomponent = new fileComponent_default({
|
|
props: {
|
|
change: ctx[34],
|
|
view: ctx[1],
|
|
manager: ctx[0].gitManager
|
|
}
|
|
});
|
|
filecomponent.$on("git-refresh", triggerRefresh);
|
|
return {
|
|
c() {
|
|
create_component(filecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(filecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const filecomponent_changes = {};
|
|
if (dirty[0] & 32)
|
|
filecomponent_changes.change = ctx2[34];
|
|
if (dirty[0] & 2)
|
|
filecomponent_changes.view = ctx2[1];
|
|
if (dirty[0] & 1)
|
|
filecomponent_changes.manager = ctx2[0].gitManager;
|
|
filecomponent.$set(filecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(filecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(filecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(filecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_12(ctx) {
|
|
let div3;
|
|
let div2;
|
|
let div0;
|
|
let t0;
|
|
let div1;
|
|
let t2;
|
|
let span;
|
|
let t3_value = ctx[6].length + "";
|
|
let t3;
|
|
let t4;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block = ctx[14] && create_if_block_22(ctx);
|
|
return {
|
|
c() {
|
|
div3 = element("div");
|
|
div2 = element("div");
|
|
div0 = element("div");
|
|
div0.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="svg-icon right-triangle"><path d="M3 8L12 17L21 8"></path></svg>`;
|
|
t0 = space();
|
|
div1 = element("div");
|
|
div1.textContent = "Recently Pulled Files";
|
|
t2 = space();
|
|
span = element("span");
|
|
t3 = text(t3_value);
|
|
t4 = space();
|
|
if (if_block)
|
|
if_block.c();
|
|
attr(div0, "class", "nav-folder-collapse-indicator collapse-icon");
|
|
attr(div1, "class", "nav-folder-title-content");
|
|
attr(span, "class", "tree-item-flair svelte-1u4uc91");
|
|
attr(div2, "class", "nav-folder-title");
|
|
attr(div3, "class", "pulled nav-folder");
|
|
toggle_class(div3, "is-collapsed", !ctx[14]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div3, anchor);
|
|
append2(div3, div2);
|
|
append2(div2, div0);
|
|
append2(div2, t0);
|
|
append2(div2, div1);
|
|
append2(div2, t2);
|
|
append2(div2, span);
|
|
append2(span, t3);
|
|
append2(div3, t4);
|
|
if (if_block)
|
|
if_block.m(div3, null);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = listen(div2, "click", ctx[32]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if ((!current || dirty[0] & 64) && t3_value !== (t3_value = ctx2[6].length + ""))
|
|
set_data(t3, t3_value);
|
|
if (ctx2[14]) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
if (dirty[0] & 16384) {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else {
|
|
if_block = create_if_block_22(ctx2);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(div3, null);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
if (!current || dirty[0] & 16384) {
|
|
toggle_class(div3, "is-collapsed", !ctx2[14]);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div3);
|
|
if (if_block)
|
|
if_block.d();
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_22(ctx) {
|
|
let div;
|
|
let current_block_type_index;
|
|
let if_block;
|
|
let div_transition;
|
|
let current;
|
|
const if_block_creators = [create_if_block_32, create_else_block2];
|
|
const if_blocks = [];
|
|
function select_block_type_2(ctx2, dirty) {
|
|
if (ctx2[2])
|
|
return 0;
|
|
return 1;
|
|
}
|
|
current_block_type_index = select_block_type_2(ctx, [-1, -1]);
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
if_block.c();
|
|
attr(div, "class", "nav-folder-children");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if_blocks[current_block_type_index].m(div, null);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
let previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type_2(ctx2, dirty);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if_blocks[current_block_type_index].p(ctx2, dirty);
|
|
} else {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
if_block = if_blocks[current_block_type_index];
|
|
if (!if_block) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
|
|
if_block.c();
|
|
} else {
|
|
if_block.p(ctx2, dirty);
|
|
}
|
|
transition_in(if_block, 1);
|
|
if_block.m(div, null);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
if (local) {
|
|
add_render_callback(() => {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true);
|
|
div_transition.run(1);
|
|
});
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
if (local) {
|
|
if (!div_transition)
|
|
div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false);
|
|
div_transition.run(0);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
if_blocks[current_block_type_index].d();
|
|
if (detaching && div_transition)
|
|
div_transition.end();
|
|
}
|
|
};
|
|
}
|
|
function create_else_block2(ctx) {
|
|
let each_1_anchor;
|
|
let current;
|
|
let each_value = ctx[6];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block2(get_each_context2(ctx, each_value, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
return {
|
|
c() {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
each_1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
insert(target, each_1_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 66) {
|
|
each_value = ctx2[6];
|
|
let i;
|
|
for (i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context2(ctx2, each_value, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block2(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value.length; i < each_blocks.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(each_1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_32(ctx) {
|
|
let treecomponent;
|
|
let current;
|
|
treecomponent = new treeComponent_default({
|
|
props: {
|
|
hierarchy: ctx[11],
|
|
plugin: ctx[0],
|
|
view: ctx[1],
|
|
fileType: FileType.pulled,
|
|
topLevel: true
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(treecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(treecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const treecomponent_changes = {};
|
|
if (dirty[0] & 2048)
|
|
treecomponent_changes.hierarchy = ctx2[11];
|
|
if (dirty[0] & 1)
|
|
treecomponent_changes.plugin = ctx2[0];
|
|
if (dirty[0] & 2)
|
|
treecomponent_changes.view = ctx2[1];
|
|
treecomponent.$set(treecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(treecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(treecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(treecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block2(ctx) {
|
|
let pulledfilecomponent;
|
|
let current;
|
|
pulledfilecomponent = new pulledFileComponent_default({
|
|
props: {
|
|
change: ctx[34],
|
|
view: ctx[1]
|
|
}
|
|
});
|
|
pulledfilecomponent.$on("git-refresh", triggerRefresh);
|
|
return {
|
|
c() {
|
|
create_component(pulledfilecomponent.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(pulledfilecomponent, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const pulledfilecomponent_changes = {};
|
|
if (dirty[0] & 64)
|
|
pulledfilecomponent_changes.change = ctx2[34];
|
|
if (dirty[0] & 2)
|
|
pulledfilecomponent_changes.view = ctx2[1];
|
|
pulledfilecomponent.$set(pulledfilecomponent_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(pulledfilecomponent.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(pulledfilecomponent.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(pulledfilecomponent, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment5(ctx) {
|
|
let main;
|
|
let div8;
|
|
let div7;
|
|
let div0;
|
|
let t0;
|
|
let div1;
|
|
let t1;
|
|
let div2;
|
|
let t2;
|
|
let div3;
|
|
let t3;
|
|
let div4;
|
|
let t4;
|
|
let div5;
|
|
let t5;
|
|
let div6;
|
|
let t6;
|
|
let div9;
|
|
let textarea;
|
|
let t7;
|
|
let t8;
|
|
let div10;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block0 = ctx[7] && create_if_block_8(ctx);
|
|
let if_block1 = ctx[5] && ctx[10] && ctx[9] && create_if_block4(ctx);
|
|
return {
|
|
c() {
|
|
main = element("main");
|
|
div8 = element("div");
|
|
div7 = element("div");
|
|
div0 = element("div");
|
|
t0 = space();
|
|
div1 = element("div");
|
|
t1 = space();
|
|
div2 = element("div");
|
|
t2 = space();
|
|
div3 = element("div");
|
|
t3 = space();
|
|
div4 = element("div");
|
|
t4 = space();
|
|
div5 = element("div");
|
|
t5 = space();
|
|
div6 = element("div");
|
|
t6 = space();
|
|
div9 = element("div");
|
|
textarea = element("textarea");
|
|
t7 = space();
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t8 = space();
|
|
div10 = element("div");
|
|
if (if_block1)
|
|
if_block1.c();
|
|
attr(div0, "id", "commit-btn");
|
|
attr(div0, "data-icon", "check");
|
|
attr(div0, "class", "clickable-icon nav-action-button");
|
|
attr(div0, "aria-label", "Commit");
|
|
attr(div1, "id", "stage-all");
|
|
attr(div1, "class", "clickable-icon nav-action-button");
|
|
attr(div1, "data-icon", "plus-circle");
|
|
attr(div1, "aria-label", "Stage all");
|
|
attr(div2, "id", "unstage-all");
|
|
attr(div2, "class", "clickable-icon nav-action-button");
|
|
attr(div2, "data-icon", "minus-circle");
|
|
attr(div2, "aria-label", "Unstage all");
|
|
attr(div3, "id", "push");
|
|
attr(div3, "class", "clickable-icon nav-action-button");
|
|
attr(div3, "data-icon", "upload");
|
|
attr(div3, "aria-label", "Push");
|
|
attr(div4, "id", "pull");
|
|
attr(div4, "class", "clickable-icon nav-action-button");
|
|
attr(div4, "data-icon", "download");
|
|
attr(div4, "aria-label", "Pull");
|
|
attr(div5, "id", "layoutChange");
|
|
attr(div5, "class", "clickable-icon nav-action-button");
|
|
attr(div5, "aria-label", "Change Layout");
|
|
attr(div6, "id", "refresh");
|
|
attr(div6, "class", "clickable-icon nav-action-button");
|
|
attr(div6, "data-icon", "refresh-cw");
|
|
attr(div6, "aria-label", "Refresh");
|
|
toggle_class(div6, "loading", ctx[4]);
|
|
attr(div7, "class", "nav-buttons-container");
|
|
attr(div8, "class", "nav-header");
|
|
attr(textarea, "class", "commit-msg-input svelte-1u4uc91");
|
|
attr(textarea, "type", "text");
|
|
attr(textarea, "spellcheck", "true");
|
|
attr(textarea, "placeholder", "Commit Message");
|
|
attr(div9, "class", "git-commit-msg svelte-1u4uc91");
|
|
attr(div10, "class", "nav-files-container");
|
|
set_style(div10, "position", "relative");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, main, anchor);
|
|
append2(main, div8);
|
|
append2(div8, div7);
|
|
append2(div7, div0);
|
|
ctx[20](div0);
|
|
append2(div7, t0);
|
|
append2(div7, div1);
|
|
ctx[21](div1);
|
|
append2(div7, t1);
|
|
append2(div7, div2);
|
|
ctx[22](div2);
|
|
append2(div7, t2);
|
|
append2(div7, div3);
|
|
ctx[23](div3);
|
|
append2(div7, t3);
|
|
append2(div7, div4);
|
|
ctx[24](div4);
|
|
append2(div7, t4);
|
|
append2(div7, div5);
|
|
ctx[25](div5);
|
|
append2(div7, t5);
|
|
append2(div7, div6);
|
|
ctx[27](div6);
|
|
append2(main, t6);
|
|
append2(main, div9);
|
|
append2(div9, textarea);
|
|
set_input_value(textarea, ctx[7]);
|
|
append2(div9, t7);
|
|
if (if_block0)
|
|
if_block0.m(div9, null);
|
|
append2(main, t8);
|
|
append2(main, div10);
|
|
if (if_block1)
|
|
if_block1.m(div10, null);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(div0, "click", ctx[15]),
|
|
listen(div1, "click", ctx[16]),
|
|
listen(div2, "click", ctx[17]),
|
|
listen(div3, "click", ctx[18]),
|
|
listen(div4, "click", ctx[19]),
|
|
listen(div5, "click", ctx[26]),
|
|
listen(div6, "click", triggerRefresh),
|
|
listen(textarea, "input", ctx[28])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (!current || dirty[0] & 16) {
|
|
toggle_class(div6, "loading", ctx2[4]);
|
|
}
|
|
if (dirty[0] & 128) {
|
|
set_input_value(textarea, ctx2[7]);
|
|
}
|
|
if (ctx2[7]) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_8(ctx2);
|
|
if_block0.c();
|
|
if_block0.m(div9, null);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if (ctx2[5] && ctx2[10] && ctx2[9]) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx2, dirty);
|
|
if (dirty[0] & 1568) {
|
|
transition_in(if_block1, 1);
|
|
}
|
|
} else {
|
|
if_block1 = create_if_block4(ctx2);
|
|
if_block1.c();
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(div10, null);
|
|
}
|
|
} else if (if_block1) {
|
|
group_outros();
|
|
transition_out(if_block1, 1, 1, () => {
|
|
if_block1 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block1);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block1);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(main);
|
|
ctx[20](null);
|
|
ctx[21](null);
|
|
ctx[22](null);
|
|
ctx[23](null);
|
|
ctx[24](null);
|
|
ctx[25](null);
|
|
ctx[27](null);
|
|
if (if_block0)
|
|
if_block0.d();
|
|
if (if_block1)
|
|
if_block1.d();
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function triggerRefresh() {
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
}
|
|
function instance5($$self, $$props, $$invalidate) {
|
|
let { plugin } = $$props;
|
|
let { view } = $$props;
|
|
let loading;
|
|
let status2;
|
|
let lastPulledFiles = [];
|
|
let commitMessage = plugin.settings.commitMessage;
|
|
let buttons = [];
|
|
let changeHierarchy;
|
|
let stagedHierarchy;
|
|
let lastPulledFilesHierarchy;
|
|
let changesOpen = true;
|
|
let stagedOpen = true;
|
|
let lastPulledFilesOpen = true;
|
|
let showTree = plugin.settings.treeStructure;
|
|
let layoutBtn;
|
|
addEventListener("git-view-refresh", refresh);
|
|
plugin.app.workspace.onLayoutReady(() => {
|
|
window.setTimeout(() => {
|
|
buttons.forEach((btn) => (0, import_obsidian21.setIcon)(btn, btn.getAttr("data-icon"), 16));
|
|
(0, import_obsidian21.setIcon)(layoutBtn, showTree ? "list" : "folder", 16);
|
|
}, 0);
|
|
});
|
|
onDestroy(() => {
|
|
removeEventListener("git-view-refresh", refresh);
|
|
});
|
|
async function commit2() {
|
|
$$invalidate(4, loading = true);
|
|
if (status2) {
|
|
if (await plugin.hasTooBigFiles(status2.staged)) {
|
|
plugin.setState(PluginState.idle);
|
|
return false;
|
|
}
|
|
plugin.gitManager.commit(commitMessage).then(() => {
|
|
if (commitMessage !== plugin.settings.commitMessage) {
|
|
$$invalidate(7, commitMessage = "");
|
|
}
|
|
}).finally(triggerRefresh);
|
|
}
|
|
}
|
|
async function refresh() {
|
|
if (!plugin.gitReady) {
|
|
$$invalidate(5, status2 = void 0);
|
|
return;
|
|
}
|
|
$$invalidate(5, status2 = plugin.cachedStatus);
|
|
if (plugin.lastPulledFiles && plugin.lastPulledFiles != lastPulledFiles) {
|
|
$$invalidate(6, lastPulledFiles = plugin.lastPulledFiles);
|
|
$$invalidate(11, lastPulledFilesHierarchy = {
|
|
title: "",
|
|
path: "",
|
|
children: plugin.gitManager.getTreeStructure(lastPulledFiles)
|
|
});
|
|
}
|
|
if (status2) {
|
|
const sort = (a, b) => {
|
|
return a.vault_path.split("/").last().localeCompare(b.vault_path.split("/").last());
|
|
};
|
|
status2.changed.sort(sort);
|
|
status2.staged.sort(sort);
|
|
if (status2.changed.length + status2.staged.length > 500) {
|
|
$$invalidate(5, status2 = void 0);
|
|
if (!plugin.loading) {
|
|
plugin.displayError("Too many changes to display");
|
|
}
|
|
} else {
|
|
$$invalidate(9, changeHierarchy = {
|
|
title: "",
|
|
path: "",
|
|
children: plugin.gitManager.getTreeStructure(status2.changed)
|
|
});
|
|
$$invalidate(10, stagedHierarchy = {
|
|
title: "",
|
|
path: "",
|
|
children: plugin.gitManager.getTreeStructure(status2.staged)
|
|
});
|
|
}
|
|
} else {
|
|
$$invalidate(9, changeHierarchy = void 0);
|
|
$$invalidate(10, stagedHierarchy = void 0);
|
|
}
|
|
$$invalidate(4, loading = plugin.loading);
|
|
}
|
|
function stageAll() {
|
|
$$invalidate(4, loading = true);
|
|
plugin.gitManager.stageAll({ status: status2 }).finally(triggerRefresh);
|
|
}
|
|
function unstageAll() {
|
|
$$invalidate(4, loading = true);
|
|
plugin.gitManager.unstageAll({ status: status2 }).finally(triggerRefresh);
|
|
}
|
|
function push2() {
|
|
$$invalidate(4, loading = true);
|
|
plugin.push().finally(triggerRefresh);
|
|
}
|
|
function pull2() {
|
|
$$invalidate(4, loading = true);
|
|
plugin.pullChangesFromRemote().finally(triggerRefresh);
|
|
}
|
|
function div0_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[0] = $$value;
|
|
$$invalidate(8, buttons);
|
|
});
|
|
}
|
|
function div1_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[1] = $$value;
|
|
$$invalidate(8, buttons);
|
|
});
|
|
}
|
|
function div2_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[2] = $$value;
|
|
$$invalidate(8, buttons);
|
|
});
|
|
}
|
|
function div3_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[3] = $$value;
|
|
$$invalidate(8, buttons);
|
|
});
|
|
}
|
|
function div4_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[4] = $$value;
|
|
$$invalidate(8, buttons);
|
|
});
|
|
}
|
|
function div5_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
layoutBtn = $$value;
|
|
$$invalidate(3, layoutBtn);
|
|
});
|
|
}
|
|
const click_handler = () => {
|
|
$$invalidate(2, showTree = !showTree);
|
|
$$invalidate(0, plugin.settings.treeStructure = showTree, plugin);
|
|
plugin.saveSettings();
|
|
};
|
|
function div6_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
buttons[6] = $$value;
|
|
$$invalidate(8, buttons);
|
|
});
|
|
}
|
|
function textarea_input_handler() {
|
|
commitMessage = this.value;
|
|
$$invalidate(7, commitMessage);
|
|
}
|
|
const click_handler_1 = () => $$invalidate(7, commitMessage = "");
|
|
const click_handler_2 = () => $$invalidate(13, stagedOpen = !stagedOpen);
|
|
const click_handler_3 = () => $$invalidate(12, changesOpen = !changesOpen);
|
|
const click_handler_4 = () => $$invalidate(14, lastPulledFilesOpen = !lastPulledFilesOpen);
|
|
$$self.$$set = ($$props2) => {
|
|
if ("plugin" in $$props2)
|
|
$$invalidate(0, plugin = $$props2.plugin);
|
|
if ("view" in $$props2)
|
|
$$invalidate(1, view = $$props2.view);
|
|
};
|
|
$$self.$$.update = () => {
|
|
if ($$self.$$.dirty[0] & 12) {
|
|
$: {
|
|
if (layoutBtn) {
|
|
layoutBtn.empty();
|
|
(0, import_obsidian21.setIcon)(layoutBtn, showTree ? "list" : "folder", 16);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
return [
|
|
plugin,
|
|
view,
|
|
showTree,
|
|
layoutBtn,
|
|
loading,
|
|
status2,
|
|
lastPulledFiles,
|
|
commitMessage,
|
|
buttons,
|
|
changeHierarchy,
|
|
stagedHierarchy,
|
|
lastPulledFilesHierarchy,
|
|
changesOpen,
|
|
stagedOpen,
|
|
lastPulledFilesOpen,
|
|
commit2,
|
|
stageAll,
|
|
unstageAll,
|
|
push2,
|
|
pull2,
|
|
div0_binding,
|
|
div1_binding,
|
|
div2_binding,
|
|
div3_binding,
|
|
div4_binding,
|
|
div5_binding,
|
|
click_handler,
|
|
div6_binding,
|
|
textarea_input_handler,
|
|
click_handler_1,
|
|
click_handler_2,
|
|
click_handler_3,
|
|
click_handler_4
|
|
];
|
|
}
|
|
var GitView = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init2(this, options, instance5, create_fragment5, safe_not_equal, { plugin: 0, view: 1 }, add_css5, [-1, -1]);
|
|
}
|
|
};
|
|
var gitView_default = GitView;
|
|
|
|
// src/ui/sidebar/sidebarView.ts
|
|
var GitView2 = class extends import_obsidian22.ItemView {
|
|
constructor(leaf, plugin) {
|
|
super(leaf);
|
|
this.plugin = plugin;
|
|
this.hoverPopover = null;
|
|
}
|
|
getViewType() {
|
|
return GIT_VIEW_CONFIG.type;
|
|
}
|
|
getDisplayText() {
|
|
return GIT_VIEW_CONFIG.name;
|
|
}
|
|
getIcon() {
|
|
return GIT_VIEW_CONFIG.icon;
|
|
}
|
|
onClose() {
|
|
return super.onClose();
|
|
}
|
|
onOpen() {
|
|
this._view = new gitView_default({
|
|
target: this.contentEl,
|
|
props: {
|
|
plugin: this.plugin,
|
|
view: this
|
|
}
|
|
});
|
|
return super.onOpen();
|
|
}
|
|
};
|
|
|
|
// src/ui/statusBar/branchStatusBar.ts
|
|
init_polyfill_buffer();
|
|
var BranchStatusBar = class {
|
|
constructor(statusBarEl, plugin) {
|
|
this.statusBarEl = statusBarEl;
|
|
this.plugin = plugin;
|
|
this.statusBarEl.addClass("mod-clickable");
|
|
this.statusBarEl.onClickEvent((e) => {
|
|
this.plugin.switchBranch();
|
|
});
|
|
}
|
|
async display() {
|
|
if (this.plugin.gitReady) {
|
|
const branchInfo = await this.plugin.gitManager.branchInfo();
|
|
if (branchInfo.current != void 0) {
|
|
this.statusBarEl.setText(branchInfo.current);
|
|
} else {
|
|
this.statusBarEl.empty();
|
|
}
|
|
} else {
|
|
this.statusBarEl.empty();
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/main.ts
|
|
var ObsidianGit = class extends import_obsidian23.Plugin {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.gitReady = false;
|
|
this.promiseQueue = new PromiseQueue();
|
|
this.conflictOutputFile = "conflict-files-obsidian-git.md";
|
|
this.offlineMode = false;
|
|
this.loading = false;
|
|
}
|
|
setState(state) {
|
|
var _a2;
|
|
this.state = state;
|
|
(_a2 = this.statusBar) == null ? void 0 : _a2.display();
|
|
}
|
|
async updateCachedStatus() {
|
|
this.cachedStatus = await this.gitManager.status();
|
|
return this.cachedStatus;
|
|
}
|
|
async refresh() {
|
|
const gitView = this.app.workspace.getLeavesOfType(GIT_VIEW_CONFIG.type);
|
|
if (this.settings.changedFilesInStatusBar || gitView.length > 0) {
|
|
this.loading = true;
|
|
dispatchEvent(new CustomEvent("git-view-refresh"));
|
|
await this.updateCachedStatus();
|
|
this.loading = false;
|
|
dispatchEvent(new CustomEvent("git-view-refresh"));
|
|
}
|
|
}
|
|
async onload() {
|
|
console.log("loading " + this.manifest.name + " plugin");
|
|
this.localStorage = new LocalStorageSettings(this);
|
|
this.localStorage.migrate();
|
|
await this.loadSettings();
|
|
this.migrateSettings();
|
|
this.addSettingTab(new ObsidianGitSettingsTab(this.app, this));
|
|
if (!this.localStorage.getPluginDisabled()) {
|
|
this.loadPlugin();
|
|
}
|
|
}
|
|
async loadPlugin() {
|
|
addEventListener("git-refresh", this.refresh.bind(this));
|
|
this.registerView(GIT_VIEW_CONFIG.type, (leaf) => {
|
|
return new GitView2(leaf, this);
|
|
});
|
|
this.registerView(DIFF_VIEW_CONFIG.type, (leaf) => {
|
|
return new DiffView(leaf, this);
|
|
});
|
|
this.app.workspace.registerHoverLinkSource(GIT_VIEW_CONFIG.type, {
|
|
display: "Git View",
|
|
defaultMod: true
|
|
});
|
|
this.setRefreshDebouncer();
|
|
this.addCommand({
|
|
id: "edit-gitignore",
|
|
name: "Edit .gitignore",
|
|
callback: async () => {
|
|
const content = await this.app.vault.adapter.read(this.gitManager.getVaultPath(".gitignore"));
|
|
const modal = new IgnoreModal(this.app, content);
|
|
const res = await modal.open();
|
|
if (res !== void 0) {
|
|
await this.app.vault.adapter.write(this.gitManager.getVaultPath(".gitignore"), res);
|
|
this.refresh();
|
|
}
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "open-git-view",
|
|
name: "Open source control view",
|
|
callback: async () => {
|
|
const leafs = this.app.workspace.getLeavesOfType(GIT_VIEW_CONFIG.type);
|
|
let leaf;
|
|
if (leafs.length === 0) {
|
|
leaf = this.app.workspace.getRightLeaf(false);
|
|
await leaf.setViewState({
|
|
type: GIT_VIEW_CONFIG.type
|
|
});
|
|
} else {
|
|
leaf = leafs.first();
|
|
}
|
|
this.app.workspace.revealLeaf(leaf);
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "open-diff-view",
|
|
name: "Open diff view",
|
|
checkCallback: (checking) => {
|
|
var _a2;
|
|
const file = this.app.workspace.getActiveFile();
|
|
if (checking) {
|
|
return file !== null;
|
|
} else {
|
|
(_a2 = getNewLeaf()) == null ? void 0 : _a2.setViewState({ type: DIFF_VIEW_CONFIG.type, state: { staged: false, file: file.path } });
|
|
}
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "view-file-on-github",
|
|
name: "Open file on GitHub",
|
|
editorCallback: (editor, { file }) => openLineInGitHub(editor, file, this.gitManager)
|
|
});
|
|
this.addCommand({
|
|
id: "view-history-on-github",
|
|
name: "Open file history on GitHub",
|
|
editorCallback: (_, { file }) => openHistoryInGitHub(file, this.gitManager)
|
|
});
|
|
this.addCommand({
|
|
id: "pull",
|
|
name: "Pull",
|
|
callback: () => this.promiseQueue.addTask(() => this.pullChangesFromRemote())
|
|
});
|
|
this.addCommand({
|
|
id: "add-to-gitignore",
|
|
name: "Add file to gitignore",
|
|
checkCallback: (checking) => {
|
|
const file = app.workspace.getActiveFile();
|
|
if (checking) {
|
|
return file !== null;
|
|
} else {
|
|
app.vault.adapter.append(this.gitManager.getVaultPath(".gitignore"), "\n" + this.gitManager.getPath(file.path, true)).then(() => {
|
|
this.refresh();
|
|
});
|
|
}
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "push",
|
|
name: "Create backup",
|
|
callback: () => this.promiseQueue.addTask(() => this.createBackup(false))
|
|
});
|
|
this.addCommand({
|
|
id: "backup-and-close",
|
|
name: "Create backup and close",
|
|
callback: () => this.promiseQueue.addTask(async () => {
|
|
await this.createBackup(false);
|
|
window.close();
|
|
})
|
|
});
|
|
this.addCommand({
|
|
id: "commit-push-specified-message",
|
|
name: "Create backup with specific message",
|
|
callback: () => this.promiseQueue.addTask(() => this.createBackup(false, true))
|
|
});
|
|
this.addCommand({
|
|
id: "commit",
|
|
name: "Commit all changes",
|
|
callback: () => this.promiseQueue.addTask(() => this.commit(false))
|
|
});
|
|
this.addCommand({
|
|
id: "commit-specified-message",
|
|
name: "Commit all changes with specific message",
|
|
callback: () => this.promiseQueue.addTask(() => this.commit(false, true))
|
|
});
|
|
this.addCommand({
|
|
id: "commit-staged",
|
|
name: "Commit staged",
|
|
callback: () => this.promiseQueue.addTask(() => this.commit(false, false, true))
|
|
});
|
|
this.addCommand({
|
|
id: "commit-staged-specified-message",
|
|
name: "Commit staged with specific message",
|
|
callback: () => this.promiseQueue.addTask(() => this.commit(false, true, true))
|
|
});
|
|
this.addCommand({
|
|
id: "push2",
|
|
name: "Push",
|
|
callback: () => this.promiseQueue.addTask(() => this.push())
|
|
});
|
|
this.addCommand({
|
|
id: "stage-current-file",
|
|
name: "Stage current file",
|
|
checkCallback: (checking) => {
|
|
const file = this.app.workspace.getActiveFile();
|
|
if (checking) {
|
|
return file !== null;
|
|
} else {
|
|
this.promiseQueue.addTask(() => this.stageFile(file));
|
|
}
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "unstage-current-file",
|
|
name: "Unstage current file",
|
|
checkCallback: (checking) => {
|
|
const file = this.app.workspace.getActiveFile();
|
|
if (checking) {
|
|
return file !== null;
|
|
} else {
|
|
this.promiseQueue.addTask(() => this.unstageFile(file));
|
|
}
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "edit-remotes",
|
|
name: "Edit remotes",
|
|
callback: async () => this.editRemotes()
|
|
});
|
|
this.addCommand({
|
|
id: "remove-remote",
|
|
name: "Remove remote",
|
|
callback: async () => this.removeRemote()
|
|
});
|
|
this.addCommand({
|
|
id: "delete-repo",
|
|
name: "CAUTION: Delete repository",
|
|
callback: async () => {
|
|
const repoExists = await this.app.vault.adapter.exists(`${this.settings.basePath}/.git`);
|
|
if (repoExists) {
|
|
const modal = new GeneralModal({ options: ["NO", "YES"], placeholder: "Do you really want to delete the repository (.git directory)? This action cannot be undone.", onlySelection: true });
|
|
const shouldDelete = await modal.open() === "YES";
|
|
if (shouldDelete) {
|
|
await this.app.vault.adapter.rmdir(`${this.settings.basePath}/.git`, true);
|
|
new import_obsidian23.Notice("Successfully deleted repository. Reloading plugin...");
|
|
this.unloadPlugin();
|
|
this.init();
|
|
}
|
|
} else {
|
|
new import_obsidian23.Notice("No repository found");
|
|
}
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "init-repo",
|
|
name: "Initialize a new repo",
|
|
callback: async () => this.createNewRepo()
|
|
});
|
|
this.addCommand({
|
|
id: "clone-repo",
|
|
name: "Clone an existing remote repo",
|
|
callback: async () => this.cloneNewRepo()
|
|
});
|
|
this.addCommand({
|
|
id: "list-changed-files",
|
|
name: "List changed files",
|
|
callback: async () => {
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
const status2 = await this.gitManager.status();
|
|
this.setState(PluginState.idle);
|
|
if (status2.changed.length + status2.staged.length > 500) {
|
|
this.displayError("Too many changes to display");
|
|
return;
|
|
}
|
|
new ChangedFilesModal(this, status2.changed).open();
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "switch-branch",
|
|
name: "Switch branch",
|
|
callback: () => {
|
|
this.switchBranch();
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "create-branch",
|
|
name: "Create new branch",
|
|
callback: () => {
|
|
this.createBranch();
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "delete-branch",
|
|
name: "Delete branch",
|
|
callback: () => {
|
|
this.deleteBranch();
|
|
}
|
|
});
|
|
this.registerEvent(this.app.workspace.on("file-menu", (menu, file, source) => {
|
|
this.handleFileMenu(menu, file, source);
|
|
}));
|
|
if (this.settings.showStatusBar) {
|
|
const statusBarEl = this.addStatusBarItem();
|
|
this.statusBar = new StatusBar(statusBarEl, this);
|
|
this.registerInterval(window.setInterval(() => {
|
|
var _a2;
|
|
return (_a2 = this.statusBar) == null ? void 0 : _a2.display();
|
|
}, 1e3));
|
|
}
|
|
if (import_obsidian23.Platform.isDesktop && this.settings.showBranchStatusBar) {
|
|
const branchStatusBarEl = this.addStatusBarItem();
|
|
this.branchBar = new BranchStatusBar(branchStatusBarEl, this);
|
|
this.registerInterval(window.setInterval(() => {
|
|
var _a2;
|
|
return (_a2 = this.branchBar) == null ? void 0 : _a2.display();
|
|
}, 6e4));
|
|
}
|
|
this.app.workspace.onLayoutReady(() => this.init());
|
|
}
|
|
setRefreshDebouncer() {
|
|
var _a2;
|
|
(_a2 = this.debRefresh) == null ? void 0 : _a2.cancel();
|
|
this.debRefresh = (0, import_obsidian23.debounce)(() => {
|
|
if (this.settings.refreshSourceControl) {
|
|
this.refresh();
|
|
}
|
|
}, this.settings.refreshSourceControlTimer, true);
|
|
}
|
|
async showNotices() {
|
|
const length = 1e4;
|
|
if (this.manifest.id === "obsidian-git" && import_obsidian23.Platform.isDesktopApp && !this.settings.showedMobileNotice) {
|
|
new import_obsidian23.Notice("Obsidian Git is now available on mobile! Please read the plugin's README for more information.", length);
|
|
this.settings.showedMobileNotice = true;
|
|
await this.saveSettings();
|
|
}
|
|
if (this.manifest.id === "obsidian-git-isomorphic") {
|
|
new import_obsidian23.Notice("Obsidian Git Mobile is now deprecated. Please uninstall it and install Obsidian Git instead.", length);
|
|
}
|
|
}
|
|
handleFileMenu(menu, file, source) {
|
|
if (source !== "file-explorer-context-menu") {
|
|
return;
|
|
}
|
|
if (!file) {
|
|
return;
|
|
}
|
|
if (!this.gitReady)
|
|
return;
|
|
menu.addItem((item) => {
|
|
item.setTitle(`Git: Stage`).setIcon("plus-circle").setSection("action").onClick((_) => {
|
|
this.promiseQueue.addTask(async () => {
|
|
if (file instanceof import_obsidian23.TFile) {
|
|
await this.gitManager.stage(file.path, true);
|
|
} else {
|
|
await this.gitManager.stageAll({ dir: this.gitManager.getPath(file.path, true) });
|
|
}
|
|
this.displayMessage(`Staged ${file.path}`);
|
|
});
|
|
});
|
|
});
|
|
menu.addItem((item) => {
|
|
item.setTitle(`Git: Unstage`).setIcon("minus-circle").setSection("action").onClick((_) => {
|
|
this.promiseQueue.addTask(async () => {
|
|
if (file instanceof import_obsidian23.TFile) {
|
|
await this.gitManager.unstage(file.path, true);
|
|
} else {
|
|
await this.gitManager.unstageAll({ dir: this.gitManager.getPath(file.path, true) });
|
|
}
|
|
this.displayMessage(`Unstaged ${file.path}`);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
async migrateSettings() {
|
|
if (this.settings.mergeOnPull != void 0) {
|
|
this.settings.syncMethod = this.settings.mergeOnPull ? "merge" : "rebase";
|
|
this.settings.mergeOnPull = void 0;
|
|
await this.saveSettings();
|
|
}
|
|
if (this.settings.autoCommitMessage === void 0) {
|
|
this.settings.autoCommitMessage = this.settings.commitMessage;
|
|
await this.saveSettings();
|
|
}
|
|
if (this.settings.gitPath != void 0) {
|
|
this.localStorage.setGitPath(this.settings.gitPath);
|
|
this.settings.gitPath = void 0;
|
|
await this.saveSettings();
|
|
}
|
|
}
|
|
unloadPlugin() {
|
|
this.gitReady = false;
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
this.clearAutoPull();
|
|
this.clearAutoPush();
|
|
this.clearAutoBackup();
|
|
removeEventListener("git-refresh", this.refresh.bind(this));
|
|
this.app.metadataCache.offref(this.modifyEvent);
|
|
this.app.metadataCache.offref(this.deleteEvent);
|
|
this.app.metadataCache.offref(this.createEvent);
|
|
this.app.metadataCache.offref(this.renameEvent);
|
|
this.debRefresh.cancel();
|
|
}
|
|
async onunload() {
|
|
this.app.workspace.unregisterHoverLinkSource(GIT_VIEW_CONFIG.type);
|
|
this.unloadPlugin();
|
|
console.log("unloading " + this.manifest.name + " plugin");
|
|
}
|
|
async loadSettings() {
|
|
let data = await this.loadData();
|
|
if (data == void 0) {
|
|
data = { showedMobileNotice: true };
|
|
}
|
|
this.settings = Object.assign({}, DEFAULT_SETTINGS, data);
|
|
}
|
|
async saveSettings() {
|
|
await this.saveData(this.settings);
|
|
}
|
|
async saveLastAuto(date, mode) {
|
|
if (mode === "backup") {
|
|
this.localStorage.setLastAutoBackup(date.toString());
|
|
} else if (mode === "pull") {
|
|
this.localStorage.setLastAutoPull(date.toString());
|
|
} else if (mode === "push") {
|
|
this.localStorage.setLastAutoPush(date.toString());
|
|
}
|
|
}
|
|
async loadLastAuto() {
|
|
var _a2, _b, _c;
|
|
return {
|
|
"backup": new Date((_a2 = this.localStorage.getLastAutoBackup()) != null ? _a2 : ""),
|
|
"pull": new Date((_b = this.localStorage.getLastAutoPull()) != null ? _b : ""),
|
|
"push": new Date((_c = this.localStorage.getLastAutoPush()) != null ? _c : "")
|
|
};
|
|
}
|
|
async init() {
|
|
var _a2;
|
|
this.showNotices();
|
|
try {
|
|
if (import_obsidian23.Platform.isDesktopApp) {
|
|
this.gitManager = new SimpleGit(this);
|
|
await this.gitManager.setGitInstance();
|
|
} else {
|
|
this.gitManager = new IsomorphicGit(this);
|
|
}
|
|
const result = await this.gitManager.checkRequirements();
|
|
switch (result) {
|
|
case "missing-git":
|
|
this.displayError("Cannot run git command");
|
|
break;
|
|
case "missing-repo":
|
|
new import_obsidian23.Notice("Can't find a valid git repository. Please create one via the given command or clone an existing repo.");
|
|
break;
|
|
case "valid":
|
|
this.gitReady = true;
|
|
this.setState(PluginState.idle);
|
|
this.modifyEvent = this.app.vault.on("modify", () => {
|
|
this.debRefresh();
|
|
});
|
|
this.deleteEvent = this.app.vault.on("delete", () => {
|
|
this.debRefresh();
|
|
});
|
|
this.createEvent = this.app.vault.on("create", () => {
|
|
this.debRefresh();
|
|
});
|
|
this.renameEvent = this.app.vault.on("rename", () => {
|
|
this.debRefresh();
|
|
});
|
|
this.registerEvent(this.modifyEvent);
|
|
this.registerEvent(this.deleteEvent);
|
|
this.registerEvent(this.createEvent);
|
|
this.registerEvent(this.renameEvent);
|
|
(_a2 = this.branchBar) == null ? void 0 : _a2.display();
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
if (this.settings.autoPullOnBoot) {
|
|
this.promiseQueue.addTask(() => this.pullChangesFromRemote());
|
|
}
|
|
const lastAutos = await this.loadLastAuto();
|
|
if (this.settings.autoSaveInterval > 0) {
|
|
const now2 = new Date();
|
|
const diff2 = this.settings.autoSaveInterval - Math.round((now2.getTime() - lastAutos.backup.getTime()) / 1e3 / 60);
|
|
this.startAutoBackup(diff2 <= 0 ? 0 : diff2);
|
|
}
|
|
if (this.settings.differentIntervalCommitAndPush && this.settings.autoPushInterval > 0) {
|
|
const now2 = new Date();
|
|
const diff2 = this.settings.autoPushInterval - Math.round((now2.getTime() - lastAutos.push.getTime()) / 1e3 / 60);
|
|
this.startAutoPush(diff2 <= 0 ? 0 : diff2);
|
|
}
|
|
if (this.settings.autoPullInterval > 0) {
|
|
const now2 = new Date();
|
|
const diff2 = this.settings.autoPullInterval - Math.round((now2.getTime() - lastAutos.pull.getTime()) / 1e3 / 60);
|
|
this.startAutoPull(diff2 <= 0 ? 0 : diff2);
|
|
}
|
|
break;
|
|
default:
|
|
console.log("Something weird happened. The 'checkRequirements' result is " + result);
|
|
}
|
|
} catch (error) {
|
|
this.displayError(error);
|
|
console.error(error);
|
|
}
|
|
}
|
|
async createNewRepo() {
|
|
await this.gitManager.init();
|
|
new import_obsidian23.Notice("Initialized new repo");
|
|
await this.init();
|
|
}
|
|
async cloneNewRepo() {
|
|
const modal = new GeneralModal({ placeholder: "Enter remote URL" });
|
|
const url = await modal.open();
|
|
if (url) {
|
|
const confirmOption = "Vault Root";
|
|
let dir = await new GeneralModal({
|
|
options: [confirmOption],
|
|
placeholder: "Enter directory for clone. It needs to be empty or not existent.",
|
|
allowEmpty: this.gitManager instanceof IsomorphicGit
|
|
}).open();
|
|
if (dir !== void 0) {
|
|
if (dir === confirmOption) {
|
|
dir = ".";
|
|
}
|
|
dir = (0, import_obsidian23.normalizePath)(dir);
|
|
if (dir === "/") {
|
|
dir = ".";
|
|
}
|
|
if (dir === ".") {
|
|
const modal2 = new GeneralModal({ options: ["NO", "YES"], placeholder: `Does your remote repo contain a ${app.vault.configDir} directory at the root?`, onlySelection: true });
|
|
const containsConflictDir = await modal2.open();
|
|
if (containsConflictDir === void 0) {
|
|
new import_obsidian23.Notice("Aborted clone");
|
|
return;
|
|
} else if (containsConflictDir === "YES") {
|
|
const confirmOption2 = "DELETE ALL YOUR LOCAL CONFIG AND PLUGINS";
|
|
const modal3 = new GeneralModal({ options: ["Abort clone", confirmOption2], placeholder: `To avoid conflicts, the local ${app.vault.configDir} directory needs to be deleted.`, onlySelection: true });
|
|
const shouldDelete = await modal3.open() === confirmOption2;
|
|
if (shouldDelete) {
|
|
await this.app.vault.adapter.rmdir(app.vault.configDir, true);
|
|
} else {
|
|
new import_obsidian23.Notice("Aborted clone");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
new import_obsidian23.Notice(`Cloning new repo into "${dir}"`);
|
|
await this.gitManager.clone(url, dir);
|
|
new import_obsidian23.Notice("Cloned new repo.");
|
|
new import_obsidian23.Notice("Please restart Obsidian");
|
|
if (dir && dir !== ".") {
|
|
this.settings.basePath = dir;
|
|
this.saveSettings();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async isAllInitialized() {
|
|
if (!this.gitReady) {
|
|
await this.init();
|
|
}
|
|
return this.gitReady;
|
|
}
|
|
async pullChangesFromRemote() {
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
const filesUpdated = await this.pull();
|
|
if (!filesUpdated) {
|
|
this.displayMessage("Everything is up-to-date");
|
|
}
|
|
if (this.gitManager instanceof SimpleGit) {
|
|
const status2 = await this.gitManager.status();
|
|
if (status2.conflicted.length > 0) {
|
|
this.displayError(`You have ${status2.conflicted.length} conflict ${status2.conflicted.length > 1 ? "files" : "file"}`);
|
|
this.handleConflict(status2.conflicted);
|
|
}
|
|
}
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
this.lastUpdate = Date.now();
|
|
this.setState(PluginState.idle);
|
|
}
|
|
async createBackup(fromAutoBackup, requestCustomMessage = false) {
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
if (this.settings.syncMethod == "reset" && this.settings.pullBeforePush) {
|
|
await this.pull();
|
|
}
|
|
if (!await this.commit(fromAutoBackup, requestCustomMessage))
|
|
return;
|
|
if (!this.settings.disablePush) {
|
|
if (await this.gitManager.canPush()) {
|
|
if (this.settings.syncMethod != "reset" && this.settings.pullBeforePush) {
|
|
await this.pull();
|
|
}
|
|
await this.push();
|
|
} else {
|
|
this.displayMessage("No changes to push");
|
|
}
|
|
}
|
|
this.setState(PluginState.idle);
|
|
}
|
|
async commit(fromAutoBackup, requestCustomMessage = false, onlyStaged = false) {
|
|
if (!await this.isAllInitialized())
|
|
return false;
|
|
const hadConflict = this.localStorage.getConflict() === "true";
|
|
let changedFiles;
|
|
let status2;
|
|
let unstagedFiles;
|
|
if (this.gitManager instanceof SimpleGit) {
|
|
const file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);
|
|
if (file != null)
|
|
await this.app.vault.delete(file);
|
|
status2 = await this.updateCachedStatus();
|
|
if (fromAutoBackup && status2.conflicted.length > 0) {
|
|
this.displayError(`Did not commit, because you have ${status2.conflicted.length} conflict ${status2.conflicted.length > 1 ? "files" : "file"}. Please resolve them and commit per command.`);
|
|
this.handleConflict(status2.conflicted);
|
|
return false;
|
|
}
|
|
changedFiles = [...status2.changed, ...status2.staged];
|
|
} else if (fromAutoBackup && hadConflict) {
|
|
this.setState(PluginState.conflicted);
|
|
this.displayError(`Did not commit, because you have conflict files. Please resolve them and commit per command.`);
|
|
return false;
|
|
} else if (hadConflict) {
|
|
const file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);
|
|
if (file != null)
|
|
await this.app.vault.delete(file);
|
|
status2 = await this.updateCachedStatus();
|
|
changedFiles = [...status2.changed, ...status2.staged];
|
|
} else {
|
|
if (onlyStaged) {
|
|
changedFiles = await this.gitManager.getStagedFiles();
|
|
} else {
|
|
unstagedFiles = await this.gitManager.getUnstagedFiles();
|
|
changedFiles = unstagedFiles.map(({ filepath }) => ({ vault_path: this.gitManager.getVaultPath(filepath) }));
|
|
}
|
|
}
|
|
if (await this.hasTooBigFiles(changedFiles)) {
|
|
this.setState(PluginState.idle);
|
|
return false;
|
|
}
|
|
if (changedFiles.length !== 0 || hadConflict) {
|
|
let commitMessage = fromAutoBackup ? this.settings.autoCommitMessage : this.settings.commitMessage;
|
|
if (fromAutoBackup && this.settings.customMessageOnAutoBackup || requestCustomMessage) {
|
|
if (!this.settings.disablePopups && fromAutoBackup) {
|
|
new import_obsidian23.Notice("Auto backup: Please enter a custom commit message. Leave empty to abort");
|
|
}
|
|
const tempMessage = await new CustomMessageModal(this, true).open();
|
|
if (tempMessage != void 0 && tempMessage != "" && tempMessage != "...") {
|
|
commitMessage = tempMessage;
|
|
} else {
|
|
this.setState(PluginState.idle);
|
|
return false;
|
|
}
|
|
}
|
|
let committedFiles;
|
|
if (onlyStaged) {
|
|
committedFiles = await this.gitManager.commit(commitMessage);
|
|
} else {
|
|
committedFiles = await this.gitManager.commitAll({ message: commitMessage, status: status2, unstagedFiles });
|
|
}
|
|
let roughly = false;
|
|
if (committedFiles === void 0) {
|
|
roughly = true;
|
|
committedFiles = changedFiles.length;
|
|
}
|
|
this.displayMessage(`Committed${roughly ? " approx." : ""} ${committedFiles} ${committedFiles > 1 ? "files" : "file"}`);
|
|
} else {
|
|
this.displayMessage("No changes to commit");
|
|
}
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
this.setState(PluginState.idle);
|
|
return true;
|
|
}
|
|
async hasTooBigFiles(files) {
|
|
var _a2;
|
|
const branchInfo = await this.gitManager.branchInfo();
|
|
const remote = (_a2 = branchInfo.tracking) == null ? void 0 : _a2.split("/")[0];
|
|
if (remote) {
|
|
const remoteUrl = await this.gitManager.getRemoteUrl(remote);
|
|
if (remoteUrl == null ? void 0 : remoteUrl.includes("github.com")) {
|
|
const tooBigFiles = files.filter((f) => {
|
|
const file = this.app.vault.getAbstractFileByPath(f.vault_path);
|
|
if (file instanceof import_obsidian23.TFile) {
|
|
return file.stat.size >= 1e8;
|
|
}
|
|
return false;
|
|
});
|
|
if (tooBigFiles.length > 0) {
|
|
this.displayError(`Did not commit, because following files are too big: ${tooBigFiles.map((e) => e.vault_path)}. Please remove them.`);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
async push() {
|
|
if (!await this.isAllInitialized())
|
|
return false;
|
|
if (!await this.remotesAreSet()) {
|
|
return false;
|
|
}
|
|
const file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);
|
|
const hadConflict = this.localStorage.getConflict() === "true";
|
|
if (this.gitManager instanceof SimpleGit && file)
|
|
await this.app.vault.delete(file);
|
|
let status2;
|
|
if (this.gitManager instanceof SimpleGit && (status2 = await this.updateCachedStatus()).conflicted.length > 0) {
|
|
this.displayError(`Cannot push. You have ${status2.conflicted.length} conflict ${status2.conflicted.length > 1 ? "files" : "file"}`);
|
|
this.handleConflict(status2.conflicted);
|
|
return false;
|
|
} else if (this.gitManager instanceof IsomorphicGit && hadConflict) {
|
|
this.displayError(`Cannot push. You have conflict files`);
|
|
this.setState(PluginState.conflicted);
|
|
return false;
|
|
}
|
|
{
|
|
console.log("Pushing....");
|
|
const pushedFiles = await this.gitManager.push();
|
|
console.log("Pushed!", pushedFiles);
|
|
this.lastUpdate = Date.now();
|
|
if (pushedFiles > 0) {
|
|
this.displayMessage(`Pushed ${pushedFiles} ${pushedFiles > 1 ? "files" : "file"} to remote`);
|
|
} else {
|
|
this.displayMessage(`No changes to push`);
|
|
}
|
|
this.offlineMode = false;
|
|
this.setState(PluginState.idle);
|
|
return true;
|
|
}
|
|
}
|
|
async pull() {
|
|
if (!await this.remotesAreSet()) {
|
|
return false;
|
|
}
|
|
const pulledFiles = await this.gitManager.pull() || [];
|
|
this.offlineMode = false;
|
|
if (pulledFiles.length > 0) {
|
|
this.displayMessage(`Pulled ${pulledFiles.length} ${pulledFiles.length > 1 ? "files" : "file"} from remote`);
|
|
this.lastPulledFiles = pulledFiles;
|
|
}
|
|
return pulledFiles.length != 0;
|
|
}
|
|
async stageFile(file) {
|
|
if (!await this.isAllInitialized())
|
|
return false;
|
|
await this.gitManager.stage(file.path, true);
|
|
this.displayMessage(`Staged ${file.path}`);
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
this.setState(PluginState.idle);
|
|
return true;
|
|
}
|
|
async unstageFile(file) {
|
|
if (!await this.isAllInitialized())
|
|
return false;
|
|
await this.gitManager.unstage(file.path, true);
|
|
this.displayMessage(`Unstaged ${file.path}`);
|
|
dispatchEvent(new CustomEvent("git-refresh"));
|
|
this.setState(PluginState.idle);
|
|
return true;
|
|
}
|
|
async switchBranch() {
|
|
var _a2;
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
const branchInfo = await this.gitManager.branchInfo();
|
|
const selectedBranch = await new BranchModal(branchInfo.branches).open();
|
|
if (selectedBranch != void 0) {
|
|
await this.gitManager.checkout(selectedBranch);
|
|
this.displayMessage(`Switched to ${selectedBranch}`);
|
|
(_a2 = this.branchBar) == null ? void 0 : _a2.display();
|
|
return selectedBranch;
|
|
}
|
|
}
|
|
async createBranch() {
|
|
var _a2;
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
const newBranch = await new GeneralModal({ placeholder: "Create new branch" }).open();
|
|
if (newBranch != void 0) {
|
|
await this.gitManager.createBranch(newBranch);
|
|
this.displayMessage(`Created new branch ${newBranch}`);
|
|
(_a2 = this.branchBar) == null ? void 0 : _a2.display();
|
|
return newBranch;
|
|
}
|
|
}
|
|
async deleteBranch() {
|
|
var _a2;
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
const branchInfo = await this.gitManager.branchInfo();
|
|
if (branchInfo.current)
|
|
branchInfo.branches.remove(branchInfo.current);
|
|
const branch2 = await new GeneralModal({ options: branchInfo.branches, placeholder: "Delete branch", onlySelection: true }).open();
|
|
if (branch2 != void 0) {
|
|
let force = false;
|
|
if (!await this.gitManager.branchIsMerged(branch2)) {
|
|
const forceAnswer = await new GeneralModal({ options: ["YES", "NO"], placeholder: "This branch isn't merged into HEAD. Force delete?", onlySelection: true }).open();
|
|
if (forceAnswer !== "YES") {
|
|
return;
|
|
}
|
|
force = forceAnswer === "YES";
|
|
}
|
|
await this.gitManager.deleteBranch(branch2, force);
|
|
this.displayMessage(`Deleted branch ${branch2}`);
|
|
(_a2 = this.branchBar) == null ? void 0 : _a2.display();
|
|
return branch2;
|
|
}
|
|
}
|
|
async remotesAreSet() {
|
|
if (!(await this.gitManager.branchInfo()).tracking) {
|
|
new import_obsidian23.Notice("No upstream branch is set. Please select one.");
|
|
const remoteBranch = await this.selectRemoteBranch();
|
|
if (remoteBranch == void 0) {
|
|
this.displayError("Aborted. No upstream-branch is set!", 1e4);
|
|
this.setState(PluginState.idle);
|
|
return false;
|
|
} else {
|
|
await this.gitManager.updateUpstreamBranch(remoteBranch);
|
|
return true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
startAutoBackup(minutes) {
|
|
const time = (minutes != null ? minutes : this.settings.autoSaveInterval) * 6e4;
|
|
if (this.settings.autoBackupAfterFileChange) {
|
|
if (minutes === 0) {
|
|
this.doAutoBackup();
|
|
} else {
|
|
this.onFileModifyEventRef = this.app.vault.on("modify", () => this.autoBackupDebouncer());
|
|
this.autoBackupDebouncer = (0, import_obsidian23.debounce)(() => this.doAutoBackup(), time, true);
|
|
}
|
|
} else {
|
|
this.timeoutIDBackup = window.setTimeout(() => this.doAutoBackup(), time);
|
|
}
|
|
}
|
|
doAutoBackup() {
|
|
this.promiseQueue.addTask(() => {
|
|
if (this.settings.differentIntervalCommitAndPush) {
|
|
return this.commit(true);
|
|
} else {
|
|
return this.createBackup(true);
|
|
}
|
|
});
|
|
this.saveLastAuto(new Date(), "backup");
|
|
this.saveSettings();
|
|
this.startAutoBackup();
|
|
}
|
|
startAutoPull(minutes) {
|
|
this.timeoutIDPull = window.setTimeout(() => {
|
|
this.promiseQueue.addTask(() => this.pullChangesFromRemote());
|
|
this.saveLastAuto(new Date(), "pull");
|
|
this.saveSettings();
|
|
this.startAutoPull();
|
|
}, (minutes != null ? minutes : this.settings.autoPullInterval) * 6e4);
|
|
}
|
|
startAutoPush(minutes) {
|
|
this.timeoutIDPush = window.setTimeout(() => {
|
|
this.promiseQueue.addTask(() => this.push());
|
|
this.saveLastAuto(new Date(), "push");
|
|
this.saveSettings();
|
|
this.startAutoPush();
|
|
}, (minutes != null ? minutes : this.settings.autoPushInterval) * 6e4);
|
|
}
|
|
clearAutoBackup() {
|
|
var _a2;
|
|
let wasActive = false;
|
|
if (this.timeoutIDBackup) {
|
|
window.clearTimeout(this.timeoutIDBackup);
|
|
this.timeoutIDBackup = void 0;
|
|
wasActive = true;
|
|
}
|
|
if (this.onFileModifyEventRef) {
|
|
(_a2 = this.autoBackupDebouncer) == null ? void 0 : _a2.cancel();
|
|
this.app.vault.offref(this.onFileModifyEventRef);
|
|
this.onFileModifyEventRef = void 0;
|
|
wasActive = true;
|
|
}
|
|
return wasActive;
|
|
}
|
|
clearAutoPull() {
|
|
if (this.timeoutIDPull) {
|
|
window.clearTimeout(this.timeoutIDPull);
|
|
this.timeoutIDPull = void 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
clearAutoPush() {
|
|
if (this.timeoutIDPush) {
|
|
window.clearTimeout(this.timeoutIDPush);
|
|
this.timeoutIDPush = void 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
async handleConflict(conflicted) {
|
|
this.setState(PluginState.conflicted);
|
|
this.localStorage.setConflict("true");
|
|
let lines;
|
|
if (conflicted !== void 0) {
|
|
lines = [
|
|
"# Conflict files",
|
|
"Please resolve them and commit per command (This file will be deleted before the commit).",
|
|
...conflicted.map((e) => {
|
|
const file = this.app.vault.getAbstractFileByPath(e);
|
|
if (file instanceof import_obsidian23.TFile) {
|
|
const link = this.app.metadataCache.fileToLinktext(file, "/");
|
|
return `- [[${link}]]`;
|
|
} else {
|
|
return `- Not a file: ${e}`;
|
|
}
|
|
})
|
|
];
|
|
}
|
|
this.writeAndOpenFile(lines == null ? void 0 : lines.join("\n"));
|
|
}
|
|
async editRemotes() {
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
const remotes = await this.gitManager.getRemotes();
|
|
const nameModal = new GeneralModal({
|
|
options: remotes,
|
|
placeholder: "Select or create a new remote by typing its name and selecting it"
|
|
});
|
|
const remoteName = await nameModal.open();
|
|
if (remoteName) {
|
|
const oldUrl = await this.gitManager.getRemoteUrl(remoteName);
|
|
const urlModal = new GeneralModal({ initialValue: oldUrl });
|
|
const remoteURL = await urlModal.open();
|
|
if (remoteURL) {
|
|
await this.gitManager.setRemote(remoteName, remoteURL);
|
|
return remoteName;
|
|
}
|
|
}
|
|
}
|
|
async selectRemoteBranch() {
|
|
let remotes = await this.gitManager.getRemotes();
|
|
let selectedRemote;
|
|
if (remotes.length === 0) {
|
|
selectedRemote = await this.editRemotes();
|
|
if (selectedRemote == void 0) {
|
|
remotes = await this.gitManager.getRemotes();
|
|
}
|
|
}
|
|
const nameModal = new GeneralModal({ options: remotes, placeholder: "Select or create a new remote by typing its name and selecting it" });
|
|
const remoteName = selectedRemote != null ? selectedRemote : await nameModal.open();
|
|
if (remoteName) {
|
|
this.displayMessage("Fetching remote branches");
|
|
await this.gitManager.fetch(remoteName);
|
|
const branches = await this.gitManager.getRemoteBranches(remoteName);
|
|
const branchModal = new GeneralModal({ options: branches, placeholder: "Select or create a new remote branch by typing its name and selecting it" });
|
|
return await branchModal.open();
|
|
}
|
|
}
|
|
async removeRemote() {
|
|
if (!await this.isAllInitialized())
|
|
return;
|
|
const remotes = await this.gitManager.getRemotes();
|
|
const nameModal = new GeneralModal({ options: remotes, placeholder: "Select a remote" });
|
|
const remoteName = await nameModal.open();
|
|
if (remoteName) {
|
|
this.gitManager.removeRemote(remoteName);
|
|
}
|
|
}
|
|
async writeAndOpenFile(text2) {
|
|
if (text2 !== void 0) {
|
|
await this.app.vault.adapter.write(this.conflictOutputFile, text2);
|
|
}
|
|
let fileIsAlreadyOpened = false;
|
|
this.app.workspace.iterateAllLeaves((leaf) => {
|
|
if (leaf.getDisplayText() != "" && this.conflictOutputFile.startsWith(leaf.getDisplayText())) {
|
|
fileIsAlreadyOpened = true;
|
|
}
|
|
});
|
|
if (!fileIsAlreadyOpened) {
|
|
this.app.workspace.openLinkText(this.conflictOutputFile, "/", true);
|
|
}
|
|
}
|
|
displayMessage(message, timeout = 4 * 1e3) {
|
|
var _a2;
|
|
(_a2 = this.statusBar) == null ? void 0 : _a2.displayMessage(message.toLowerCase(), timeout);
|
|
if (!this.settings.disablePopups) {
|
|
new import_obsidian23.Notice(message, 5 * 1e3);
|
|
}
|
|
console.log(`git obsidian message: ${message}`);
|
|
}
|
|
displayError(message, timeout = 10 * 1e3) {
|
|
var _a2;
|
|
if (message instanceof Errors.UserCanceledError) {
|
|
new import_obsidian23.Notice("Aborted");
|
|
return;
|
|
}
|
|
message = message.toString();
|
|
new import_obsidian23.Notice(message, timeout);
|
|
console.log(`git obsidian error: ${message}`);
|
|
(_a2 = this.statusBar) == null ? void 0 : _a2.displayMessage(message.toLowerCase(), timeout);
|
|
}
|
|
};
|
|
/*!
|
|
Copyright (c) 2016 Jed Watson.
|
|
Licensed under the MIT License (MIT), see
|
|
http://jedwatson.github.io/classnames
|
|
*/
|
|
/*!
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* @author Feross Aboukhadijeh <https://feross.org>
|
|
* @license MIT
|
|
*/
|
|
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
PERFORMANCE OF THIS SOFTWARE.
|
|
***************************************************************************** */
|
|
/*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com */
|
|
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
|
|
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
|