2187 lines
85 KiB
JavaScript
2187 lines
85 KiB
JavaScript
;(() => {
|
|
var e = {
|
|
650: (e) => {
|
|
var r = Object.prototype.toString
|
|
var n =
|
|
typeof Buffer.alloc === "function" &&
|
|
typeof Buffer.allocUnsafe === "function" &&
|
|
typeof Buffer.from === "function"
|
|
function isArrayBuffer(e) {
|
|
return r.call(e).slice(8, -1) === "ArrayBuffer"
|
|
}
|
|
function fromArrayBuffer(e, r, t) {
|
|
r >>>= 0
|
|
var o = e.byteLength - r
|
|
if (o < 0) {
|
|
throw new RangeError("'offset' is out of bounds")
|
|
}
|
|
if (t === undefined) {
|
|
t = o
|
|
} else {
|
|
t >>>= 0
|
|
if (t > o) {
|
|
throw new RangeError("'length' is out of bounds")
|
|
}
|
|
}
|
|
return n ? Buffer.from(e.slice(r, r + t)) : new Buffer(new Uint8Array(e.slice(r, r + t)))
|
|
}
|
|
function fromString(e, r) {
|
|
if (typeof r !== "string" || r === "") {
|
|
r = "utf8"
|
|
}
|
|
if (!Buffer.isEncoding(r)) {
|
|
throw new TypeError('"encoding" must be a valid string encoding')
|
|
}
|
|
return n ? Buffer.from(e, r) : new Buffer(e, r)
|
|
}
|
|
function bufferFrom(e, r, t) {
|
|
if (typeof e === "number") {
|
|
throw new TypeError('"value" argument must not be a number')
|
|
}
|
|
if (isArrayBuffer(e)) {
|
|
return fromArrayBuffer(e, r, t)
|
|
}
|
|
if (typeof e === "string") {
|
|
return fromString(e, r)
|
|
}
|
|
return n ? Buffer.from(e) : new Buffer(e)
|
|
}
|
|
e.exports = bufferFrom
|
|
},
|
|
274: (e, r, n) => {
|
|
var t = n(339)
|
|
var o = Object.prototype.hasOwnProperty
|
|
var i = typeof Map !== "undefined"
|
|
function ArraySet() {
|
|
this._array = []
|
|
this._set = i ? new Map() : Object.create(null)
|
|
}
|
|
ArraySet.fromArray = function ArraySet_fromArray(e, r) {
|
|
var n = new ArraySet()
|
|
for (var t = 0, o = e.length; t < o; t++) {
|
|
n.add(e[t], r)
|
|
}
|
|
return n
|
|
}
|
|
ArraySet.prototype.size = function ArraySet_size() {
|
|
return i ? this._set.size : Object.getOwnPropertyNames(this._set).length
|
|
}
|
|
ArraySet.prototype.add = function ArraySet_add(e, r) {
|
|
var n = i ? e : t.toSetString(e)
|
|
var a = i ? this.has(e) : o.call(this._set, n)
|
|
var u = this._array.length
|
|
if (!a || r) {
|
|
this._array.push(e)
|
|
}
|
|
if (!a) {
|
|
if (i) {
|
|
this._set.set(e, u)
|
|
} else {
|
|
this._set[n] = u
|
|
}
|
|
}
|
|
}
|
|
ArraySet.prototype.has = function ArraySet_has(e) {
|
|
if (i) {
|
|
return this._set.has(e)
|
|
} else {
|
|
var r = t.toSetString(e)
|
|
return o.call(this._set, r)
|
|
}
|
|
}
|
|
ArraySet.prototype.indexOf = function ArraySet_indexOf(e) {
|
|
if (i) {
|
|
var r = this._set.get(e)
|
|
if (r >= 0) {
|
|
return r
|
|
}
|
|
} else {
|
|
var n = t.toSetString(e)
|
|
if (o.call(this._set, n)) {
|
|
return this._set[n]
|
|
}
|
|
}
|
|
throw new Error('"' + e + '" is not in the set.')
|
|
}
|
|
ArraySet.prototype.at = function ArraySet_at(e) {
|
|
if (e >= 0 && e < this._array.length) {
|
|
return this._array[e]
|
|
}
|
|
throw new Error("No element indexed by " + e)
|
|
}
|
|
ArraySet.prototype.toArray = function ArraySet_toArray() {
|
|
return this._array.slice()
|
|
}
|
|
r.I = ArraySet
|
|
},
|
|
449: (e, r, n) => {
|
|
var t = n(190)
|
|
var o = 5
|
|
var i = 1 << o
|
|
var a = i - 1
|
|
var u = i
|
|
function toVLQSigned(e) {
|
|
return e < 0 ? (-e << 1) + 1 : (e << 1) + 0
|
|
}
|
|
function fromVLQSigned(e) {
|
|
var r = (e & 1) === 1
|
|
var n = e >> 1
|
|
return r ? -n : n
|
|
}
|
|
r.encode = function base64VLQ_encode(e) {
|
|
var r = ""
|
|
var n
|
|
var i = toVLQSigned(e)
|
|
do {
|
|
n = i & a
|
|
i >>>= o
|
|
if (i > 0) {
|
|
n |= u
|
|
}
|
|
r += t.encode(n)
|
|
} while (i > 0)
|
|
return r
|
|
}
|
|
r.decode = function base64VLQ_decode(e, r, n) {
|
|
var i = e.length
|
|
var s = 0
|
|
var l = 0
|
|
var c, p
|
|
do {
|
|
if (r >= i) {
|
|
throw new Error("Expected more digits in base 64 VLQ value.")
|
|
}
|
|
p = t.decode(e.charCodeAt(r++))
|
|
if (p === -1) {
|
|
throw new Error("Invalid base64 digit: " + e.charAt(r - 1))
|
|
}
|
|
c = !!(p & u)
|
|
p &= a
|
|
s = s + (p << l)
|
|
l += o
|
|
} while (c)
|
|
n.value = fromVLQSigned(s)
|
|
n.rest = r
|
|
}
|
|
},
|
|
190: (e, r) => {
|
|
var n = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("")
|
|
r.encode = function (e) {
|
|
if (0 <= e && e < n.length) {
|
|
return n[e]
|
|
}
|
|
throw new TypeError("Must be between 0 and 63: " + e)
|
|
}
|
|
r.decode = function (e) {
|
|
var r = 65
|
|
var n = 90
|
|
var t = 97
|
|
var o = 122
|
|
var i = 48
|
|
var a = 57
|
|
var u = 43
|
|
var s = 47
|
|
var l = 26
|
|
var c = 52
|
|
if (r <= e && e <= n) {
|
|
return e - r
|
|
}
|
|
if (t <= e && e <= o) {
|
|
return e - t + l
|
|
}
|
|
if (i <= e && e <= a) {
|
|
return e - i + c
|
|
}
|
|
if (e == u) {
|
|
return 62
|
|
}
|
|
if (e == s) {
|
|
return 63
|
|
}
|
|
return -1
|
|
}
|
|
},
|
|
345: (e, r) => {
|
|
r.GREATEST_LOWER_BOUND = 1
|
|
r.LEAST_UPPER_BOUND = 2
|
|
function recursiveSearch(e, n, t, o, i, a) {
|
|
var u = Math.floor((n - e) / 2) + e
|
|
var s = i(t, o[u], true)
|
|
if (s === 0) {
|
|
return u
|
|
} else if (s > 0) {
|
|
if (n - u > 1) {
|
|
return recursiveSearch(u, n, t, o, i, a)
|
|
}
|
|
if (a == r.LEAST_UPPER_BOUND) {
|
|
return n < o.length ? n : -1
|
|
} else {
|
|
return u
|
|
}
|
|
} else {
|
|
if (u - e > 1) {
|
|
return recursiveSearch(e, u, t, o, i, a)
|
|
}
|
|
if (a == r.LEAST_UPPER_BOUND) {
|
|
return u
|
|
} else {
|
|
return e < 0 ? -1 : e
|
|
}
|
|
}
|
|
}
|
|
r.search = function search(e, n, t, o) {
|
|
if (n.length === 0) {
|
|
return -1
|
|
}
|
|
var i = recursiveSearch(-1, n.length, e, n, t, o || r.GREATEST_LOWER_BOUND)
|
|
if (i < 0) {
|
|
return -1
|
|
}
|
|
while (i - 1 >= 0) {
|
|
if (t(n[i], n[i - 1], true) !== 0) {
|
|
break
|
|
}
|
|
--i
|
|
}
|
|
return i
|
|
}
|
|
},
|
|
680: (e, r, n) => {
|
|
var t = n(339)
|
|
function generatedPositionAfter(e, r) {
|
|
var n = e.generatedLine
|
|
var o = r.generatedLine
|
|
var i = e.generatedColumn
|
|
var a = r.generatedColumn
|
|
return o > n || (o == n && a >= i) || t.compareByGeneratedPositionsInflated(e, r) <= 0
|
|
}
|
|
function MappingList() {
|
|
this._array = []
|
|
this._sorted = true
|
|
this._last = { generatedLine: -1, generatedColumn: 0 }
|
|
}
|
|
MappingList.prototype.unsortedForEach = function MappingList_forEach(e, r) {
|
|
this._array.forEach(e, r)
|
|
}
|
|
MappingList.prototype.add = function MappingList_add(e) {
|
|
if (generatedPositionAfter(this._last, e)) {
|
|
this._last = e
|
|
this._array.push(e)
|
|
} else {
|
|
this._sorted = false
|
|
this._array.push(e)
|
|
}
|
|
}
|
|
MappingList.prototype.toArray = function MappingList_toArray() {
|
|
if (!this._sorted) {
|
|
this._array.sort(t.compareByGeneratedPositionsInflated)
|
|
this._sorted = true
|
|
}
|
|
return this._array
|
|
}
|
|
r.H = MappingList
|
|
},
|
|
758: (e, r) => {
|
|
function swap(e, r, n) {
|
|
var t = e[r]
|
|
e[r] = e[n]
|
|
e[n] = t
|
|
}
|
|
function randomIntInRange(e, r) {
|
|
return Math.round(e + Math.random() * (r - e))
|
|
}
|
|
function doQuickSort(e, r, n, t) {
|
|
if (n < t) {
|
|
var o = randomIntInRange(n, t)
|
|
var i = n - 1
|
|
swap(e, o, t)
|
|
var a = e[t]
|
|
for (var u = n; u < t; u++) {
|
|
if (r(e[u], a) <= 0) {
|
|
i += 1
|
|
swap(e, i, u)
|
|
}
|
|
}
|
|
swap(e, i + 1, u)
|
|
var s = i + 1
|
|
doQuickSort(e, r, n, s - 1)
|
|
doQuickSort(e, r, s + 1, t)
|
|
}
|
|
}
|
|
r.U = function (e, r) {
|
|
doQuickSort(e, r, 0, e.length - 1)
|
|
}
|
|
},
|
|
952: (e, r, n) => {
|
|
var t
|
|
var o = n(339)
|
|
var i = n(345)
|
|
var a = n(274).I
|
|
var u = n(449)
|
|
var s = n(758).U
|
|
function SourceMapConsumer(e, r) {
|
|
var n = e
|
|
if (typeof e === "string") {
|
|
n = o.parseSourceMapInput(e)
|
|
}
|
|
return n.sections != null ? new IndexedSourceMapConsumer(n, r) : new BasicSourceMapConsumer(n, r)
|
|
}
|
|
SourceMapConsumer.fromSourceMap = function (e, r) {
|
|
return BasicSourceMapConsumer.fromSourceMap(e, r)
|
|
}
|
|
SourceMapConsumer.prototype._version = 3
|
|
SourceMapConsumer.prototype.__generatedMappings = null
|
|
Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function () {
|
|
if (!this.__generatedMappings) {
|
|
this._parseMappings(this._mappings, this.sourceRoot)
|
|
}
|
|
return this.__generatedMappings
|
|
},
|
|
})
|
|
SourceMapConsumer.prototype.__originalMappings = null
|
|
Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function () {
|
|
if (!this.__originalMappings) {
|
|
this._parseMappings(this._mappings, this.sourceRoot)
|
|
}
|
|
return this.__originalMappings
|
|
},
|
|
})
|
|
SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(
|
|
e,
|
|
r
|
|
) {
|
|
var n = e.charAt(r)
|
|
return n === ";" || n === ","
|
|
}
|
|
SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(e, r) {
|
|
throw new Error("Subclasses must implement _parseMappings")
|
|
}
|
|
SourceMapConsumer.GENERATED_ORDER = 1
|
|
SourceMapConsumer.ORIGINAL_ORDER = 2
|
|
SourceMapConsumer.GREATEST_LOWER_BOUND = 1
|
|
SourceMapConsumer.LEAST_UPPER_BOUND = 2
|
|
SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(e, r, n) {
|
|
var t = r || null
|
|
var i = n || SourceMapConsumer.GENERATED_ORDER
|
|
var a
|
|
switch (i) {
|
|
case SourceMapConsumer.GENERATED_ORDER:
|
|
a = this._generatedMappings
|
|
break
|
|
case SourceMapConsumer.ORIGINAL_ORDER:
|
|
a = this._originalMappings
|
|
break
|
|
default:
|
|
throw new Error("Unknown order of iteration.")
|
|
}
|
|
var u = this.sourceRoot
|
|
a.map(function (e) {
|
|
var r = e.source === null ? null : this._sources.at(e.source)
|
|
r = o.computeSourceURL(u, r, this._sourceMapURL)
|
|
return {
|
|
source: r,
|
|
generatedLine: e.generatedLine,
|
|
generatedColumn: e.generatedColumn,
|
|
originalLine: e.originalLine,
|
|
originalColumn: e.originalColumn,
|
|
name: e.name === null ? null : this._names.at(e.name),
|
|
}
|
|
}, this).forEach(e, t)
|
|
}
|
|
SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(
|
|
e
|
|
) {
|
|
var r = o.getArg(e, "line")
|
|
var n = { source: o.getArg(e, "source"), originalLine: r, originalColumn: o.getArg(e, "column", 0) }
|
|
n.source = this._findSourceIndex(n.source)
|
|
if (n.source < 0) {
|
|
return []
|
|
}
|
|
var t = []
|
|
var a = this._findMapping(
|
|
n,
|
|
this._originalMappings,
|
|
"originalLine",
|
|
"originalColumn",
|
|
o.compareByOriginalPositions,
|
|
i.LEAST_UPPER_BOUND
|
|
)
|
|
if (a >= 0) {
|
|
var u = this._originalMappings[a]
|
|
if (e.column === undefined) {
|
|
var s = u.originalLine
|
|
while (u && u.originalLine === s) {
|
|
t.push({
|
|
line: o.getArg(u, "generatedLine", null),
|
|
column: o.getArg(u, "generatedColumn", null),
|
|
lastColumn: o.getArg(u, "lastGeneratedColumn", null),
|
|
})
|
|
u = this._originalMappings[++a]
|
|
}
|
|
} else {
|
|
var l = u.originalColumn
|
|
while (u && u.originalLine === r && u.originalColumn == l) {
|
|
t.push({
|
|
line: o.getArg(u, "generatedLine", null),
|
|
column: o.getArg(u, "generatedColumn", null),
|
|
lastColumn: o.getArg(u, "lastGeneratedColumn", null),
|
|
})
|
|
u = this._originalMappings[++a]
|
|
}
|
|
}
|
|
}
|
|
return t
|
|
}
|
|
r.SourceMapConsumer = SourceMapConsumer
|
|
function BasicSourceMapConsumer(e, r) {
|
|
var n = e
|
|
if (typeof e === "string") {
|
|
n = o.parseSourceMapInput(e)
|
|
}
|
|
var t = o.getArg(n, "version")
|
|
var i = o.getArg(n, "sources")
|
|
var u = o.getArg(n, "names", [])
|
|
var s = o.getArg(n, "sourceRoot", null)
|
|
var l = o.getArg(n, "sourcesContent", null)
|
|
var c = o.getArg(n, "mappings")
|
|
var p = o.getArg(n, "file", null)
|
|
if (t != this._version) {
|
|
throw new Error("Unsupported version: " + t)
|
|
}
|
|
if (s) {
|
|
s = o.normalize(s)
|
|
}
|
|
i = i
|
|
.map(String)
|
|
.map(o.normalize)
|
|
.map(function (e) {
|
|
return s && o.isAbsolute(s) && o.isAbsolute(e) ? o.relative(s, e) : e
|
|
})
|
|
this._names = a.fromArray(u.map(String), true)
|
|
this._sources = a.fromArray(i, true)
|
|
this._absoluteSources = this._sources.toArray().map(function (e) {
|
|
return o.computeSourceURL(s, e, r)
|
|
})
|
|
this.sourceRoot = s
|
|
this.sourcesContent = l
|
|
this._mappings = c
|
|
this._sourceMapURL = r
|
|
this.file = p
|
|
}
|
|
BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype)
|
|
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer
|
|
BasicSourceMapConsumer.prototype._findSourceIndex = function (e) {
|
|
var r = e
|
|
if (this.sourceRoot != null) {
|
|
r = o.relative(this.sourceRoot, r)
|
|
}
|
|
if (this._sources.has(r)) {
|
|
return this._sources.indexOf(r)
|
|
}
|
|
var n
|
|
for (n = 0; n < this._absoluteSources.length; ++n) {
|
|
if (this._absoluteSources[n] == e) {
|
|
return n
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(e, r) {
|
|
var n = Object.create(BasicSourceMapConsumer.prototype)
|
|
var t = (n._names = a.fromArray(e._names.toArray(), true))
|
|
var i = (n._sources = a.fromArray(e._sources.toArray(), true))
|
|
n.sourceRoot = e._sourceRoot
|
|
n.sourcesContent = e._generateSourcesContent(n._sources.toArray(), n.sourceRoot)
|
|
n.file = e._file
|
|
n._sourceMapURL = r
|
|
n._absoluteSources = n._sources.toArray().map(function (e) {
|
|
return o.computeSourceURL(n.sourceRoot, e, r)
|
|
})
|
|
var u = e._mappings.toArray().slice()
|
|
var l = (n.__generatedMappings = [])
|
|
var c = (n.__originalMappings = [])
|
|
for (var p = 0, f = u.length; p < f; p++) {
|
|
var g = u[p]
|
|
var h = new Mapping()
|
|
h.generatedLine = g.generatedLine
|
|
h.generatedColumn = g.generatedColumn
|
|
if (g.source) {
|
|
h.source = i.indexOf(g.source)
|
|
h.originalLine = g.originalLine
|
|
h.originalColumn = g.originalColumn
|
|
if (g.name) {
|
|
h.name = t.indexOf(g.name)
|
|
}
|
|
c.push(h)
|
|
}
|
|
l.push(h)
|
|
}
|
|
s(n.__originalMappings, o.compareByOriginalPositions)
|
|
return n
|
|
}
|
|
BasicSourceMapConsumer.prototype._version = 3
|
|
Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
|
|
get: function () {
|
|
return this._absoluteSources.slice()
|
|
},
|
|
})
|
|
function Mapping() {
|
|
this.generatedLine = 0
|
|
this.generatedColumn = 0
|
|
this.source = null
|
|
this.originalLine = null
|
|
this.originalColumn = null
|
|
this.name = null
|
|
}
|
|
BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(e, r) {
|
|
var n = 1
|
|
var t = 0
|
|
var i = 0
|
|
var a = 0
|
|
var l = 0
|
|
var c = 0
|
|
var p = e.length
|
|
var f = 0
|
|
var g = {}
|
|
var h = {}
|
|
var d = []
|
|
var m = []
|
|
var v, S, _, C, y
|
|
while (f < p) {
|
|
if (e.charAt(f) === ";") {
|
|
n++
|
|
f++
|
|
t = 0
|
|
} else if (e.charAt(f) === ",") {
|
|
f++
|
|
} else {
|
|
v = new Mapping()
|
|
v.generatedLine = n
|
|
for (C = f; C < p; C++) {
|
|
if (this._charIsMappingSeparator(e, C)) {
|
|
break
|
|
}
|
|
}
|
|
S = e.slice(f, C)
|
|
_ = g[S]
|
|
if (_) {
|
|
f += S.length
|
|
} else {
|
|
_ = []
|
|
while (f < C) {
|
|
u.decode(e, f, h)
|
|
y = h.value
|
|
f = h.rest
|
|
_.push(y)
|
|
}
|
|
if (_.length === 2) {
|
|
throw new Error("Found a source, but no line and column")
|
|
}
|
|
if (_.length === 3) {
|
|
throw new Error("Found a source and line, but no column")
|
|
}
|
|
g[S] = _
|
|
}
|
|
v.generatedColumn = t + _[0]
|
|
t = v.generatedColumn
|
|
if (_.length > 1) {
|
|
v.source = l + _[1]
|
|
l += _[1]
|
|
v.originalLine = i + _[2]
|
|
i = v.originalLine
|
|
v.originalLine += 1
|
|
v.originalColumn = a + _[3]
|
|
a = v.originalColumn
|
|
if (_.length > 4) {
|
|
v.name = c + _[4]
|
|
c += _[4]
|
|
}
|
|
}
|
|
m.push(v)
|
|
if (typeof v.originalLine === "number") {
|
|
d.push(v)
|
|
}
|
|
}
|
|
}
|
|
s(m, o.compareByGeneratedPositionsDeflated)
|
|
this.__generatedMappings = m
|
|
s(d, o.compareByOriginalPositions)
|
|
this.__originalMappings = d
|
|
}
|
|
BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(e, r, n, t, o, a) {
|
|
if (e[n] <= 0) {
|
|
throw new TypeError("Line must be greater than or equal to 1, got " + e[n])
|
|
}
|
|
if (e[t] < 0) {
|
|
throw new TypeError("Column must be greater than or equal to 0, got " + e[t])
|
|
}
|
|
return i.search(e, r, o, a)
|
|
}
|
|
BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
|
|
for (var e = 0; e < this._generatedMappings.length; ++e) {
|
|
var r = this._generatedMappings[e]
|
|
if (e + 1 < this._generatedMappings.length) {
|
|
var n = this._generatedMappings[e + 1]
|
|
if (r.generatedLine === n.generatedLine) {
|
|
r.lastGeneratedColumn = n.generatedColumn - 1
|
|
continue
|
|
}
|
|
}
|
|
r.lastGeneratedColumn = Infinity
|
|
}
|
|
}
|
|
BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(e) {
|
|
var r = { generatedLine: o.getArg(e, "line"), generatedColumn: o.getArg(e, "column") }
|
|
var n = this._findMapping(
|
|
r,
|
|
this._generatedMappings,
|
|
"generatedLine",
|
|
"generatedColumn",
|
|
o.compareByGeneratedPositionsDeflated,
|
|
o.getArg(e, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
|
|
)
|
|
if (n >= 0) {
|
|
var t = this._generatedMappings[n]
|
|
if (t.generatedLine === r.generatedLine) {
|
|
var i = o.getArg(t, "source", null)
|
|
if (i !== null) {
|
|
i = this._sources.at(i)
|
|
i = o.computeSourceURL(this.sourceRoot, i, this._sourceMapURL)
|
|
}
|
|
var a = o.getArg(t, "name", null)
|
|
if (a !== null) {
|
|
a = this._names.at(a)
|
|
}
|
|
return {
|
|
source: i,
|
|
line: o.getArg(t, "originalLine", null),
|
|
column: o.getArg(t, "originalColumn", null),
|
|
name: a,
|
|
}
|
|
}
|
|
}
|
|
return { source: null, line: null, column: null, name: null }
|
|
}
|
|
BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
|
|
function BasicSourceMapConsumer_hasContentsOfAllSources() {
|
|
if (!this.sourcesContent) {
|
|
return false
|
|
}
|
|
return (
|
|
this.sourcesContent.length >= this._sources.size() &&
|
|
!this.sourcesContent.some(function (e) {
|
|
return e == null
|
|
})
|
|
)
|
|
}
|
|
BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(e, r) {
|
|
if (!this.sourcesContent) {
|
|
return null
|
|
}
|
|
var n = this._findSourceIndex(e)
|
|
if (n >= 0) {
|
|
return this.sourcesContent[n]
|
|
}
|
|
var t = e
|
|
if (this.sourceRoot != null) {
|
|
t = o.relative(this.sourceRoot, t)
|
|
}
|
|
var i
|
|
if (this.sourceRoot != null && (i = o.urlParse(this.sourceRoot))) {
|
|
var a = t.replace(/^file:\/\//, "")
|
|
if (i.scheme == "file" && this._sources.has(a)) {
|
|
return this.sourcesContent[this._sources.indexOf(a)]
|
|
}
|
|
if ((!i.path || i.path == "/") && this._sources.has("/" + t)) {
|
|
return this.sourcesContent[this._sources.indexOf("/" + t)]
|
|
}
|
|
}
|
|
if (r) {
|
|
return null
|
|
} else {
|
|
throw new Error('"' + t + '" is not in the SourceMap.')
|
|
}
|
|
}
|
|
BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(e) {
|
|
var r = o.getArg(e, "source")
|
|
r = this._findSourceIndex(r)
|
|
if (r < 0) {
|
|
return { line: null, column: null, lastColumn: null }
|
|
}
|
|
var n = { source: r, originalLine: o.getArg(e, "line"), originalColumn: o.getArg(e, "column") }
|
|
var t = this._findMapping(
|
|
n,
|
|
this._originalMappings,
|
|
"originalLine",
|
|
"originalColumn",
|
|
o.compareByOriginalPositions,
|
|
o.getArg(e, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
|
|
)
|
|
if (t >= 0) {
|
|
var i = this._originalMappings[t]
|
|
if (i.source === n.source) {
|
|
return {
|
|
line: o.getArg(i, "generatedLine", null),
|
|
column: o.getArg(i, "generatedColumn", null),
|
|
lastColumn: o.getArg(i, "lastGeneratedColumn", null),
|
|
}
|
|
}
|
|
}
|
|
return { line: null, column: null, lastColumn: null }
|
|
}
|
|
t = BasicSourceMapConsumer
|
|
function IndexedSourceMapConsumer(e, r) {
|
|
var n = e
|
|
if (typeof e === "string") {
|
|
n = o.parseSourceMapInput(e)
|
|
}
|
|
var t = o.getArg(n, "version")
|
|
var i = o.getArg(n, "sections")
|
|
if (t != this._version) {
|
|
throw new Error("Unsupported version: " + t)
|
|
}
|
|
this._sources = new a()
|
|
this._names = new a()
|
|
var u = { line: -1, column: 0 }
|
|
this._sections = i.map(function (e) {
|
|
if (e.url) {
|
|
throw new Error("Support for url field in sections not implemented.")
|
|
}
|
|
var n = o.getArg(e, "offset")
|
|
var t = o.getArg(n, "line")
|
|
var i = o.getArg(n, "column")
|
|
if (t < u.line || (t === u.line && i < u.column)) {
|
|
throw new Error("Section offsets must be ordered and non-overlapping.")
|
|
}
|
|
u = n
|
|
return {
|
|
generatedOffset: { generatedLine: t + 1, generatedColumn: i + 1 },
|
|
consumer: new SourceMapConsumer(o.getArg(e, "map"), r),
|
|
}
|
|
})
|
|
}
|
|
IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype)
|
|
IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer
|
|
IndexedSourceMapConsumer.prototype._version = 3
|
|
Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
|
|
get: function () {
|
|
var e = []
|
|
for (var r = 0; r < this._sections.length; r++) {
|
|
for (var n = 0; n < this._sections[r].consumer.sources.length; n++) {
|
|
e.push(this._sections[r].consumer.sources[n])
|
|
}
|
|
}
|
|
return e
|
|
},
|
|
})
|
|
IndexedSourceMapConsumer.prototype.originalPositionFor =
|
|
function IndexedSourceMapConsumer_originalPositionFor(e) {
|
|
var r = { generatedLine: o.getArg(e, "line"), generatedColumn: o.getArg(e, "column") }
|
|
var n = i.search(r, this._sections, function (e, r) {
|
|
var n = e.generatedLine - r.generatedOffset.generatedLine
|
|
if (n) {
|
|
return n
|
|
}
|
|
return e.generatedColumn - r.generatedOffset.generatedColumn
|
|
})
|
|
var t = this._sections[n]
|
|
if (!t) {
|
|
return { source: null, line: null, column: null, name: null }
|
|
}
|
|
return t.consumer.originalPositionFor({
|
|
line: r.generatedLine - (t.generatedOffset.generatedLine - 1),
|
|
column:
|
|
r.generatedColumn -
|
|
(t.generatedOffset.generatedLine === r.generatedLine
|
|
? t.generatedOffset.generatedColumn - 1
|
|
: 0),
|
|
bias: e.bias,
|
|
})
|
|
}
|
|
IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
|
|
function IndexedSourceMapConsumer_hasContentsOfAllSources() {
|
|
return this._sections.every(function (e) {
|
|
return e.consumer.hasContentsOfAllSources()
|
|
})
|
|
}
|
|
IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(
|
|
e,
|
|
r
|
|
) {
|
|
for (var n = 0; n < this._sections.length; n++) {
|
|
var t = this._sections[n]
|
|
var o = t.consumer.sourceContentFor(e, true)
|
|
if (o) {
|
|
return o
|
|
}
|
|
}
|
|
if (r) {
|
|
return null
|
|
} else {
|
|
throw new Error('"' + e + '" is not in the SourceMap.')
|
|
}
|
|
}
|
|
IndexedSourceMapConsumer.prototype.generatedPositionFor =
|
|
function IndexedSourceMapConsumer_generatedPositionFor(e) {
|
|
for (var r = 0; r < this._sections.length; r++) {
|
|
var n = this._sections[r]
|
|
if (n.consumer._findSourceIndex(o.getArg(e, "source")) === -1) {
|
|
continue
|
|
}
|
|
var t = n.consumer.generatedPositionFor(e)
|
|
if (t) {
|
|
var i = {
|
|
line: t.line + (n.generatedOffset.generatedLine - 1),
|
|
column:
|
|
t.column +
|
|
(n.generatedOffset.generatedLine === t.line
|
|
? n.generatedOffset.generatedColumn - 1
|
|
: 0),
|
|
}
|
|
return i
|
|
}
|
|
}
|
|
return { line: null, column: null }
|
|
}
|
|
IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(e, r) {
|
|
this.__generatedMappings = []
|
|
this.__originalMappings = []
|
|
for (var n = 0; n < this._sections.length; n++) {
|
|
var t = this._sections[n]
|
|
var i = t.consumer._generatedMappings
|
|
for (var a = 0; a < i.length; a++) {
|
|
var u = i[a]
|
|
var l = t.consumer._sources.at(u.source)
|
|
l = o.computeSourceURL(t.consumer.sourceRoot, l, this._sourceMapURL)
|
|
this._sources.add(l)
|
|
l = this._sources.indexOf(l)
|
|
var c = null
|
|
if (u.name) {
|
|
c = t.consumer._names.at(u.name)
|
|
this._names.add(c)
|
|
c = this._names.indexOf(c)
|
|
}
|
|
var p = {
|
|
source: l,
|
|
generatedLine: u.generatedLine + (t.generatedOffset.generatedLine - 1),
|
|
generatedColumn:
|
|
u.generatedColumn +
|
|
(t.generatedOffset.generatedLine === u.generatedLine
|
|
? t.generatedOffset.generatedColumn - 1
|
|
: 0),
|
|
originalLine: u.originalLine,
|
|
originalColumn: u.originalColumn,
|
|
name: c,
|
|
}
|
|
this.__generatedMappings.push(p)
|
|
if (typeof p.originalLine === "number") {
|
|
this.__originalMappings.push(p)
|
|
}
|
|
}
|
|
}
|
|
s(this.__generatedMappings, o.compareByGeneratedPositionsDeflated)
|
|
s(this.__originalMappings, o.compareByOriginalPositions)
|
|
}
|
|
t = IndexedSourceMapConsumer
|
|
},
|
|
591: (e, r, n) => {
|
|
var t = n(449)
|
|
var o = n(339)
|
|
var i = n(274).I
|
|
var a = n(680).H
|
|
function SourceMapGenerator(e) {
|
|
if (!e) {
|
|
e = {}
|
|
}
|
|
this._file = o.getArg(e, "file", null)
|
|
this._sourceRoot = o.getArg(e, "sourceRoot", null)
|
|
this._skipValidation = o.getArg(e, "skipValidation", false)
|
|
this._sources = new i()
|
|
this._names = new i()
|
|
this._mappings = new a()
|
|
this._sourcesContents = null
|
|
}
|
|
SourceMapGenerator.prototype._version = 3
|
|
SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(e) {
|
|
var r = e.sourceRoot
|
|
var n = new SourceMapGenerator({ file: e.file, sourceRoot: r })
|
|
e.eachMapping(function (e) {
|
|
var t = { generated: { line: e.generatedLine, column: e.generatedColumn } }
|
|
if (e.source != null) {
|
|
t.source = e.source
|
|
if (r != null) {
|
|
t.source = o.relative(r, t.source)
|
|
}
|
|
t.original = { line: e.originalLine, column: e.originalColumn }
|
|
if (e.name != null) {
|
|
t.name = e.name
|
|
}
|
|
}
|
|
n.addMapping(t)
|
|
})
|
|
e.sources.forEach(function (t) {
|
|
var i = t
|
|
if (r !== null) {
|
|
i = o.relative(r, t)
|
|
}
|
|
if (!n._sources.has(i)) {
|
|
n._sources.add(i)
|
|
}
|
|
var a = e.sourceContentFor(t)
|
|
if (a != null) {
|
|
n.setSourceContent(t, a)
|
|
}
|
|
})
|
|
return n
|
|
}
|
|
SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(e) {
|
|
var r = o.getArg(e, "generated")
|
|
var n = o.getArg(e, "original", null)
|
|
var t = o.getArg(e, "source", null)
|
|
var i = o.getArg(e, "name", null)
|
|
if (!this._skipValidation) {
|
|
this._validateMapping(r, n, t, i)
|
|
}
|
|
if (t != null) {
|
|
t = String(t)
|
|
if (!this._sources.has(t)) {
|
|
this._sources.add(t)
|
|
}
|
|
}
|
|
if (i != null) {
|
|
i = String(i)
|
|
if (!this._names.has(i)) {
|
|
this._names.add(i)
|
|
}
|
|
}
|
|
this._mappings.add({
|
|
generatedLine: r.line,
|
|
generatedColumn: r.column,
|
|
originalLine: n != null && n.line,
|
|
originalColumn: n != null && n.column,
|
|
source: t,
|
|
name: i,
|
|
})
|
|
}
|
|
SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(e, r) {
|
|
var n = e
|
|
if (this._sourceRoot != null) {
|
|
n = o.relative(this._sourceRoot, n)
|
|
}
|
|
if (r != null) {
|
|
if (!this._sourcesContents) {
|
|
this._sourcesContents = Object.create(null)
|
|
}
|
|
this._sourcesContents[o.toSetString(n)] = r
|
|
} else if (this._sourcesContents) {
|
|
delete this._sourcesContents[o.toSetString(n)]
|
|
if (Object.keys(this._sourcesContents).length === 0) {
|
|
this._sourcesContents = null
|
|
}
|
|
}
|
|
}
|
|
SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(e, r, n) {
|
|
var t = r
|
|
if (r == null) {
|
|
if (e.file == null) {
|
|
throw new Error(
|
|
"SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " +
|
|
'or the source map\'s "file" property. Both were omitted.'
|
|
)
|
|
}
|
|
t = e.file
|
|
}
|
|
var a = this._sourceRoot
|
|
if (a != null) {
|
|
t = o.relative(a, t)
|
|
}
|
|
var u = new i()
|
|
var s = new i()
|
|
this._mappings.unsortedForEach(function (r) {
|
|
if (r.source === t && r.originalLine != null) {
|
|
var i = e.originalPositionFor({ line: r.originalLine, column: r.originalColumn })
|
|
if (i.source != null) {
|
|
r.source = i.source
|
|
if (n != null) {
|
|
r.source = o.join(n, r.source)
|
|
}
|
|
if (a != null) {
|
|
r.source = o.relative(a, r.source)
|
|
}
|
|
r.originalLine = i.line
|
|
r.originalColumn = i.column
|
|
if (i.name != null) {
|
|
r.name = i.name
|
|
}
|
|
}
|
|
}
|
|
var l = r.source
|
|
if (l != null && !u.has(l)) {
|
|
u.add(l)
|
|
}
|
|
var c = r.name
|
|
if (c != null && !s.has(c)) {
|
|
s.add(c)
|
|
}
|
|
}, this)
|
|
this._sources = u
|
|
this._names = s
|
|
e.sources.forEach(function (r) {
|
|
var t = e.sourceContentFor(r)
|
|
if (t != null) {
|
|
if (n != null) {
|
|
r = o.join(n, r)
|
|
}
|
|
if (a != null) {
|
|
r = o.relative(a, r)
|
|
}
|
|
this.setSourceContent(r, t)
|
|
}
|
|
}, this)
|
|
}
|
|
SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(e, r, n, t) {
|
|
if (r && typeof r.line !== "number" && typeof r.column !== "number") {
|
|
throw new Error(
|
|
"original.line and original.column are not numbers -- you probably meant to omit " +
|
|
"the original mapping entirely and only map the generated position. If so, pass " +
|
|
"null for the original mapping instead of an object with empty or null values."
|
|
)
|
|
}
|
|
if (e && "line" in e && "column" in e && e.line > 0 && e.column >= 0 && !r && !n && !t) {
|
|
return
|
|
} else if (
|
|
e &&
|
|
"line" in e &&
|
|
"column" in e &&
|
|
r &&
|
|
"line" in r &&
|
|
"column" in r &&
|
|
e.line > 0 &&
|
|
e.column >= 0 &&
|
|
r.line > 0 &&
|
|
r.column >= 0 &&
|
|
n
|
|
) {
|
|
return
|
|
} else {
|
|
throw new Error(
|
|
"Invalid mapping: " + JSON.stringify({ generated: e, source: n, original: r, name: t })
|
|
)
|
|
}
|
|
}
|
|
SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
|
|
var e = 0
|
|
var r = 1
|
|
var n = 0
|
|
var i = 0
|
|
var a = 0
|
|
var u = 0
|
|
var s = ""
|
|
var l
|
|
var c
|
|
var p
|
|
var f
|
|
var g = this._mappings.toArray()
|
|
for (var h = 0, d = g.length; h < d; h++) {
|
|
c = g[h]
|
|
l = ""
|
|
if (c.generatedLine !== r) {
|
|
e = 0
|
|
while (c.generatedLine !== r) {
|
|
l += ";"
|
|
r++
|
|
}
|
|
} else {
|
|
if (h > 0) {
|
|
if (!o.compareByGeneratedPositionsInflated(c, g[h - 1])) {
|
|
continue
|
|
}
|
|
l += ","
|
|
}
|
|
}
|
|
l += t.encode(c.generatedColumn - e)
|
|
e = c.generatedColumn
|
|
if (c.source != null) {
|
|
f = this._sources.indexOf(c.source)
|
|
l += t.encode(f - u)
|
|
u = f
|
|
l += t.encode(c.originalLine - 1 - i)
|
|
i = c.originalLine - 1
|
|
l += t.encode(c.originalColumn - n)
|
|
n = c.originalColumn
|
|
if (c.name != null) {
|
|
p = this._names.indexOf(c.name)
|
|
l += t.encode(p - a)
|
|
a = p
|
|
}
|
|
}
|
|
s += l
|
|
}
|
|
return s
|
|
}
|
|
SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(
|
|
e,
|
|
r
|
|
) {
|
|
return e.map(function (e) {
|
|
if (!this._sourcesContents) {
|
|
return null
|
|
}
|
|
if (r != null) {
|
|
e = o.relative(r, e)
|
|
}
|
|
var n = o.toSetString(e)
|
|
return Object.prototype.hasOwnProperty.call(this._sourcesContents, n)
|
|
? this._sourcesContents[n]
|
|
: null
|
|
}, this)
|
|
}
|
|
SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
|
|
var e = {
|
|
version: this._version,
|
|
sources: this._sources.toArray(),
|
|
names: this._names.toArray(),
|
|
mappings: this._serializeMappings(),
|
|
}
|
|
if (this._file != null) {
|
|
e.file = this._file
|
|
}
|
|
if (this._sourceRoot != null) {
|
|
e.sourceRoot = this._sourceRoot
|
|
}
|
|
if (this._sourcesContents) {
|
|
e.sourcesContent = this._generateSourcesContent(e.sources, e.sourceRoot)
|
|
}
|
|
return e
|
|
}
|
|
SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
|
|
return JSON.stringify(this.toJSON())
|
|
}
|
|
r.h = SourceMapGenerator
|
|
},
|
|
351: (e, r, n) => {
|
|
var t
|
|
var o = n(591).h
|
|
var i = n(339)
|
|
var a = /(\r?\n)/
|
|
var u = 10
|
|
var s = "$$$isSourceNode$$$"
|
|
function SourceNode(e, r, n, t, o) {
|
|
this.children = []
|
|
this.sourceContents = {}
|
|
this.line = e == null ? null : e
|
|
this.column = r == null ? null : r
|
|
this.source = n == null ? null : n
|
|
this.name = o == null ? null : o
|
|
this[s] = true
|
|
if (t != null) this.add(t)
|
|
}
|
|
SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(e, r, n) {
|
|
var t = new SourceNode()
|
|
var o = e.split(a)
|
|
var u = 0
|
|
var shiftNextLine = function () {
|
|
var e = getNextLine()
|
|
var r = getNextLine() || ""
|
|
return e + r
|
|
function getNextLine() {
|
|
return u < o.length ? o[u++] : undefined
|
|
}
|
|
}
|
|
var s = 1,
|
|
l = 0
|
|
var c = null
|
|
r.eachMapping(function (e) {
|
|
if (c !== null) {
|
|
if (s < e.generatedLine) {
|
|
addMappingWithCode(c, shiftNextLine())
|
|
s++
|
|
l = 0
|
|
} else {
|
|
var r = o[u] || ""
|
|
var n = r.substr(0, e.generatedColumn - l)
|
|
o[u] = r.substr(e.generatedColumn - l)
|
|
l = e.generatedColumn
|
|
addMappingWithCode(c, n)
|
|
c = e
|
|
return
|
|
}
|
|
}
|
|
while (s < e.generatedLine) {
|
|
t.add(shiftNextLine())
|
|
s++
|
|
}
|
|
if (l < e.generatedColumn) {
|
|
var r = o[u] || ""
|
|
t.add(r.substr(0, e.generatedColumn))
|
|
o[u] = r.substr(e.generatedColumn)
|
|
l = e.generatedColumn
|
|
}
|
|
c = e
|
|
}, this)
|
|
if (u < o.length) {
|
|
if (c) {
|
|
addMappingWithCode(c, shiftNextLine())
|
|
}
|
|
t.add(o.splice(u).join(""))
|
|
}
|
|
r.sources.forEach(function (e) {
|
|
var o = r.sourceContentFor(e)
|
|
if (o != null) {
|
|
if (n != null) {
|
|
e = i.join(n, e)
|
|
}
|
|
t.setSourceContent(e, o)
|
|
}
|
|
})
|
|
return t
|
|
function addMappingWithCode(e, r) {
|
|
if (e === null || e.source === undefined) {
|
|
t.add(r)
|
|
} else {
|
|
var o = n ? i.join(n, e.source) : e.source
|
|
t.add(new SourceNode(e.originalLine, e.originalColumn, o, r, e.name))
|
|
}
|
|
}
|
|
}
|
|
SourceNode.prototype.add = function SourceNode_add(e) {
|
|
if (Array.isArray(e)) {
|
|
e.forEach(function (e) {
|
|
this.add(e)
|
|
}, this)
|
|
} else if (e[s] || typeof e === "string") {
|
|
if (e) {
|
|
this.children.push(e)
|
|
}
|
|
} else {
|
|
throw new TypeError(
|
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + e
|
|
)
|
|
}
|
|
return this
|
|
}
|
|
SourceNode.prototype.prepend = function SourceNode_prepend(e) {
|
|
if (Array.isArray(e)) {
|
|
for (var r = e.length - 1; r >= 0; r--) {
|
|
this.prepend(e[r])
|
|
}
|
|
} else if (e[s] || typeof e === "string") {
|
|
this.children.unshift(e)
|
|
} else {
|
|
throw new TypeError(
|
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + e
|
|
)
|
|
}
|
|
return this
|
|
}
|
|
SourceNode.prototype.walk = function SourceNode_walk(e) {
|
|
var r
|
|
for (var n = 0, t = this.children.length; n < t; n++) {
|
|
r = this.children[n]
|
|
if (r[s]) {
|
|
r.walk(e)
|
|
} else {
|
|
if (r !== "") {
|
|
e(r, { source: this.source, line: this.line, column: this.column, name: this.name })
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SourceNode.prototype.join = function SourceNode_join(e) {
|
|
var r
|
|
var n
|
|
var t = this.children.length
|
|
if (t > 0) {
|
|
r = []
|
|
for (n = 0; n < t - 1; n++) {
|
|
r.push(this.children[n])
|
|
r.push(e)
|
|
}
|
|
r.push(this.children[n])
|
|
this.children = r
|
|
}
|
|
return this
|
|
}
|
|
SourceNode.prototype.replaceRight = function SourceNode_replaceRight(e, r) {
|
|
var n = this.children[this.children.length - 1]
|
|
if (n[s]) {
|
|
n.replaceRight(e, r)
|
|
} else if (typeof n === "string") {
|
|
this.children[this.children.length - 1] = n.replace(e, r)
|
|
} else {
|
|
this.children.push("".replace(e, r))
|
|
}
|
|
return this
|
|
}
|
|
SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(e, r) {
|
|
this.sourceContents[i.toSetString(e)] = r
|
|
}
|
|
SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(e) {
|
|
for (var r = 0, n = this.children.length; r < n; r++) {
|
|
if (this.children[r][s]) {
|
|
this.children[r].walkSourceContents(e)
|
|
}
|
|
}
|
|
var t = Object.keys(this.sourceContents)
|
|
for (var r = 0, n = t.length; r < n; r++) {
|
|
e(i.fromSetString(t[r]), this.sourceContents[t[r]])
|
|
}
|
|
}
|
|
SourceNode.prototype.toString = function SourceNode_toString() {
|
|
var e = ""
|
|
this.walk(function (r) {
|
|
e += r
|
|
})
|
|
return e
|
|
}
|
|
SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(e) {
|
|
var r = { code: "", line: 1, column: 0 }
|
|
var n = new o(e)
|
|
var t = false
|
|
var i = null
|
|
var a = null
|
|
var s = null
|
|
var l = null
|
|
this.walk(function (e, o) {
|
|
r.code += e
|
|
if (o.source !== null && o.line !== null && o.column !== null) {
|
|
if (i !== o.source || a !== o.line || s !== o.column || l !== o.name) {
|
|
n.addMapping({
|
|
source: o.source,
|
|
original: { line: o.line, column: o.column },
|
|
generated: { line: r.line, column: r.column },
|
|
name: o.name,
|
|
})
|
|
}
|
|
i = o.source
|
|
a = o.line
|
|
s = o.column
|
|
l = o.name
|
|
t = true
|
|
} else if (t) {
|
|
n.addMapping({ generated: { line: r.line, column: r.column } })
|
|
i = null
|
|
t = false
|
|
}
|
|
for (var c = 0, p = e.length; c < p; c++) {
|
|
if (e.charCodeAt(c) === u) {
|
|
r.line++
|
|
r.column = 0
|
|
if (c + 1 === p) {
|
|
i = null
|
|
t = false
|
|
} else if (t) {
|
|
n.addMapping({
|
|
source: o.source,
|
|
original: { line: o.line, column: o.column },
|
|
generated: { line: r.line, column: r.column },
|
|
name: o.name,
|
|
})
|
|
}
|
|
} else {
|
|
r.column++
|
|
}
|
|
}
|
|
})
|
|
this.walkSourceContents(function (e, r) {
|
|
n.setSourceContent(e, r)
|
|
})
|
|
return { code: r.code, map: n }
|
|
}
|
|
t = SourceNode
|
|
},
|
|
339: (e, r) => {
|
|
function getArg(e, r, n) {
|
|
if (r in e) {
|
|
return e[r]
|
|
} else if (arguments.length === 3) {
|
|
return n
|
|
} else {
|
|
throw new Error('"' + r + '" is a required argument.')
|
|
}
|
|
}
|
|
r.getArg = getArg
|
|
var n = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/
|
|
var t = /^data:.+\,.+$/
|
|
function urlParse(e) {
|
|
var r = e.match(n)
|
|
if (!r) {
|
|
return null
|
|
}
|
|
return { scheme: r[1], auth: r[2], host: r[3], port: r[4], path: r[5] }
|
|
}
|
|
r.urlParse = urlParse
|
|
function urlGenerate(e) {
|
|
var r = ""
|
|
if (e.scheme) {
|
|
r += e.scheme + ":"
|
|
}
|
|
r += "//"
|
|
if (e.auth) {
|
|
r += e.auth + "@"
|
|
}
|
|
if (e.host) {
|
|
r += e.host
|
|
}
|
|
if (e.port) {
|
|
r += ":" + e.port
|
|
}
|
|
if (e.path) {
|
|
r += e.path
|
|
}
|
|
return r
|
|
}
|
|
r.urlGenerate = urlGenerate
|
|
function normalize(e) {
|
|
var n = e
|
|
var t = urlParse(e)
|
|
if (t) {
|
|
if (!t.path) {
|
|
return e
|
|
}
|
|
n = t.path
|
|
}
|
|
var o = r.isAbsolute(n)
|
|
var i = n.split(/\/+/)
|
|
for (var a, u = 0, s = i.length - 1; s >= 0; s--) {
|
|
a = i[s]
|
|
if (a === ".") {
|
|
i.splice(s, 1)
|
|
} else if (a === "..") {
|
|
u++
|
|
} else if (u > 0) {
|
|
if (a === "") {
|
|
i.splice(s + 1, u)
|
|
u = 0
|
|
} else {
|
|
i.splice(s, 2)
|
|
u--
|
|
}
|
|
}
|
|
}
|
|
n = i.join("/")
|
|
if (n === "") {
|
|
n = o ? "/" : "."
|
|
}
|
|
if (t) {
|
|
t.path = n
|
|
return urlGenerate(t)
|
|
}
|
|
return n
|
|
}
|
|
r.normalize = normalize
|
|
function join(e, r) {
|
|
if (e === "") {
|
|
e = "."
|
|
}
|
|
if (r === "") {
|
|
r = "."
|
|
}
|
|
var n = urlParse(r)
|
|
var o = urlParse(e)
|
|
if (o) {
|
|
e = o.path || "/"
|
|
}
|
|
if (n && !n.scheme) {
|
|
if (o) {
|
|
n.scheme = o.scheme
|
|
}
|
|
return urlGenerate(n)
|
|
}
|
|
if (n || r.match(t)) {
|
|
return r
|
|
}
|
|
if (o && !o.host && !o.path) {
|
|
o.host = r
|
|
return urlGenerate(o)
|
|
}
|
|
var i = r.charAt(0) === "/" ? r : normalize(e.replace(/\/+$/, "") + "/" + r)
|
|
if (o) {
|
|
o.path = i
|
|
return urlGenerate(o)
|
|
}
|
|
return i
|
|
}
|
|
r.join = join
|
|
r.isAbsolute = function (e) {
|
|
return e.charAt(0) === "/" || n.test(e)
|
|
}
|
|
function relative(e, r) {
|
|
if (e === "") {
|
|
e = "."
|
|
}
|
|
e = e.replace(/\/$/, "")
|
|
var n = 0
|
|
while (r.indexOf(e + "/") !== 0) {
|
|
var t = e.lastIndexOf("/")
|
|
if (t < 0) {
|
|
return r
|
|
}
|
|
e = e.slice(0, t)
|
|
if (e.match(/^([^\/]+:\/)?\/*$/)) {
|
|
return r
|
|
}
|
|
++n
|
|
}
|
|
return Array(n + 1).join("../") + r.substr(e.length + 1)
|
|
}
|
|
r.relative = relative
|
|
var o = (function () {
|
|
var e = Object.create(null)
|
|
return !("__proto__" in e)
|
|
})()
|
|
function identity(e) {
|
|
return e
|
|
}
|
|
function toSetString(e) {
|
|
if (isProtoString(e)) {
|
|
return "$" + e
|
|
}
|
|
return e
|
|
}
|
|
r.toSetString = o ? identity : toSetString
|
|
function fromSetString(e) {
|
|
if (isProtoString(e)) {
|
|
return e.slice(1)
|
|
}
|
|
return e
|
|
}
|
|
r.fromSetString = o ? identity : fromSetString
|
|
function isProtoString(e) {
|
|
if (!e) {
|
|
return false
|
|
}
|
|
var r = e.length
|
|
if (r < 9) {
|
|
return false
|
|
}
|
|
if (
|
|
e.charCodeAt(r - 1) !== 95 ||
|
|
e.charCodeAt(r - 2) !== 95 ||
|
|
e.charCodeAt(r - 3) !== 111 ||
|
|
e.charCodeAt(r - 4) !== 116 ||
|
|
e.charCodeAt(r - 5) !== 111 ||
|
|
e.charCodeAt(r - 6) !== 114 ||
|
|
e.charCodeAt(r - 7) !== 112 ||
|
|
e.charCodeAt(r - 8) !== 95 ||
|
|
e.charCodeAt(r - 9) !== 95
|
|
) {
|
|
return false
|
|
}
|
|
for (var n = r - 10; n >= 0; n--) {
|
|
if (e.charCodeAt(n) !== 36) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
function compareByOriginalPositions(e, r, n) {
|
|
var t = strcmp(e.source, r.source)
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
t = e.originalLine - r.originalLine
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
t = e.originalColumn - r.originalColumn
|
|
if (t !== 0 || n) {
|
|
return t
|
|
}
|
|
t = e.generatedColumn - r.generatedColumn
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
t = e.generatedLine - r.generatedLine
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
return strcmp(e.name, r.name)
|
|
}
|
|
r.compareByOriginalPositions = compareByOriginalPositions
|
|
function compareByGeneratedPositionsDeflated(e, r, n) {
|
|
var t = e.generatedLine - r.generatedLine
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
t = e.generatedColumn - r.generatedColumn
|
|
if (t !== 0 || n) {
|
|
return t
|
|
}
|
|
t = strcmp(e.source, r.source)
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
t = e.originalLine - r.originalLine
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
t = e.originalColumn - r.originalColumn
|
|
if (t !== 0) {
|
|
return t
|
|
}
|
|
return strcmp(e.name, r.name)
|
|
}
|
|
r.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated
|
|
function strcmp(e, r) {
|
|
if (e === r) {
|
|
return 0
|
|
}
|
|
if (e === null) {
|
|
return 1
|
|
}
|
|
if (r === null) {
|
|
return -1
|
|
}
|
|
if (e > r) {
|
|
return 1
|
|
}
|
|
return -1
|
|
}
|
|
function compareByGeneratedPositionsInflated(e, r) {
|
|
var n = e.generatedLine - r.generatedLine
|
|
if (n !== 0) {
|
|
return n
|
|
}
|
|
n = e.generatedColumn - r.generatedColumn
|
|
if (n !== 0) {
|
|
return n
|
|
}
|
|
n = strcmp(e.source, r.source)
|
|
if (n !== 0) {
|
|
return n
|
|
}
|
|
n = e.originalLine - r.originalLine
|
|
if (n !== 0) {
|
|
return n
|
|
}
|
|
n = e.originalColumn - r.originalColumn
|
|
if (n !== 0) {
|
|
return n
|
|
}
|
|
return strcmp(e.name, r.name)
|
|
}
|
|
r.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated
|
|
function parseSourceMapInput(e) {
|
|
return JSON.parse(e.replace(/^\)]}'[^\n]*\n/, ""))
|
|
}
|
|
r.parseSourceMapInput = parseSourceMapInput
|
|
function computeSourceURL(e, r, n) {
|
|
r = r || ""
|
|
if (e) {
|
|
if (e[e.length - 1] !== "/" && r[0] !== "/") {
|
|
e += "/"
|
|
}
|
|
r = e + r
|
|
}
|
|
if (n) {
|
|
var t = urlParse(n)
|
|
if (!t) {
|
|
throw new Error("sourceMapURL could not be parsed")
|
|
}
|
|
if (t.path) {
|
|
var o = t.path.lastIndexOf("/")
|
|
if (o >= 0) {
|
|
t.path = t.path.substring(0, o + 1)
|
|
}
|
|
}
|
|
r = join(urlGenerate(t), r)
|
|
}
|
|
return normalize(r)
|
|
}
|
|
r.computeSourceURL = computeSourceURL
|
|
},
|
|
997: (e, r, n) => {
|
|
n(591).h
|
|
r.SourceMapConsumer = n(952).SourceMapConsumer
|
|
n(351)
|
|
},
|
|
284: (e, r, n) => {
|
|
e = n.nmd(e)
|
|
var t = n(997).SourceMapConsumer
|
|
var o = n(17)
|
|
var i
|
|
try {
|
|
i = n(147)
|
|
if (!i.existsSync || !i.readFileSync) {
|
|
i = null
|
|
}
|
|
} catch (e) {}
|
|
var a = n(650)
|
|
function dynamicRequire(e, r) {
|
|
return e.require(r)
|
|
}
|
|
var u = false
|
|
var s = false
|
|
var l = false
|
|
var c = "auto"
|
|
var p = {}
|
|
var f = {}
|
|
var g = /^data:application\/json[^,]+base64,/
|
|
var h = []
|
|
var d = []
|
|
function isInBrowser() {
|
|
if (c === "browser") return true
|
|
if (c === "node") return false
|
|
return (
|
|
typeof window !== "undefined" &&
|
|
typeof XMLHttpRequest === "function" &&
|
|
!(window.require && window.module && window.process && window.process.type === "renderer")
|
|
)
|
|
}
|
|
function hasGlobalProcessEventEmitter() {
|
|
return typeof process === "object" && process !== null && typeof process.on === "function"
|
|
}
|
|
function globalProcessVersion() {
|
|
if (typeof process === "object" && process !== null) {
|
|
return process.version
|
|
} else {
|
|
return ""
|
|
}
|
|
}
|
|
function globalProcessStderr() {
|
|
if (typeof process === "object" && process !== null) {
|
|
return process.stderr
|
|
}
|
|
}
|
|
function globalProcessExit(e) {
|
|
if (typeof process === "object" && process !== null && typeof process.exit === "function") {
|
|
return process.exit(e)
|
|
}
|
|
}
|
|
function handlerExec(e) {
|
|
return function (r) {
|
|
for (var n = 0; n < e.length; n++) {
|
|
var t = e[n](r)
|
|
if (t) {
|
|
return t
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
}
|
|
var m = handlerExec(h)
|
|
h.push(function (e) {
|
|
e = e.trim()
|
|
if (/^file:/.test(e)) {
|
|
e = e.replace(/file:\/\/\/(\w:)?/, function (e, r) {
|
|
return r ? "" : "/"
|
|
})
|
|
}
|
|
if (e in p) {
|
|
return p[e]
|
|
}
|
|
var r = ""
|
|
try {
|
|
if (!i) {
|
|
var n = new XMLHttpRequest()
|
|
n.open("GET", e, false)
|
|
n.send(null)
|
|
if (n.readyState === 4 && n.status === 200) {
|
|
r = n.responseText
|
|
}
|
|
} else if (i.existsSync(e)) {
|
|
r = i.readFileSync(e, "utf8")
|
|
}
|
|
} catch (e) {}
|
|
return (p[e] = r)
|
|
})
|
|
function supportRelativeURL(e, r) {
|
|
if (!e) return r
|
|
var n = o.dirname(e)
|
|
var t = /^\w+:\/\/[^\/]*/.exec(n)
|
|
var i = t ? t[0] : ""
|
|
var a = n.slice(i.length)
|
|
if (i && /^\/\w\:/.test(a)) {
|
|
i += "/"
|
|
return i + o.resolve(n.slice(i.length), r).replace(/\\/g, "/")
|
|
}
|
|
return i + o.resolve(n.slice(i.length), r)
|
|
}
|
|
function retrieveSourceMapURL(e) {
|
|
var r
|
|
if (isInBrowser()) {
|
|
try {
|
|
var n = new XMLHttpRequest()
|
|
n.open("GET", e, false)
|
|
n.send(null)
|
|
r = n.readyState === 4 ? n.responseText : null
|
|
var t = n.getResponseHeader("SourceMap") || n.getResponseHeader("X-SourceMap")
|
|
if (t) {
|
|
return t
|
|
}
|
|
} catch (e) {}
|
|
}
|
|
r = m(e)
|
|
var o =
|
|
/(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/gm
|
|
var i, a
|
|
while ((a = o.exec(r))) i = a
|
|
if (!i) return null
|
|
return i[1]
|
|
}
|
|
var v = handlerExec(d)
|
|
d.push(function (e) {
|
|
var r = retrieveSourceMapURL(e)
|
|
if (!r) return null
|
|
var n
|
|
if (g.test(r)) {
|
|
var t = r.slice(r.indexOf(",") + 1)
|
|
n = a(t, "base64").toString()
|
|
r = e
|
|
} else {
|
|
r = supportRelativeURL(e, r)
|
|
n = m(r)
|
|
}
|
|
if (!n) {
|
|
return null
|
|
}
|
|
return { url: r, map: n }
|
|
})
|
|
function mapSourcePosition(e) {
|
|
var r = f[e.source]
|
|
if (!r) {
|
|
var n = v(e.source)
|
|
if (n) {
|
|
r = f[e.source] = { url: n.url, map: new t(n.map) }
|
|
if (r.map.sourcesContent) {
|
|
r.map.sources.forEach(function (e, n) {
|
|
var t = r.map.sourcesContent[n]
|
|
if (t) {
|
|
var o = supportRelativeURL(r.url, e)
|
|
p[o] = t
|
|
}
|
|
})
|
|
}
|
|
} else {
|
|
r = f[e.source] = { url: null, map: null }
|
|
}
|
|
}
|
|
if (r && r.map && typeof r.map.originalPositionFor === "function") {
|
|
var o = r.map.originalPositionFor(e)
|
|
if (o.source !== null) {
|
|
o.source = supportRelativeURL(r.url, o.source)
|
|
return o
|
|
}
|
|
}
|
|
return e
|
|
}
|
|
function mapEvalOrigin(e) {
|
|
var r = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(e)
|
|
if (r) {
|
|
var n = mapSourcePosition({ source: r[2], line: +r[3], column: r[4] - 1 })
|
|
return "eval at " + r[1] + " (" + n.source + ":" + n.line + ":" + (n.column + 1) + ")"
|
|
}
|
|
r = /^eval at ([^(]+) \((.+)\)$/.exec(e)
|
|
if (r) {
|
|
return "eval at " + r[1] + " (" + mapEvalOrigin(r[2]) + ")"
|
|
}
|
|
return e
|
|
}
|
|
function CallSiteToString() {
|
|
var e
|
|
var r = ""
|
|
if (this.isNative()) {
|
|
r = "native"
|
|
} else {
|
|
e = this.getScriptNameOrSourceURL()
|
|
if (!e && this.isEval()) {
|
|
r = this.getEvalOrigin()
|
|
r += ", "
|
|
}
|
|
if (e) {
|
|
r += e
|
|
} else {
|
|
r += "<anonymous>"
|
|
}
|
|
var n = this.getLineNumber()
|
|
if (n != null) {
|
|
r += ":" + n
|
|
var t = this.getColumnNumber()
|
|
if (t) {
|
|
r += ":" + t
|
|
}
|
|
}
|
|
}
|
|
var o = ""
|
|
var i = this.getFunctionName()
|
|
var a = true
|
|
var u = this.isConstructor()
|
|
var s = !(this.isToplevel() || u)
|
|
if (s) {
|
|
var l = this.getTypeName()
|
|
if (l === "[object Object]") {
|
|
l = "null"
|
|
}
|
|
var c = this.getMethodName()
|
|
if (i) {
|
|
if (l && i.indexOf(l) != 0) {
|
|
o += l + "."
|
|
}
|
|
o += i
|
|
if (c && i.indexOf("." + c) != i.length - c.length - 1) {
|
|
o += " [as " + c + "]"
|
|
}
|
|
} else {
|
|
o += l + "." + (c || "<anonymous>")
|
|
}
|
|
} else if (u) {
|
|
o += "new " + (i || "<anonymous>")
|
|
} else if (i) {
|
|
o += i
|
|
} else {
|
|
o += r
|
|
a = false
|
|
}
|
|
if (a) {
|
|
o += " (" + r + ")"
|
|
}
|
|
return o
|
|
}
|
|
function cloneCallSite(e) {
|
|
var r = {}
|
|
Object.getOwnPropertyNames(Object.getPrototypeOf(e)).forEach(function (n) {
|
|
r[n] = /^(?:is|get)/.test(n)
|
|
? function () {
|
|
return e[n].call(e)
|
|
}
|
|
: e[n]
|
|
})
|
|
r.toString = CallSiteToString
|
|
return r
|
|
}
|
|
function wrapCallSite(e, r) {
|
|
if (r === undefined) {
|
|
r = { nextPosition: null, curPosition: null }
|
|
}
|
|
if (e.isNative()) {
|
|
r.curPosition = null
|
|
return e
|
|
}
|
|
var n = e.getFileName() || e.getScriptNameOrSourceURL()
|
|
if (n) {
|
|
var t = e.getLineNumber()
|
|
var o = e.getColumnNumber() - 1
|
|
var i = /^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/
|
|
var a = i.test(globalProcessVersion()) ? 0 : 62
|
|
if (t === 1 && o > a && !isInBrowser() && !e.isEval()) {
|
|
o -= a
|
|
}
|
|
var u = mapSourcePosition({ source: n, line: t, column: o })
|
|
r.curPosition = u
|
|
e = cloneCallSite(e)
|
|
var s = e.getFunctionName
|
|
e.getFunctionName = function () {
|
|
if (r.nextPosition == null) {
|
|
return s()
|
|
}
|
|
return r.nextPosition.name || s()
|
|
}
|
|
e.getFileName = function () {
|
|
return u.source
|
|
}
|
|
e.getLineNumber = function () {
|
|
return u.line
|
|
}
|
|
e.getColumnNumber = function () {
|
|
return u.column + 1
|
|
}
|
|
e.getScriptNameOrSourceURL = function () {
|
|
return u.source
|
|
}
|
|
return e
|
|
}
|
|
var l = e.isEval() && e.getEvalOrigin()
|
|
if (l) {
|
|
l = mapEvalOrigin(l)
|
|
e = cloneCallSite(e)
|
|
e.getEvalOrigin = function () {
|
|
return l
|
|
}
|
|
return e
|
|
}
|
|
return e
|
|
}
|
|
function prepareStackTrace(e, r) {
|
|
if (l) {
|
|
p = {}
|
|
f = {}
|
|
}
|
|
var n = e.name || "Error"
|
|
var t = e.message || ""
|
|
var o = n + ": " + t
|
|
var i = { nextPosition: null, curPosition: null }
|
|
var a = []
|
|
for (var u = r.length - 1; u >= 0; u--) {
|
|
a.push("\n at " + wrapCallSite(r[u], i))
|
|
i.nextPosition = i.curPosition
|
|
}
|
|
i.curPosition = i.nextPosition = null
|
|
return o + a.reverse().join("")
|
|
}
|
|
function getErrorSource(e) {
|
|
var r = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(e.stack)
|
|
if (r) {
|
|
var n = r[1]
|
|
var t = +r[2]
|
|
var o = +r[3]
|
|
var a = p[n]
|
|
if (!a && i && i.existsSync(n)) {
|
|
try {
|
|
a = i.readFileSync(n, "utf8")
|
|
} catch (e) {
|
|
a = ""
|
|
}
|
|
}
|
|
if (a) {
|
|
var u = a.split(/(?:\r\n|\r|\n)/)[t - 1]
|
|
if (u) {
|
|
return n + ":" + t + "\n" + u + "\n" + new Array(o).join(" ") + "^"
|
|
}
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
function printErrorAndExit(e) {
|
|
var r = getErrorSource(e)
|
|
var n = globalProcessStderr()
|
|
if (n && n._handle && n._handle.setBlocking) {
|
|
n._handle.setBlocking(true)
|
|
}
|
|
if (r) {
|
|
console.error()
|
|
console.error(r)
|
|
}
|
|
console.error(e.stack)
|
|
globalProcessExit(1)
|
|
}
|
|
function shimEmitUncaughtException() {
|
|
var e = process.emit
|
|
process.emit = function (r) {
|
|
if (r === "uncaughtException") {
|
|
var n = arguments[1] && arguments[1].stack
|
|
var t = this.listeners(r).length > 0
|
|
if (n && !t) {
|
|
return printErrorAndExit(arguments[1])
|
|
}
|
|
}
|
|
return e.apply(this, arguments)
|
|
}
|
|
}
|
|
var S = h.slice(0)
|
|
var _ = d.slice(0)
|
|
r.wrapCallSite = wrapCallSite
|
|
r.getErrorSource = getErrorSource
|
|
r.mapSourcePosition = mapSourcePosition
|
|
r.retrieveSourceMap = v
|
|
r.install = function (r) {
|
|
r = r || {}
|
|
if (r.environment) {
|
|
c = r.environment
|
|
if (["node", "browser", "auto"].indexOf(c) === -1) {
|
|
throw new Error(
|
|
"environment " + c + " was unknown. Available options are {auto, browser, node}"
|
|
)
|
|
}
|
|
}
|
|
if (r.retrieveFile) {
|
|
if (r.overrideRetrieveFile) {
|
|
h.length = 0
|
|
}
|
|
h.unshift(r.retrieveFile)
|
|
}
|
|
if (r.retrieveSourceMap) {
|
|
if (r.overrideRetrieveSourceMap) {
|
|
d.length = 0
|
|
}
|
|
d.unshift(r.retrieveSourceMap)
|
|
}
|
|
if (r.hookRequire && !isInBrowser()) {
|
|
var n = dynamicRequire(e, "module")
|
|
var t = n.prototype._compile
|
|
if (!t.__sourceMapSupport) {
|
|
n.prototype._compile = function (e, r) {
|
|
p[r] = e
|
|
f[r] = undefined
|
|
return t.call(this, e, r)
|
|
}
|
|
n.prototype._compile.__sourceMapSupport = true
|
|
}
|
|
}
|
|
if (!l) {
|
|
l = "emptyCacheBetweenOperations" in r ? r.emptyCacheBetweenOperations : false
|
|
}
|
|
if (!u) {
|
|
u = true
|
|
Error.prepareStackTrace = prepareStackTrace
|
|
}
|
|
if (!s) {
|
|
var o = "handleUncaughtExceptions" in r ? r.handleUncaughtExceptions : true
|
|
try {
|
|
var i = dynamicRequire(e, "worker_threads")
|
|
if (i.isMainThread === false) {
|
|
o = false
|
|
}
|
|
} catch (e) {}
|
|
if (o && hasGlobalProcessEventEmitter()) {
|
|
s = true
|
|
shimEmitUncaughtException()
|
|
}
|
|
}
|
|
}
|
|
r.resetRetrieveHandlers = function () {
|
|
h.length = 0
|
|
d.length = 0
|
|
h = S.slice(0)
|
|
d = _.slice(0)
|
|
v = handlerExec(d)
|
|
m = handlerExec(h)
|
|
}
|
|
},
|
|
147: (e) => {
|
|
"use strict"
|
|
e.exports = require("fs")
|
|
},
|
|
17: (e) => {
|
|
"use strict"
|
|
e.exports = require("path")
|
|
},
|
|
}
|
|
var r = {}
|
|
function __webpack_require__(n) {
|
|
var t = r[n]
|
|
if (t !== undefined) {
|
|
return t.exports
|
|
}
|
|
var o = (r[n] = { id: n, loaded: false, exports: {} })
|
|
var i = true
|
|
try {
|
|
e[n](o, o.exports, __webpack_require__)
|
|
i = false
|
|
} finally {
|
|
if (i) delete r[n]
|
|
}
|
|
o.loaded = true
|
|
return o.exports
|
|
}
|
|
;(() => {
|
|
__webpack_require__.nmd = (e) => {
|
|
e.paths = []
|
|
if (!e.children) e.children = []
|
|
return e
|
|
}
|
|
})()
|
|
if (typeof __webpack_require__ !== "undefined") __webpack_require__.ab = __dirname + "/"
|
|
var n = {}
|
|
;(() => {
|
|
__webpack_require__(284).install()
|
|
})()
|
|
module.exports = n
|
|
})()
|