aboutsummaryrefslogtreecommitdiffstats
path: root/ts.worker.js
diff options
context:
space:
mode:
Diffstat (limited to 'ts.worker.js')
-rw-r--r--ts.worker.js203350
1 files changed, 203350 insertions, 0 deletions
diff --git a/ts.worker.js b/ts.worker.js
new file mode 100644
index 0000000..42a1129
--- /dev/null
+++ b/ts.worker.js
@@ -0,0 +1,203350 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * 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 { initialize } 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 require2 = void 0;
+var module = { exports: {} };
+var ts = (() => {
+ var __defProp2 = Object.defineProperty;
+ var __getOwnPropNames = Object.getOwnPropertyNames;
+ var __esm = (fn, res) => function __init() {
+ return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+ };
+ var __commonJS = (cb, mod) => function __require() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+ };
+ var __export2 = (target, all) => {
+ for (var name in all)
+ __defProp2(target, name, { get: all[name], enumerable: true });
+ };
+ var versionMajorMinor, version, Comparison;
+ var init_corePublic = __esm({
+ "src/compiler/corePublic.ts"() {
+ "use strict";
+ versionMajorMinor = "5.4";
+ version = "5.4.5";
+ Comparison = /* @__PURE__ */ ((Comparison3) => {
+ Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
+ Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
+ Comparison3[Comparison3["GreaterThan"] = 1] = "GreaterThan";
+ return Comparison3;
+ })(Comparison || {});
+ }
+ });
+ function length(array) {
+ return array ? array.length : 0;
+ }
+ function forEach(array, callback) {
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const result = callback(array[i], i);
+ if (result) {
+ return result;
+ }
+ }
+ }
+ return void 0;
+ }
+ function forEachRight(array, callback) {
+ if (array) {
+ for (let i = array.length - 1; i >= 0; i--) {
+ const result = callback(array[i], i);
+ if (result) {
+ return result;
+ }
+ }
+ }
+ return void 0;
+ }
+ function firstDefined(array, callback) {
+ if (array === void 0) {
+ return void 0;
+ }
+ for (let i = 0; i < array.length; i++) {
+ const result = callback(array[i], i);
+ if (result !== void 0) {
+ return result;
+ }
+ }
+ return void 0;
+ }
+ function firstDefinedIterator(iter, callback) {
+ for (const value of iter) {
+ const result = callback(value);
+ if (result !== void 0) {
+ return result;
+ }
+ }
+ return void 0;
+ }
+ function reduceLeftIterator(iterator, f, initial) {
+ let result = initial;
+ if (iterator) {
+ let pos = 0;
+ for (const value of iterator) {
+ result = f(result, value, pos);
+ pos++;
+ }
+ }
+ return result;
+ }
+ function zipWith(arrayA, arrayB, callback) {
+ const result = [];
+ Debug.assertEqual(arrayA.length, arrayB.length);
+ for (let i = 0; i < arrayA.length; i++) {
+ result.push(callback(arrayA[i], arrayB[i], i));
+ }
+ return result;
+ }
+ function intersperse(input, element) {
+ if (input.length <= 1) {
+ return input;
+ }
+ const result = [];
+ for (let i = 0, n = input.length; i < n; i++) {
+ if (i)
+ result.push(element);
+ result.push(input[i]);
+ }
+ return result;
+ }
+ function every(array, callback) {
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ if (!callback(array[i], i)) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ function find(array, predicate, startIndex) {
+ if (array === void 0)
+ return void 0;
+ for (let i = startIndex ?? 0; i < array.length; i++) {
+ const value = array[i];
+ if (predicate(value, i)) {
+ return value;
+ }
+ }
+ return void 0;
+ }
+ function findLast(array, predicate, startIndex) {
+ if (array === void 0)
+ return void 0;
+ for (let i = startIndex ?? array.length - 1; i >= 0; i--) {
+ const value = array[i];
+ if (predicate(value, i)) {
+ return value;
+ }
+ }
+ return void 0;
+ }
+ function findIndex(array, predicate, startIndex) {
+ if (array === void 0)
+ return -1;
+ for (let i = startIndex ?? 0; i < array.length; i++) {
+ if (predicate(array[i], i)) {
+ return i;
+ }
+ }
+ return -1;
+ }
+ function findLastIndex(array, predicate, startIndex) {
+ if (array === void 0)
+ return -1;
+ for (let i = startIndex ?? array.length - 1; i >= 0; i--) {
+ if (predicate(array[i], i)) {
+ return i;
+ }
+ }
+ return -1;
+ }
+ function findMap(array, callback) {
+ for (let i = 0; i < array.length; i++) {
+ const result = callback(array[i], i);
+ if (result) {
+ return result;
+ }
+ }
+ return Debug.fail();
+ }
+ function contains(array, value, equalityComparer = equateValues) {
+ if (array) {
+ for (const v of array) {
+ if (equalityComparer(v, value)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ function arraysEqual(a, b, equalityComparer = equateValues) {
+ return a.length === b.length && a.every((x, i) => equalityComparer(x, b[i]));
+ }
+ function indexOfAnyCharCode(text, charCodes, start) {
+ for (let i = start || 0; i < text.length; i++) {
+ if (contains(charCodes, text.charCodeAt(i))) {
+ return i;
+ }
+ }
+ return -1;
+ }
+ function countWhere(array, predicate) {
+ let count = 0;
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const v = array[i];
+ if (predicate(v, i)) {
+ count++;
+ }
+ }
+ }
+ return count;
+ }
+ function filter(array, f) {
+ if (array) {
+ const len = array.length;
+ let i = 0;
+ while (i < len && f(array[i]))
+ i++;
+ if (i < len) {
+ const result = array.slice(0, i);
+ i++;
+ while (i < len) {
+ const item = array[i];
+ if (f(item)) {
+ result.push(item);
+ }
+ i++;
+ }
+ return result;
+ }
+ }
+ return array;
+ }
+ function filterMutate(array, f) {
+ let outIndex = 0;
+ for (let i = 0; i < array.length; i++) {
+ if (f(array[i], i, array)) {
+ array[outIndex] = array[i];
+ outIndex++;
+ }
+ }
+ array.length = outIndex;
+ }
+ function clear(array) {
+ array.length = 0;
+ }
+ function map(array, f) {
+ let result;
+ if (array) {
+ result = [];
+ for (let i = 0; i < array.length; i++) {
+ result.push(f(array[i], i));
+ }
+ }
+ return result;
+ }
+ function* mapIterator(iter, mapFn) {
+ for (const x of iter) {
+ yield mapFn(x);
+ }
+ }
+ function sameMap(array, f) {
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const item = array[i];
+ const mapped = f(item, i);
+ if (item !== mapped) {
+ const result = array.slice(0, i);
+ result.push(mapped);
+ for (i++; i < array.length; i++) {
+ result.push(f(array[i], i));
+ }
+ return result;
+ }
+ }
+ }
+ return array;
+ }
+ function flatten(array) {
+ const result = [];
+ for (const v of array) {
+ if (v) {
+ if (isArray(v)) {
+ addRange(result, v);
+ } else {
+ result.push(v);
+ }
+ }
+ }
+ return result;
+ }
+ function flatMap(array, mapfn) {
+ let result;
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const v = mapfn(array[i], i);
+ if (v) {
+ if (isArray(v)) {
+ result = addRange(result, v);
+ } else {
+ result = append(result, v);
+ }
+ }
+ }
+ }
+ return result || emptyArray;
+ }
+ function flatMapToMutable(array, mapfn) {
+ const result = [];
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const v = mapfn(array[i], i);
+ if (v) {
+ if (isArray(v)) {
+ addRange(result, v);
+ } else {
+ result.push(v);
+ }
+ }
+ }
+ }
+ return result;
+ }
+ function* flatMapIterator(iter, mapfn) {
+ for (const x of iter) {
+ const iter2 = mapfn(x);
+ if (!iter2)
+ continue;
+ yield* iter2;
+ }
+ }
+ function sameFlatMap(array, mapfn) {
+ let result;
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const item = array[i];
+ const 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;
+ }
+ function mapAllOrFail(array, mapFn) {
+ const result = [];
+ for (let i = 0; i < array.length; i++) {
+ const mapped = mapFn(array[i], i);
+ if (mapped === void 0) {
+ return void 0;
+ }
+ result.push(mapped);
+ }
+ return result;
+ }
+ function mapDefined(array, mapFn) {
+ const result = [];
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const mapped = mapFn(array[i], i);
+ if (mapped !== void 0) {
+ result.push(mapped);
+ }
+ }
+ }
+ return result;
+ }
+ function* mapDefinedIterator(iter, mapFn) {
+ for (const x of iter) {
+ const value = mapFn(x);
+ if (value !== void 0) {
+ yield value;
+ }
+ }
+ }
+ function mapDefinedEntries(map2, f) {
+ if (!map2) {
+ return void 0;
+ }
+ const result = /* @__PURE__ */ new Map();
+ map2.forEach((value, key) => {
+ const entry = f(key, value);
+ if (entry !== void 0) {
+ const [newKey, newValue] = entry;
+ if (newKey !== void 0 && newValue !== void 0) {
+ result.set(newKey, newValue);
+ }
+ }
+ });
+ return result;
+ }
+ function getOrUpdate(map2, key, callback) {
+ if (map2.has(key)) {
+ return map2.get(key);
+ }
+ const value = callback();
+ map2.set(key, value);
+ return value;
+ }
+ function tryAddToSet(set, value) {
+ if (!set.has(value)) {
+ set.add(value);
+ return true;
+ }
+ return false;
+ }
+ function* singleIterator(value) {
+ yield value;
+ }
+ function spanMap(array, keyfn, mapfn) {
+ let result;
+ if (array) {
+ result = [];
+ const len = array.length;
+ let previousKey;
+ let key;
+ let start = 0;
+ let pos = 0;
+ while (start < len) {
+ while (pos < len) {
+ const value = array[pos];
+ key = keyfn(value, pos);
+ if (pos === 0) {
+ previousKey = key;
+ } else if (key !== previousKey) {
+ break;
+ }
+ pos++;
+ }
+ if (start < pos) {
+ const v = mapfn(array.slice(start, pos), previousKey, start, pos);
+ if (v) {
+ result.push(v);
+ }
+ start = pos;
+ }
+ previousKey = key;
+ pos++;
+ }
+ }
+ return result;
+ }
+ function mapEntries(map2, f) {
+ if (!map2) {
+ return void 0;
+ }
+ const result = /* @__PURE__ */ new Map();
+ map2.forEach((value, key) => {
+ const [newKey, newValue] = f(key, value);
+ result.set(newKey, newValue);
+ });
+ return result;
+ }
+ function some(array, predicate) {
+ if (array) {
+ if (predicate) {
+ for (const v of array) {
+ if (predicate(v)) {
+ return true;
+ }
+ }
+ } else {
+ return array.length > 0;
+ }
+ }
+ return false;
+ }
+ function getRangesWhere(arr, pred, cb) {
+ let start;
+ for (let 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);
+ }
+ function concatenate(array1, array2) {
+ if (!some(array2))
+ return array1;
+ if (!some(array1))
+ return array2;
+ return [...array1, ...array2];
+ }
+ function selectIndex(_, i) {
+ return i;
+ }
+ function indicesOf(array) {
+ return array.map(selectIndex);
+ }
+ function deduplicateRelational(array, equalityComparer, comparer) {
+ const indices = indicesOf(array);
+ stableSortIndices(array, indices, comparer);
+ let last2 = array[indices[0]];
+ const deduplicated = [indices[0]];
+ for (let i = 1; i < indices.length; i++) {
+ const index = indices[i];
+ const item = array[index];
+ if (!equalityComparer(last2, item)) {
+ deduplicated.push(index);
+ last2 = item;
+ }
+ }
+ deduplicated.sort();
+ return deduplicated.map((i) => array[i]);
+ }
+ function deduplicateEquality(array, equalityComparer) {
+ const result = [];
+ for (const item of array) {
+ 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);
+ }
+ function deduplicateSorted(array, comparer) {
+ if (array.length === 0)
+ return emptyArray;
+ let last2 = array[0];
+ const deduplicated = [last2];
+ for (let i = 1; i < array.length; i++) {
+ const next = array[i];
+ switch (comparer(next, last2)) {
+ case true:
+ case 0:
+ continue;
+ case -1:
+ return Debug.fail("Array is unsorted.");
+ }
+ deduplicated.push(last2 = next);
+ }
+ return deduplicated;
+ }
+ function createSortedArray() {
+ return [];
+ }
+ function insertSorted(array, insert, compare, allowDuplicates) {
+ if (array.length === 0) {
+ array.push(insert);
+ return true;
+ }
+ const insertIndex = binarySearch(array, insert, identity, compare);
+ if (insertIndex < 0) {
+ array.splice(~insertIndex, 0, insert);
+ return true;
+ }
+ if (allowDuplicates) {
+ array.splice(insertIndex, 0, insert);
+ return true;
+ }
+ return false;
+ }
+ function sortAndDeduplicate(array, comparer, equalityComparer) {
+ return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive);
+ }
+ function arrayIsSorted(array, comparer) {
+ if (array.length < 2)
+ return true;
+ for (let i = 1, len = array.length; i < len; i++) {
+ if (comparer(array[i - 1], array[i]) === 1) {
+ return false;
+ }
+ }
+ return true;
+ }
+ function detectSortCaseSensitivity(array, getString, compareStringsCaseSensitive2, compareStringsCaseInsensitive2) {
+ let kind = 3;
+ if (array.length < 2)
+ return kind;
+ let prevElement = getString(array[0]);
+ for (let i = 1, len = array.length; i < len && kind !== 0; i++) {
+ const element = getString(array[i]);
+ if (kind & 1 && compareStringsCaseSensitive2(prevElement, element) > 0) {
+ kind &= ~1;
+ }
+ if (kind & 2 && compareStringsCaseInsensitive2(prevElement, element) > 0) {
+ kind &= ~2;
+ }
+ prevElement = element;
+ }
+ return kind;
+ }
+ function arrayIsEqualTo(array1, array2, equalityComparer = equateValues) {
+ if (!array1 || !array2) {
+ return array1 === array2;
+ }
+ if (array1.length !== array2.length) {
+ return false;
+ }
+ for (let i = 0; i < array1.length; i++) {
+ if (!equalityComparer(array1[i], array2[i], i)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ function compact(array) {
+ let result;
+ if (array) {
+ for (let i = 0; i < array.length; i++) {
+ const v = array[i];
+ if (result || !v) {
+ if (!result) {
+ result = array.slice(0, i);
+ }
+ if (v) {
+ result.push(v);
+ }
+ }
+ }
+ }
+ return result || array;
+ }
+ function relativeComplement(arrayA, arrayB, comparer) {
+ if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0)
+ return arrayB;
+ const result = [];
+ loopB:
+ for (let offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) {
+ if (offsetB > 0) {
+ Debug.assertGreaterThanOrEqual(
+ comparer(arrayB[offsetB], arrayB[offsetB - 1]),
+ 0
+ /* EqualTo */
+ );
+ }
+ loopA:
+ for (const startA = offsetA; offsetA < arrayA.length; offsetA++) {
+ if (offsetA > startA) {
+ Debug.assertGreaterThanOrEqual(
+ comparer(arrayA[offsetA], arrayA[offsetA - 1]),
+ 0
+ /* EqualTo */
+ );
+ }
+ switch (comparer(arrayB[offsetB], arrayA[offsetA])) {
+ case -1:
+ result.push(arrayB[offsetB]);
+ continue loopB;
+ case 0:
+ continue loopB;
+ case 1:
+ continue loopA;
+ }
+ }
+ }
+ return result;
+ }
+ function append(to, value) {
+ if (value === void 0)
+ return to;
+ if (to === void 0)
+ return [value];
+ to.push(value);
+ return to;
+ }
+ 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];
+ }
+ 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 (let i = start; i < end && i < from.length; i++) {
+ if (from[i] !== void 0) {
+ to.push(from[i]);
+ }
+ }
+ return to;
+ }
+ function pushIfUnique(array, toAdd, equalityComparer) {
+ if (contains(array, toAdd, equalityComparer)) {
+ return false;
+ } else {
+ array.push(toAdd);
+ return true;
+ }
+ }
+ function appendIfUnique(array, toAdd, equalityComparer) {
+ if (array) {
+ pushIfUnique(array, toAdd, equalityComparer);
+ return array;
+ } else {
+ return [toAdd];
+ }
+ }
+ function stableSortIndices(array, indices, comparer) {
+ indices.sort((x, y) => comparer(array[x], array[y]) || compareValues(x, y));
+ }
+ function sort(array, comparer) {
+ return array.length === 0 ? array : array.slice().sort(comparer);
+ }
+ function* arrayReverseIterator(array) {
+ for (let i = array.length - 1; i >= 0; i--) {
+ yield array[i];
+ }
+ }
+ function stableSort(array, comparer) {
+ const indices = indicesOf(array);
+ stableSortIndices(array, indices, comparer);
+ return indices.map((i) => array[i]);
+ }
+ function rangeEquals(array1, array2, pos, end) {
+ while (pos < end) {
+ if (array1[pos] !== array2[pos]) {
+ return false;
+ }
+ pos++;
+ }
+ return true;
+ }
+ function firstOrUndefined(array) {
+ return array === void 0 || array.length === 0 ? void 0 : array[0];
+ }
+ function firstOrUndefinedIterator(iter) {
+ if (iter) {
+ for (const value of iter) {
+ return value;
+ }
+ }
+ return void 0;
+ }
+ function first(array) {
+ Debug.assert(array.length !== 0);
+ return array[0];
+ }
+ function firstIterator(iter) {
+ for (const value of iter) {
+ return value;
+ }
+ Debug.fail("iterator is empty");
+ }
+ function lastOrUndefined(array) {
+ return array === void 0 || array.length === 0 ? void 0 : array[array.length - 1];
+ }
+ function last(array) {
+ Debug.assert(array.length !== 0);
+ return array[array.length - 1];
+ }
+ function singleOrUndefined(array) {
+ return array && array.length === 1 ? array[0] : void 0;
+ }
+ function single(array) {
+ return Debug.checkDefined(singleOrUndefined(array));
+ }
+ function singleOrMany(array) {
+ return array && array.length === 1 ? array[0] : array;
+ }
+ function replaceElement(array, index, value) {
+ const result = array.slice(0);
+ result[index] = value;
+ return result;
+ }
+ function binarySearch(array, value, keySelector, keyComparer, offset) {
+ return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset);
+ }
+ function binarySearchKey(array, key, keySelector, keyComparer, offset) {
+ if (!some(array)) {
+ return -1;
+ }
+ let low = offset || 0;
+ let high = array.length - 1;
+ while (low <= high) {
+ const middle = low + (high - low >> 1);
+ const 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;
+ }
+ function reduceLeft(array, f, initial, start, count) {
+ if (array && array.length > 0) {
+ const size = array.length;
+ if (size > 0) {
+ let pos = start === void 0 || start < 0 ? 0 : start;
+ const end = count === void 0 || pos + count > size - 1 ? size - 1 : pos + count;
+ let result;
+ 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;
+ }
+ function hasProperty(map2, key) {
+ return hasOwnProperty.call(map2, key);
+ }
+ function getProperty(map2, key) {
+ return hasOwnProperty.call(map2, key) ? map2[key] : void 0;
+ }
+ function getOwnKeys(map2) {
+ const keys = [];
+ for (const key in map2) {
+ if (hasOwnProperty.call(map2, key)) {
+ keys.push(key);
+ }
+ }
+ return keys;
+ }
+ function getAllKeys(obj) {
+ const result = [];
+ do {
+ const names = Object.getOwnPropertyNames(obj);
+ for (const name of names) {
+ pushIfUnique(result, name);
+ }
+ } while (obj = Object.getPrototypeOf(obj));
+ return result;
+ }
+ function getOwnValues(collection) {
+ const values = [];
+ for (const key in collection) {
+ if (hasOwnProperty.call(collection, key)) {
+ values.push(collection[key]);
+ }
+ }
+ return values;
+ }
+ function arrayOf(count, f) {
+ const result = new Array(count);
+ for (let i = 0; i < count; i++) {
+ result[i] = f(i);
+ }
+ return result;
+ }
+ function arrayFrom(iterator, map2) {
+ const result = [];
+ for (const value of iterator) {
+ result.push(map2 ? map2(value) : value);
+ }
+ return result;
+ }
+ function assign(t, ...args) {
+ for (const arg of args) {
+ if (arg === void 0)
+ continue;
+ for (const p in arg) {
+ if (hasProperty(arg, p)) {
+ t[p] = arg[p];
+ }
+ }
+ }
+ return t;
+ }
+ function equalOwnProperties(left, right, equalityComparer = equateValues) {
+ if (left === right)
+ return true;
+ if (!left || !right)
+ return false;
+ for (const key in left) {
+ if (hasOwnProperty.call(left, key)) {
+ if (!hasOwnProperty.call(right, key))
+ return false;
+ if (!equalityComparer(left[key], right[key]))
+ return false;
+ }
+ }
+ for (const key in right) {
+ if (hasOwnProperty.call(right, key)) {
+ if (!hasOwnProperty.call(left, key))
+ return false;
+ }
+ }
+ return true;
+ }
+ function arrayToMap(array, makeKey, makeValue = identity) {
+ const result = /* @__PURE__ */ new Map();
+ for (const value of array) {
+ const key = makeKey(value);
+ if (key !== void 0)
+ result.set(key, makeValue(value));
+ }
+ return result;
+ }
+ function arrayToNumericMap(array, makeKey, makeValue = identity) {
+ const result = [];
+ for (const value of array) {
+ result[makeKey(value)] = makeValue(value);
+ }
+ return result;
+ }
+ function arrayToMultiMap(values, makeKey, makeValue = identity) {
+ const result = createMultiMap();
+ for (const value of values) {
+ result.add(makeKey(value), makeValue(value));
+ }
+ return result;
+ }
+ function group(values, getGroupId, resultSelector = identity) {
+ return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector);
+ }
+ function groupBy(values, keySelector) {
+ const result = {};
+ if (values) {
+ for (const value of values) {
+ const key = `${keySelector(value)}`;
+ const array = result[key] ?? (result[key] = []);
+ array.push(value);
+ }
+ }
+ return result;
+ }
+ function clone(object) {
+ const result = {};
+ for (const id in object) {
+ if (hasOwnProperty.call(object, id)) {
+ result[id] = object[id];
+ }
+ }
+ return result;
+ }
+ function extend(first2, second) {
+ const result = {};
+ for (const id in second) {
+ if (hasOwnProperty.call(second, id)) {
+ result[id] = second[id];
+ }
+ }
+ for (const id in first2) {
+ if (hasOwnProperty.call(first2, id)) {
+ result[id] = first2[id];
+ }
+ }
+ return result;
+ }
+ function copyProperties(first2, second) {
+ for (const id in second) {
+ if (hasOwnProperty.call(second, id)) {
+ first2[id] = second[id];
+ }
+ }
+ }
+ function maybeBind(obj, fn) {
+ return fn ? fn.bind(obj) : void 0;
+ }
+ function createMultiMap() {
+ const map2 = /* @__PURE__ */ new Map();
+ map2.add = multiMapAdd;
+ map2.remove = multiMapRemove;
+ return map2;
+ }
+ function multiMapAdd(key, value) {
+ let values = this.get(key);
+ if (values) {
+ values.push(value);
+ } else {
+ this.set(key, values = [value]);
+ }
+ return values;
+ }
+ function multiMapRemove(key, value) {
+ const values = this.get(key);
+ if (values) {
+ unorderedRemoveItem(values, value);
+ if (!values.length) {
+ this.delete(key);
+ }
+ }
+ }
+ function createQueue(items) {
+ const elements = (items == null ? void 0 : items.slice()) || [];
+ let headIndex = 0;
+ function isEmpty() {
+ return headIndex === elements.length;
+ }
+ function enqueue(...items2) {
+ elements.push(...items2);
+ }
+ function dequeue() {
+ if (isEmpty()) {
+ throw new Error("Queue is empty");
+ }
+ const result = elements[headIndex];
+ elements[headIndex] = void 0;
+ headIndex++;
+ if (headIndex > 100 && headIndex > elements.length >> 1) {
+ const newLength = elements.length - headIndex;
+ elements.copyWithin(
+ /*target*/
+ 0,
+ /*start*/
+ headIndex
+ );
+ elements.length = newLength;
+ headIndex = 0;
+ }
+ return result;
+ }
+ return {
+ enqueue,
+ dequeue,
+ isEmpty
+ };
+ }
+ function createSet(getHashCode, equals) {
+ const multiMap = /* @__PURE__ */ new Map();
+ let size = 0;
+ function* getElementIterator() {
+ for (const value of multiMap.values()) {
+ if (isArray(value)) {
+ yield* value;
+ } else {
+ yield value;
+ }
+ }
+ }
+ const set = {
+ has(element) {
+ const hash = getHashCode(element);
+ if (!multiMap.has(hash))
+ return false;
+ const candidates = multiMap.get(hash);
+ if (!isArray(candidates))
+ return equals(candidates, element);
+ for (const candidate of candidates) {
+ if (equals(candidate, element)) {
+ return true;
+ }
+ }
+ return false;
+ },
+ add(element) {
+ const hash = getHashCode(element);
+ if (multiMap.has(hash)) {
+ const values = multiMap.get(hash);
+ if (isArray(values)) {
+ if (!contains(values, element, equals)) {
+ values.push(element);
+ size++;
+ }
+ } else {
+ const value = values;
+ if (!equals(value, element)) {
+ multiMap.set(hash, [value, element]);
+ size++;
+ }
+ }
+ } else {
+ multiMap.set(hash, element);
+ size++;
+ }
+ return this;
+ },
+ delete(element) {
+ const hash = getHashCode(element);
+ if (!multiMap.has(hash))
+ return false;
+ const candidates = multiMap.get(hash);
+ if (isArray(candidates)) {
+ for (let i = 0; i < candidates.length; i++) {
+ if (equals(candidates[i], element)) {
+ if (candidates.length === 1) {
+ multiMap.delete(hash);
+ } else if (candidates.length === 2) {
+ multiMap.set(hash, candidates[1 - i]);
+ } else {
+ unorderedRemoveItemAt(candidates, i);
+ }
+ size--;
+ return true;
+ }
+ }
+ } else {
+ const candidate = candidates;
+ if (equals(candidate, element)) {
+ multiMap.delete(hash);
+ size--;
+ return true;
+ }
+ }
+ return false;
+ },
+ clear() {
+ multiMap.clear();
+ size = 0;
+ },
+ get size() {
+ return size;
+ },
+ forEach(action) {
+ for (const elements of arrayFrom(multiMap.values())) {
+ if (isArray(elements)) {
+ for (const element of elements) {
+ action(element, element, set);
+ }
+ } else {
+ const element = elements;
+ action(element, element, set);
+ }
+ }
+ },
+ keys() {
+ return getElementIterator();
+ },
+ values() {
+ return getElementIterator();
+ },
+ *entries() {
+ for (const value of getElementIterator()) {
+ yield [value, value];
+ }
+ },
+ [Symbol.iterator]: () => {
+ return getElementIterator();
+ },
+ [Symbol.toStringTag]: multiMap[Symbol.toStringTag]
+ };
+ return set;
+ }
+ function isArray(value) {
+ return Array.isArray(value);
+ }
+ function toArray(value) {
+ return isArray(value) ? value : [value];
+ }
+ function isString(text) {
+ return typeof text === "string";
+ }
+ function isNumber(x) {
+ return typeof x === "number";
+ }
+ function tryCast(value, test) {
+ return value !== void 0 && test(value) ? value : void 0;
+ }
+ function cast(value, test) {
+ if (value !== void 0 && test(value))
+ return value;
+ return Debug.fail(`Invalid cast. The supplied value ${value} did not pass the test '${Debug.getFunctionName(test)}'.`);
+ }
+ function noop(_) {
+ }