jamis
Version:
一种支持通过JSON配置方式生成页面的组件库
1,775 lines (1,772 loc) • 8.34 MB
JavaScript
/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/
var __defProp = Object.defineProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
// src/language/typescript/ts.worker.ts
import * as edworker from "../../editor/editor.worker.js";
// src/language/typescript/lib/typescriptServices.js
var typescriptServices_exports = {};
__export(typescriptServices_exports, {
EndOfLineState: () => EndOfLineState,
IndentStyle: () => IndentStyle,
ScriptKind: () => ScriptKind,
ScriptTarget: () => ScriptTarget,
TokenClass: () => TokenClass,
createClassifier: () => createClassifier,
createLanguageService: () => createLanguageService,
displayPartsToString: () => displayPartsToString,
flattenDiagnosticMessageText: () => flattenDiagnosticMessageText,
typescript: () => typescript
});
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));
};
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 __makeTemplateObject = function(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
} else {
cooked.raw = raw;
}
return cooked;
};
var __generator = function(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1)
throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __rest = function(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
var __extends = function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2)
if (Object.prototype.hasOwnProperty.call(b2, p))
d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
(function(ts2) {
function createMapData() {
var sentinel = {};
sentinel.prev = sentinel;
return { head: sentinel, tail: sentinel, size: 0 };
}
function createMapEntry(key, value) {
return { key, value, next: void 0, prev: void 0 };
}
function sameValueZero(x, y) {
return x === y || x !== x && y !== y;
}
function getPrev(entry) {
var prev = entry.prev;
if (!prev || prev === entry)
throw new Error("Illegal state");
return prev;
}
function getNext(entry) {
while (entry) {
var skipNext = !entry.prev;
entry = entry.next;
if (skipNext) {
continue;
}
return entry;
}
}
function getEntry(data, key) {
for (var entry = data.tail; entry !== data.head; entry = getPrev(entry)) {
if (sameValueZero(entry.key, key)) {
return entry;
}
}
}
function addOrUpdateEntry(data, key, value) {
var existing = getEntry(data, key);
if (existing) {
existing.value = value;
return;
}
var entry = createMapEntry(key, value);
entry.prev = data.tail;
data.tail.next = entry;
data.tail = entry;
data.size++;
return entry;
}
function deleteEntry(data, key) {
for (var entry = data.tail; entry !== data.head; entry = getPrev(entry)) {
if (entry.prev === void 0)
throw new Error("Illegal state");
if (sameValueZero(entry.key, key)) {
if (entry.next) {
entry.next.prev = entry.prev;
} else {
if (data.tail !== entry)
throw new Error("Illegal state");
data.tail = entry.prev;
}
entry.prev.next = entry.next;
entry.next = entry.prev;
entry.prev = void 0;
data.size--;
return entry;
}
}
}
function clearEntries(data) {
var node = data.tail;
while (node !== data.head) {
var prev = getPrev(node);
node.next = data.head;
node.prev = void 0;
node = prev;
}
data.head.next = void 0;
data.tail = data.head;
data.size = 0;
}
function forEachEntry(data, action) {
var entry = data.head;
while (entry) {
entry = getNext(entry);
if (entry) {
action(entry.value, entry.key);
}
}
}
function forEachIteration(iterator, action) {
if (iterator) {
for (var step = iterator.next(); !step.done; step = iterator.next()) {
action(step.value);
}
}
}
function createIteratorData(data, selector) {
return { current: data.head, selector };
}
function iteratorNext(data) {
data.current = getNext(data.current);
if (data.current) {
return { value: data.selector(data.current.key, data.current.value), done: false };
} else {
return { value: void 0, done: true };
}
}
var ShimCollections;
(function(ShimCollections2) {
function createMapShim(getIterator) {
var MapIterator = function() {
function MapIterator2(data, selector) {
this._data = createIteratorData(data, selector);
}
MapIterator2.prototype.next = function() {
return iteratorNext(this._data);
};
return MapIterator2;
}();
return function() {
function Map2(iterable) {
var _this = this;
this._mapData = createMapData();
forEachIteration(getIterator(iterable), function(_a) {
var key = _a[0], value = _a[1];
return _this.set(key, value);
});
}
Object.defineProperty(Map2.prototype, "size", {
get: function() {
return this._mapData.size;
},
enumerable: false,
configurable: true
});
Map2.prototype.get = function(key) {
var _a;
return (_a = getEntry(this._mapData, key)) === null || _a === void 0 ? void 0 : _a.value;
};
Map2.prototype.set = function(key, value) {
return addOrUpdateEntry(this._mapData, key, value), this;
};
Map2.prototype.has = function(key) {
return !!getEntry(this._mapData, key);
};
Map2.prototype.delete = function(key) {
return !!deleteEntry(this._mapData, key);
};
Map2.prototype.clear = function() {
clearEntries(this._mapData);
};
Map2.prototype.keys = function() {
return new MapIterator(this._mapData, function(key, _value) {
return key;
});
};
Map2.prototype.values = function() {
return new MapIterator(this._mapData, function(_key, value) {
return value;
});
};
Map2.prototype.entries = function() {
return new MapIterator(this._mapData, function(key, value) {
return [key, value];
});
};
Map2.prototype.forEach = function(action) {
forEachEntry(this._mapData, action);
};
return Map2;
}();
}
ShimCollections2.createMapShim = createMapShim;
function createSetShim(getIterator) {
var SetIterator = function() {
function SetIterator2(data, selector) {
this._data = createIteratorData(data, selector);
}
SetIterator2.prototype.next = function() {
return iteratorNext(this._data);
};
return SetIterator2;
}();
return function() {
function Set2(iterable) {
var _this = this;
this._mapData = createMapData();
forEachIteration(getIterator(iterable), function(value) {
return _this.add(value);
});
}
Object.defineProperty(Set2.prototype, "size", {
get: function() {
return this._mapData.size;
},
enumerable: false,
configurable: true
});
Set2.prototype.add = function(value) {
return addOrUpdateEntry(this._mapData, value, value), this;
};
Set2.prototype.has = function(value) {
return !!getEntry(this._mapData, value);
};
Set2.prototype.delete = function(value) {
return !!deleteEntry(this._mapData, value);
};
Set2.prototype.clear = function() {
clearEntries(this._mapData);
};
Set2.prototype.keys = function() {
return new SetIterator(this._mapData, function(key, _value) {
return key;
});
};
Set2.prototype.values = function() {
return new SetIterator(this._mapData, function(_key, value) {
return value;
});
};
Set2.prototype.entries = function() {
return new SetIterator(this._mapData, function(key, value) {
return [key, value];
});
};
Set2.prototype.forEach = function(action) {
forEachEntry(this._mapData, action);
};
return Set2;
}();
}
ShimCollections2.createSetShim = createSetShim;
})(ShimCollections = ts2.ShimCollections || (ts2.ShimCollections = {}));
})(ts || (ts = {}));
(function(ts2) {
ts2.versionMajorMinor = "4.5";
ts2.version = "4.5.5";
var Comparison;
(function(Comparison2) {
Comparison2[Comparison2["LessThan"] = -1] = "LessThan";
Comparison2[Comparison2["EqualTo"] = 0] = "EqualTo";
Comparison2[Comparison2["GreaterThan"] = 1] = "GreaterThan";
})(Comparison = ts2.Comparison || (ts2.Comparison = {}));
var NativeCollections;
(function(NativeCollections2) {
function tryGetNativeMap() {
return typeof Map !== "undefined" && "entries" in Map.prototype && (/* @__PURE__ */ new Map([[0, 0]])).size === 1 ? Map : void 0;
}
NativeCollections2.tryGetNativeMap = tryGetNativeMap;
function tryGetNativeSet() {
return typeof Set !== "undefined" && "entries" in Set.prototype && (/* @__PURE__ */ new Set([0])).size === 1 ? Set : void 0;
}
NativeCollections2.tryGetNativeSet = tryGetNativeSet;
})(NativeCollections || (NativeCollections = {}));
ts2.Map = getCollectionImplementation("Map", "tryGetNativeMap", "createMapShim");
ts2.Set = getCollectionImplementation("Set", "tryGetNativeSet", "createSetShim");
function getCollectionImplementation(name, nativeFactory, shimFactory) {
var _a;
var constructor = (_a = NativeCollections[nativeFactory]()) !== null && _a !== void 0 ? _a : ts2.ShimCollections === null || ts2.ShimCollections === void 0 ? void 0 : ts2.ShimCollections[shimFactory](ts2.getIterator);
if (constructor)
return constructor;
throw new Error("TypeScript requires an environment that provides a compatible native ".concat(name, " implementation."));
}
})(ts || (ts = {}));
(function(ts2) {
function getIterator(iterable) {
if (iterable) {
if (isArray(iterable))
return arrayIterator(iterable);
if (iterable instanceof ts2.Map)
return iterable.entries();
if (iterable instanceof ts2.Set)
return iterable.values();
throw new Error("Iteration not supported.");
}
}
ts2.getIterator = getIterator;
ts2.emptyArray = [];
ts2.emptyMap = new ts2.Map();
ts2.emptySet = new ts2.Set();
function createMap() {
return new ts2.Map();
}
ts2.createMap = createMap;
function createMapFromTemplate(template) {
var map2 = new ts2.Map();
for (var key in template) {
if (hasOwnProperty.call(template, key)) {
map2.set(key, template[key]);
}
}
return map2;
}
ts2.createMapFromTemplate = createMapFromTemplate;
function length(array) {
return array ? array.length : 0;
}
ts2.length = length;
function forEach(array, callback) {
if (array) {
for (var i = 0; i < array.length; i++) {
var result = callback(array[i], i);
if (result) {
return result;
}
}
}
return void 0;
}
ts2.forEach = forEach;
function forEachRight(array, callback) {
if (array) {
for (var i = array.length - 1; i >= 0; i--) {
var result = callback(array[i], i);
if (result) {
return result;
}
}
}
return void 0;
}
ts2.forEachRight = forEachRight;
function firstDefined(array, callback) {
if (array === void 0) {
return void 0;
}
for (var i = 0; i < array.length; i++) {
var result = callback(array[i], i);
if (result !== void 0) {
return result;
}
}
return void 0;
}
ts2.firstDefined = firstDefined;
function firstDefinedIterator(iter, callback) {
while (true) {
var iterResult = iter.next();
if (iterResult.done) {
return void 0;
}
var result = callback(iterResult.value);
if (result !== void 0) {
return result;
}
}
}
ts2.firstDefinedIterator = firstDefinedIterator;
function reduceLeftIterator(iterator, f, initial) {
var result = initial;
if (iterator) {
for (var step = iterator.next(), pos = 0; !step.done; step = iterator.next(), pos++) {
result = f(result, step.value, pos);
}
}
return result;
}
ts2.reduceLeftIterator = reduceLeftIterator;
function zipWith(arrayA, arrayB, callback) {
var result = [];
ts2.Debug.assertEqual(arrayA.length, arrayB.length);
for (var i = 0; i < arrayA.length; i++) {
result.push(callback(arrayA[i], arrayB[i], i));
}
return result;
}
ts2.zipWith = zipWith;
function zipToIterator(arrayA, arrayB) {
ts2.Debug.assertEqual(arrayA.length, arrayB.length);
var i = 0;
return {
next: function() {
if (i === arrayA.length) {
return { value: void 0, done: true };
}
i++;
return { value: [arrayA[i - 1], arrayB[i - 1]], done: false };
}
};
}
ts2.zipToIterator = zipToIterator;
function zipToMap(keys, values) {
ts2.Debug.assert(keys.length === values.length);
var map2 = new ts2.Map();
for (var i = 0; i < keys.length; ++i) {
map2.set(keys[i], values[i]);
}
return map2;
}
ts2.zipToMap = zipToMap;
function intersperse(input, element) {
if (input.length <= 1) {
return input;
}
var result = [];
for (var i = 0, n = input.length; i < n; i++) {
if (i)
result.push(element);
result.push(input[i]);
}
return result;
}
ts2.intersperse = intersperse;
function every(array, callback) {
if (array) {
for (var i = 0; i < array.length; i++) {
if (!callback(array[i], i)) {
return false;
}
}
}
return true;
}
ts2.every = every;
function find(array, predicate) {
for (var i = 0; i < array.length; i++) {
var value = array[i];
if (predicate(value, i)) {
return value;
}
}
return void 0;
}
ts2.find = find;
function findLast(array, predicate) {
for (var i = array.length - 1; i >= 0; i--) {
var value = array[i];
if (predicate(value, i)) {
return value;
}
}
return void 0;
}
ts2.findLast = findLast;
function findIndex(array, predicate, startIndex) {
for (var i = startIndex || 0; i < array.length; i++) {
if (predicate(array[i], i)) {
return i;
}
}
return -1;
}
ts2.findIndex = findIndex;
function findLastIndex(array, predicate, startIndex) {
for (var i = startIndex === void 0 ? array.length - 1 : startIndex; i >= 0; i--) {
if (predicate(array[i], i)) {
return i;
}
}
return -1;
}
ts2.findLastIndex = findLastIndex;
function findMap(array, callback) {
for (var i = 0; i < array.length; i++) {
var result = callback(array[i], i);
if (result) {
return result;
}
}
return ts2.Debug.fail();
}
ts2.findMap = findMap;
function contains(array, value, equalityComparer) {
if (equalityComparer === void 0) {
equalityComparer = equateValues;
}
if (array) {
for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
var v = array_1[_i];
if (equalityComparer(v, value)) {
return true;
}
}
}
return false;
}
ts2.contains = contains;
function arraysEqual(a, b, equalityComparer) {
if (equalityComparer === void 0) {
equalityComparer = equateValues;
}
return a.length === b.length && a.every(function(x, i) {
return equalityComparer(x, b[i]);
});
}
ts2.arraysEqual = arraysEqual;
function indexOfAnyCharCode(text, charCodes, start) {
for (var i = start || 0; i < text.length; i++) {
if (contains(charCodes, text.charCodeAt(i))) {
return i;
}
}
return -1;
}
ts2.indexOfAnyCharCode = indexOfAnyCharCode;
function countWhere(array, predicate) {
var count = 0;
if (array) {
for (var i = 0; i < array.length; i++) {
var v = array[i];
if (predicate(v, i)) {
count++;
}
}
}
return count;
}
ts2.countWhere = countWhere;
function filter(array, f) {
if (array) {
var len = array.length;
var i = 0;
while (i < len && f(array[i]))
i++;
if (i < len) {
var result = array.slice(0, i);
i++;
while (i < len) {
var item = array[i];
if (f(item)) {
result.push(item);
}
i++;
}
return result;
}
}
return array;
}
ts2.filter = filter;
function filterMutate(array, f) {
var outIndex = 0;
for (var i = 0; i < array.length; i++) {
if (f(array[i], i, array)) {
array[outIndex] = array[i];
outIndex++;
}
}
array.length = outIndex;
}
ts2.filterMutate = filterMutate;
function clear(array) {
array.length = 0;
}
ts2.clear = clear;
function map(array, f) {
var result;
if (array) {
result = [];
for (var i = 0; i < array.length; i++) {
result.push(f(array[i], i));
}
}
return result;
}
ts2.map = map;
function mapIterator(iter, mapFn) {
return {
next: function() {
var iterRes = iter.next();
return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false };
}
};
}
ts2.mapIterator = mapIterator;
function sameMap(array, f) {
if (array) {
for (var i = 0; i < array.length; i++) {
var item = array[i];
var mapped = f(item, i);
if (item !== mapped) {
var result = array.slice(0, i);
result.push(mapped);
for (i++; i < array.length; i++) {
result.push(f(array[i], i));
}
return result;
}
}
}
return array;
}
ts2.sameMap = sameMap;
function flatten(array) {
var result = [];
for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
var v = array_2[_i];
if (v) {
if (isArray(v)) {
addRange(result, v);
} else {
result.push(v);
}
}
}
return result;
}
ts2.flatten = flatten;
function flatMap(array, mapfn) {
var result;
if (array) {
for (var i = 0; i < array.length; i++) {
var v = mapfn(array[i], i);
if (v) {
if (isArray(v)) {
result = addRange(result, v);
} else {
result = append(result, v);
}
}
}
}
return result || ts2.emptyArray;
}
ts2.flatMap = flatMap;
function flatMapToMutable(array, mapfn) {
var result = [];
if (array) {
for (var i = 0; i < array.length; i++) {
var v = mapfn(array[i], i);
if (v) {
if (isArray(v)) {
addRange(result, v);
} else {
result.push(v);
}
}
}
}
return result;
}
ts2.flatMapToMutable = flatMapToMutable;
function flatMapIterator(iter, mapfn) {
var first2 = iter.next();
if (first2.done) {
return ts2.emptyIterator;
}
var currentIter = getIterator2(first2.value);
return {
next: function() {
while (true) {
var currentRes = currentIter.next();
if (!currentRes.done) {
return currentRes;
}
var iterRes = iter.next();
if (iterRes.done) {
return iterRes;
}
currentIter = getIterator2(iterRes.value);
}
}
};
function getIterator2(x) {
var res = mapfn(x);
return res === void 0 ? ts2.emptyIterator : isArray(res) ? arrayIterator(res) : res;
}
}
ts2.flatMapIterator = flatMapIterator;
function sameFlatMap(array, mapfn) {
var result;
if (array) {
for (var i = 0; i < array.length; i++) {
var item = array[i];
var mapped = mapfn(item, i);
if (result || item !== mapped || isArray(mapped)) {
if (!result) {
result = array.slice(0, i);
}
if (isArray(mapped)) {
addRange(result, mapped);
} else {
result.push(mapped);
}
}
}
}
return result || array;
}
ts2.sameFlatMap = sameFlatMap;
function mapAllOrFail(array, mapFn) {
var result = [];
for (var i = 0; i < array.length; i++) {
var mapped = mapFn(array[i], i);
if (mapped === void 0) {
return void 0;
}
result.push(mapped);
}
return result;
}
ts2.mapAllOrFail = mapAllOrFail;
function mapDefined(array, mapFn) {
var result = [];
if (array) {
for (var i = 0; i < array.length; i++) {
var mapped = mapFn(array[i], i);
if (mapped !== void 0) {
result.push(mapped);
}
}
}
return result;
}
ts2.mapDefined = mapDefined;
function mapDefinedIterator(iter, mapFn) {
return {
next: function() {
while (true) {
var res = iter.next();
if (res.done) {
return res;
}
var value = mapFn(res.value);
if (value !== void 0) {
return { value, done: false };
}
}
}
};
}
ts2.mapDefinedIterator = mapDefinedIterator;
function mapDefinedEntries(map2, f) {
if (!map2) {
return void 0;
}
var result = new ts2.Map();
map2.forEach(function(value, key) {
var entry = f(key, value);
if (entry !== void 0) {
var newKey = entry[0], newValue = entry[1];
if (newKey !== void 0 && newValue !== void 0) {
result.set(newKey, newValue);
}
}
});
return result;
}
ts2.mapDefinedEntries = mapDefinedEntries;
function mapDefinedValues(set, f) {
if (set) {
var result_1 = new ts2.Set();
set.forEach(function(value) {
var newValue = f(value);
if (newValue !== void 0) {
result_1.add(newValue);
}
});
return result_1;
}
}
ts2.mapDefinedValues = mapDefinedValues;
function getOrUpdate(map2, key, callback) {
if (map2.has(key)) {
return map2.get(key);
}
var value = callback();
map2.set(key, value);
return value;
}
ts2.getOrUpdate = getOrUpdate;
function tryAddToSet(set, value) {
if (!set.has(value)) {
set.add(value);
return true;
}
return false;
}
ts2.tryAddToSet = tryAddToSet;
ts2.emptyIterator = { next: function() {
return { value: void 0, done: true };
} };
function singleIterator(value) {
var done = false;
return {
next: function() {
var wasDone = done;
done = true;
return wasDone ? { value: void 0, done: true } : { value, done: false };
}
};
}
ts2.singleIterator = singleIterator;
function spanMap(array, keyfn, mapfn) {
var result;
if (array) {
result = [];
var len = array.length;
var previousKey = void 0;
var key = void 0;
var start = 0;
var pos = 0;
while (start < len) {
while (pos < len) {
var value = array[pos];
key = keyfn(value, pos);
if (pos === 0) {
previousKey = key;
} else if (key !== previousKey) {
break;
}
pos++;
}
if (start < pos) {
var v = mapfn(array.slice(start, pos), previousKey, start, pos);
if (v) {
result.push(v);
}
start = pos;
}
previousKey = key;
pos++;
}
}
return result;
}
ts2.spanMap = spanMap;
function mapEntries(map2, f) {
if (!map2) {
return void 0;
}
var result = new ts2.Map();
map2.forEach(function(value, key) {
var _a = f(key, value), newKey = _a[0], newValue = _a[1];
result.set(newKey, newValue);
});
return result;
}
ts2.mapEntries = mapEntries;
function some(array, predicate) {
if (array) {
if (predicate) {
for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
var v = array_3[_i];
if (predicate(v)) {
return true;
}
}
} else {
return array.length > 0;
}
}
return false;
}
ts2.some = some;
function getRangesWhere(arr, pred, cb) {
var start;
for (var i = 0; i < arr.length; i++) {
if (pred(arr[i])) {
start = start === void 0 ? i : start;
} else {
if (start !== void 0) {
cb(start, i);
start = void 0;
}
}
}
if (start !== void 0)
cb(start, arr.length);
}
ts2.getRangesWhere = getRangesWhere;
function concatenate(array1, array2) {
if (!some(array2))
return array1;
if (!some(array1))
return array2;
return __spreadArray(__spreadArray([], array1, true), array2, true);
}
ts2.concatenate = concatenate;
function selectIndex(_, i) {
return i;
}
function indicesOf(array) {
return array.map(selectIndex);
}
ts2.indicesOf = indicesOf;
function deduplicateRelational(array, equalityComparer, comparer) {
var indices = indicesOf(array);
stableSortIndices(array, indices, comparer);
var last2 = array[indices[0]];
var deduplicated = [indices[0]];
for (var i = 1; i < indices.length; i++) {
var index = indices[i];
var item = array[index];
if (!equalityComparer(last2, item)) {
deduplicated.push(index);
last2 = item;
}
}
deduplicated.sort();
return deduplicated.map(function(i2) {
return array[i2];
});
}
function deduplicateEquality(array, equalityComparer) {
var result = [];
for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {
var item = array_4[_i];
pushIfUnique(result, item, equalityComparer);
}
return result;
}
function deduplicate(array, equalityComparer, comparer) {
return array.length === 0 ? [] : array.length === 1 ? array.slice() : comparer ? deduplicateRelational(array, equalityComparer, comparer) : deduplicateEquality(array, equalityComparer);
}
ts2.deduplicate = deduplicate;
function deduplicateSorted(array, comparer) {
if (array.length === 0)
return ts2.emptyArray;
var last2 = array[0];
var deduplicated = [last2];
for (var i = 1; i < array.length; i++) {
var next = array[i];
switch (comparer(next, last2)) {
case true:
case 0:
continue;
case -1:
return ts2.Debug.fail("Array is unsorted.");
}
deduplicated.push(last2 = next);
}
return deduplicated;
}
function insertSorted(array, insert, compare) {
if (array.length === 0) {
array.push(insert);
return;
}
var insertIndex = binarySearch(array, insert, identity, compare);
if (insertIndex < 0) {
array.splice(~insertIndex, 0, insert);
}
}
ts2.insertSorted = insertSorted;
function sortAndDeduplicate(array, comparer, equalityComparer) {
return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive);
}
ts2.sortAndDeduplicate = sortAndDeduplicate;
function arrayIsSorted(array, comparer) {
if (array.length < 2)
return true;
var prevElement = array[0];
for (var _i = 0, _a = array.slice(1); _i < _a.length; _i++) {
var element = _a[_i];
if (comparer(prevElement, element) === 1) {
return false;
}
prevElement = element;
}
return true;
}
ts2.arrayIsSorted = arrayIsSorted;
function arrayIsEqualTo(array1, array2, equalityComparer) {
if (equalityComparer === void 0) {
equalityComparer = equateValues;
}
if (!array1 || !array2) {
return array1 === array2;
}
if (array1.length !== array2.length) {
return false;
}
for (var i = 0; i < array1.length; i++) {
if (!equalityComparer(array1[i], array2[i], i)) {
return false;
}
}
return true;
}
ts2.arrayIsEqualTo = arrayIsEqualTo;
function compact(array) {
var result;
if (array) {
for (var i = 0; i < array.length; i++) {
var v = array[i];
if (result || !v) {
if (!result) {
result = array.slice(0, i);
}
if (v) {
result.push(v);
}
}
}
}
return result || array;
}
ts2.compact = compact;
function relativeComplement(arrayA, arrayB, comparer) {
if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0)
return arrayB;
var result = [];
loopB:
for (var offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) {
if (offsetB > 0) {
ts2.Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 0);
}
loopA:
for (var startA = offsetA; offsetA < arrayA.length; offsetA++) {
if (offsetA > startA) {
ts2.Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 0);
}
switch (comparer(arrayB[offsetB], arrayA[offsetA])) {
case -1:
result.push(arrayB[offsetB]);
continue loopB;
case 0:
continue loopB;
case 1:
continue loopA;
}
}
}
return result;
}
ts2.relativeComplement = relativeComplement;
function sum(array, prop) {
var result = 0;
for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {
var v = array_5[_i];
result += v[prop];
}
return result;
}
ts2.sum = sum;
function append(to, value) {
if (value === void 0)
return to;
if (to === void 0)
return [value];
to.push(value);
return to;
}
ts2.append = append;
function combine(xs, ys) {
if (xs === void 0)
return ys;
if (ys === void 0)
return xs;
if (isArray(xs))
return isArray(ys) ? concatenate(xs, ys) : append(xs, ys);
if (isArray(ys))
return append(ys, xs);
return [xs, ys];
}
ts2.combine = combine;
function toOffset(array, offset) {
return offset < 0 ? array.length + offset : offset;
}
function addRange(to, from, start, end) {
if (from === void 0 || from.length === 0)
return to;
if (to === void 0)
return from.slice(start, end);
start = start === void 0 ? 0 : toOffset(from, start);
end = end === void 0 ? from.length : toOffset(from, end);
for (var i = start; i < end && i < from.length; i++) {
if (from[i] !== void 0) {
to.push(from[i]);
}
}
return to;
}
ts2.addRange = addRange;
function pushIfUnique(array, toAdd, equalityComparer) {
if (contains(array, toAdd, equalityComparer)) {
return false;
} else {
array.push(toAdd);
return true;
}
}
ts2.pushIfUnique = pushIfUnique;
function appendIfUnique(array, toAdd, equalityComparer) {
if (array) {
pushIfUnique(array, toAdd, equalityComparer);
return array;
} else {
return [toAdd];
}
}
ts2.appendIfUnique = appendIfUnique;
function stableSortIndices(array, indices, comparer) {
indices.sort(function(x, y) {
return comparer(array[x], array[y]) || compareValues(x, y);
});
}
function sort(array, comparer) {
return array.length === 0 ? array : array.slice().sort(comparer);
}
ts2.sort = sort;
function arrayIterator(array) {
var i = 0;
return { next: function() {
if (i === array.length) {
return { value: void 0, done: true };
} else {
i++;
return { value: array[i - 1], done: false };
}
} };
}
ts2.arrayIterator = arrayIterator;
function arrayReverseIterator(array) {
var i = array.length;
return {
next: function() {
if (i === 0) {
return { value: void 0, done: true };
} else {
i--;
return { value: array[i], done: false };
}
}
};
}
ts2.arrayReverseIterator = arrayReverseIterator;
function stableSort(array, comparer) {
var indices = indicesOf(array);
stableSortIndices(array, indices, comparer);
return indices.map(function(i) {
return array[i];
});
}
ts2.stableSort = stableSort;
function rangeEquals(array1, array2, pos, end) {
while (pos < end) {
if (array1[pos] !== array2[pos]) {
return false;
}
pos++;
}
return true;
}
ts2.rangeEquals = rangeEquals;
function elementAt(array, offset) {
if (array) {
offset = toOffset(array, offset);
if (offset < array.length) {
return array[offset];
}
}
return void 0;
}
ts2.elementAt = elementAt;
function firstOrUndefined(array) {
return array.length === 0 ? void 0 : array[0];
}
ts2.firstOrUndefined = firstOrUndefined;
function first(array) {
ts2.Debug.assert(array.length !== 0);
return array[0];
}
ts2.first = first;
function lastOrUndefined(array) {
return array.length === 0 ? void 0 : array[array.length - 1];
}
ts2.lastOrUndefined = lastOrUndefined;
function last(array) {
ts2.Debug.assert(array.length !== 0);
return array[array.length - 1];
}
ts2.last = last;
function singleOrUndefined(array) {
return array && array.length === 1 ? array[0] : void 0;
}
ts2.singleOrUndefined = singleOrUndefined;
function singleOrMany(array) {
return array && array.length === 1 ? array[0] : array;
}
ts2.singleOrMany = singleOrMany;
function replaceElement(array, index, value) {
var result = array.slice(0);
result[index] = value;
return result;
}
ts2.replaceElement = replaceElement;
function binarySearch(array, value, keySelector, keyComparer, offset) {
return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset);
}
ts2.binarySearch = binarySearch;
function binarySearchKey(array, key, keySelector, keyComparer, offset) {
if (!some(array)) {
return -1;
}
var low = offset || 0;
var high = array.length - 1;
while (low <= high) {
var middle = low + (high - low >> 1);
var midKey = keySelector(array[middle], middle);
switch (keyComparer(midKey, key)) {
case -1:
low = middle + 1;
break;
case 0:
return middle;
case 1:
high = middle - 1;
break;
}
}
return ~low;
}
ts2.binarySearchKey = binarySearchKey;
function reduceLeft(array, f, initial, start, count) {
if (array && array.length > 0) {
var size = array.length;
if (size > 0) {
var pos = start === void 0 || start < 0 ? 0 : start;
var end = count === void 0 || pos + count > size - 1 ? size - 1 : pos + count;
var result = void 0;
if (arguments.length <= 2) {
result = array[pos];
pos++;
} else {
result = initial;
}
while (pos <= end) {
result = f(result, array[pos], pos);
pos++;
}
return result;
}
}
return initial;
}
ts2.reduceLeft = reduceLeft;
var hasOwnProperty = Object.prototype.hasOwnProperty;
function hasProperty(map2, key) {
return hasOwnProperty.call(map2, key);
}
ts2.hasProperty = hasProperty;
function getProperty(map2, key) {
return hasOwnProperty.call(map2, key) ? map2[key] : void 0;
}
ts2.getProperty = getProperty;
function getOwnKeys(map2) {
var keys = [];
for (var key in map2) {
if (hasOwnProperty.call(map2, key)) {
keys.push(key);
}
}
return keys;
}
ts2.getOwnKeys = getOwnKeys;
function getAllKeys(obj) {
var result = [];
do {
var names = Object.getOwnPropertyNames(obj);
for (var _i = 0, names_1 = names; _i < names_1.length; _i++) {
var name = names_1[_i];
pushIfUnique(result, name);
}
} while (obj = Object.getPrototypeOf(obj));
return result;
}
ts2.getAllKeys = getAllKeys;
function getOwnValues(sparseArray) {
var values = [];
for (var key in sparseArray) {
if (hasOwnProperty.call(sparseArray, key)) {
values.push(sparseArray[key]);
}
}
return values;
}
ts2.getOwnValues = getOwnValues;
var _entries = Object.entries || function(obj) {
var keys = getOwnKeys(obj);
var result = Array(keys.length);
for (var i = 0; i < keys.length; i++) {
result[i] = [keys[i], obj[keys[i]]];
}
return result;
};
function getEntries(obj) {
return obj ? _entries(obj) : [];
}
ts2.getEntries = getEntries;
function arrayOf(count, f) {
var result = new Array(count);
for (var i = 0; i < count; i++) {
result[i] = f(i);
}
return result;
}
ts2.arrayOf = arrayOf;
function arrayFrom(iterator, map2) {
var result = [];
for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
result.push(map2 ? map2(iterResult.value) : iterResult.value);
}
return result;
}
ts2.arrayFrom = arrayFrom;
function assign(t) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
var arg = args_1[_a];
if (arg === void 0)
continue;
for (var p in arg) {
if (hasProperty(arg, p)) {
t[p] = arg[p];
}
}
}
return t;
}
ts2.assign = assign;
function equalOwnProperties(left, right, equalityComparer) {
if (equalityComparer === void 0) {
equalityComparer = equateValues;
}
if (left === right)
return true;
if (!left || !right)
return false;
for (var key in left) {
if (hasOwnProperty.call(left, key)) {
if (!hasOwnProperty.call(right, key))
return false;
if (!equalityComparer(left[key], right[key]))
return false;
}
}
for (var key in right) {
if (hasOwnProperty.call(right, key)) {
if (!hasOwnProperty.call(left, key))
return false;
}
}
return true;
}
ts2.equalOwnProperties = equalOwnProperties;
function arrayToMap(array, makeKey, makeValue) {
if (makeValue === void 0) {
makeValue = identity;
}
var result = new ts2.Map();
for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
var value = array_6[_i];
var key = makeKey(value);
if (key !== void 0)
result.set(key, makeValue(value));
}
return result;
}
ts2.arrayToMap = arrayToMap;
function arrayToNumericMap(array, makeKey, makeValue) {
if (makeValue === void 0) {
makeValue = identity;
}
var result = [];
for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
var value = array_7[_i];
result[makeKey(value)] = makeValue(value);
}
return result;
}
ts2.arrayToNumericMap = arrayToNumericMap;
function arrayToMultiMap(values, makeKey, makeValue) {
if (makeValue === void 0) {
makeValue = identity;
}
var result = createMultiMap();
for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
var value = values_1[_i];
result.add(makeKey(value), makeValue(value));
}
return result;
}
ts2.arrayToMultiMap = arrayToMultiMap;
function group(values, getGroupId, resultSelector) {
if (resultSelector === void 0) {
resultSelector = identity;
}
return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector);
}
ts2.group = group;
function clone(object) {
var result = {};
for (var id in object) {
if (hasOwnProperty.call(object, id)) {
result[id] = object[id];
}
}
return result;
}
ts2.clone = clone;
function extend(first2, second) {
var result = {};
for (var id in second) {
if (hasOwnProperty.call(second, id)) {
result[id] = second[id];
}
}
for (var id in first2) {
if (hasOwnProperty.call(first2, id)) {
result[id] = first2[id];
}
}
return result;
}
ts2.extend = extend;
function copyProperties(first2, second) {
for (var id in second) {
if (hasOwnProperty.call(second, id)) {
first2[id] = second[id];
}
}
}
ts2.copyProperties = copyProperties;
function maybeBind(obj, fn) {
return fn ? fn.bind(obj) : void 0;
}
ts2.maybeBind = maybeBind;
function createMultiMap() {
var map2 = new ts2.Map();
map2.add = multiMapAdd;
map2.remove = multiMapRemove;
return map2;
}
ts2.createMultiMap = createMultiMap;
function multiMapAdd(key, value) {
var values = this.get(key);
if (values) {
values.push(value);
} else {
this.set(key, values = [value]);
}
return values;
}
function multiMapRemove(key, value) {
var values = this.get(key);
if (values) {
unorderedRemoveItem(values, value);
if (!values.length) {
this.delete(key);
}
}
}
function createUnderscoreEscapedMultiMap() {
return createMultiMap();
}
ts2.createUnderscoreEscapedMultiMap = createUnderscoreEscapedMultiMap;
function isArray(value) {
return Array.isArray ? Array.isArray(value) : value instanceof Array;
}
ts2.isArray = isArray;
function toArray(value) {
return isArray(value) ? value : [value];
}
ts2.toArray = toArray;
function isString(text) {
return typeof text === "string";
}
ts2.isString = isString;
function isNumber(x) {
return typeof x === "number";
}
ts2.isNumber = isNumber;
function tryCast(value, test) {
return value !== void 0 && test(value) ? value : void 0;
}
ts2.tryCast = tryCast;
function cast(value, test) {
if (value !== void 0 && test(value))
return value;
return ts2.Debug.fail("Invalid cast. The supplied value ".concat(value, " did not pass the test '").concat(ts2.Debug.getFunctionName(test), "'."));
}
ts2.cast = cast;
function noop(_) {
}
ts2.noop = noop;
function returnFalse() {
return false;
}
ts2.returnFalse = returnFalse;
function returnTrue() {
return true;
}
ts2.returnTrue = returnTrue;
function returnUndefined() {
return void 0;
}
ts2.returnUndefined = returnUndefined;
function identity(x) {
return x;
}
ts2.identity = identity;
function toLowerCase(x) {
return x.toLowerCase();
}
ts2.toLowerCase = toLowerCase;
var fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
function toFileNameLowerCase(x) {
return fileNameLowerCaseRegExp.test(x) ? x.replace(fileNameLowerCaseRegExp, toLowerCase) : x;
}
ts2.toFileNameLowerCase = toFileNameLowerCase;
function notImplemented() {
throw new Error("Not implemented");
}
ts2.notImplemented = notImplemented;
function memoize(callback) {
var value;
return function() {
if (callback) {
value = callback();
callback = void 0;
}
return value;
};
}
ts2.memoize = memoize;
function memoizeOne(callback) {
var map2 = new ts2.Map();
return function(arg) {
var key = "".concat(typeof arg, ":").concat(arg);
var value = map2.get(key);
if (value === void 0 && !map2.has(key)) {
value = callback(arg);
map2.set(key, value);
}
return value;
};
}
ts2.memoizeOne = memoizeOne;
function compose(a, b, c, d, e) {
if (!!e) {
var args_2 = [];
for (var i = 0; i < arguments.length; i++) {
args_2[i] = arguments[i];
}
return function(t) {
return reduceLeft(args_2, function(u, f) {
return f(u);
}, t);
};
} else if (d) {
return function(t) {
return d(c(b(a(t))));
};
} else if (c) {
return function(t) {
return c(b(a(t)));
};
} else if (b) {
return function(t) {
return b(a(t));
};
} else if (a) {
return function(t) {
return a(t);
};
} else {
return function(t) {
return t;
};
}
}
ts2.compose = compose;
var AssertionLevel;
(function(AssertionLevel2) {
AssertionLevel2[AssertionLevel2["None"] = 0] = "None";
AssertionLevel2[AssertionLevel2["Normal"] = 1] = "Normal";
AssertionLevel2[AssertionLevel2["Aggressive"] = 2] = "Aggressive";
AssertionLevel2[AssertionLevel2["VeryAggressive"] = 3] = "VeryAggressive";
})(AssertionLevel = ts2.AssertionLevel || (ts2.AssertionLevel = {}));
function equateValues(a, b) {
return a === b;
}
ts2.equateValues = equateValues;
function equateStringsCaseInsensitive(a, b) {
return a === b || a !== void 0 && b !== void 0 && a.toUpperCase() === b.toUpperCase();
}
ts2.equateStringsCaseInsensitive = equateStringsCaseInsensitive;
function equateStringsCaseSensitive(a, b) {
return equateValues(a, b);
}
ts2.equateStringsCaseSensitive = equateStringsCaseSensitive;
function compareComparableValues(a, b) {
return a === b ? 0 : a === void 0 ? -1 : b === void 0 ? 1 : a < b ? -1 : 1;
}
function compareValues(a, b) {
return compareComparableValues(a, b);
}
ts2.compareValues = compareValues;
function compareTextSpans(a, b) {
return compareValues(a === null || a === void 0 ? void 0 : a.start, b === null || b === void 0 ? void 0 : b.start) || compareValues(a === null || a === void 0 ? void 0 : a.length, b === null || b === void 0 ? void 0 : b.length);
}
ts2.compareTextSpans = compareTextSpans;
function min(a, b, compare) {
return compare(a, b) === -1 ? a : b;
}
ts2.min = min;
function compareStringsCaseInsensitive(a, b) {
if (a === b)
return 0;
if (a ===