diff --git a/dist/02-XYLO1.mp3 b/dist/02-XYLO1.mp3 new file mode 100644 index 00000000..5f1c9b92 Binary files /dev/null and b/dist/02-XYLO1.mp3 differ diff --git a/dist/assets/1551f4f60c37af51121f.woff2 b/dist/assets/1551f4f60c37af51121f.woff2 new file mode 100644 index 00000000..2217164f Binary files /dev/null and b/dist/assets/1551f4f60c37af51121f.woff2 differ diff --git a/dist/assets/184be8c3aa435ca6c3f5.ttf b/dist/assets/184be8c3aa435ca6c3f5.ttf new file mode 100644 index 00000000..a071a7a8 Binary files /dev/null and b/dist/assets/184be8c3aa435ca6c3f5.ttf differ diff --git a/dist/assets/2285773e6b4b172f07d9.woff b/dist/assets/2285773e6b4b172f07d9.woff new file mode 100644 index 00000000..3375bef0 Binary files /dev/null and b/dist/assets/2285773e6b4b172f07d9.woff differ diff --git a/dist/assets/23f19bb08961f37aaf69.eot b/dist/assets/23f19bb08961f37aaf69.eot new file mode 100644 index 00000000..cba6c6cc Binary files /dev/null and b/dist/assets/23f19bb08961f37aaf69.eot differ diff --git a/dist/assets/2f517e09eb2ca6650ff5.svg b/dist/assets/2f517e09eb2ca6650ff5.svg new file mode 100644 index 00000000..b9881a43 --- /dev/null +++ b/dist/assets/2f517e09eb2ca6650ff5.svg @@ -0,0 +1,3717 @@ + + + + +Created by FontForge 20201107 at Wed Aug 4 12:25:29 2021 + By Robert Madole +Copyright (c) Font Awesome + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dist/assets/4689f52cc96215721344.svg b/dist/assets/4689f52cc96215721344.svg new file mode 100644 index 00000000..463af27c --- /dev/null +++ b/dist/assets/4689f52cc96215721344.svg @@ -0,0 +1,801 @@ + + + + +Created by FontForge 20201107 at Wed Aug 4 12:25:29 2021 + By Robert Madole +Copyright (c) Font Awesome + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dist/assets/491974d108fe4002b2aa.ttf b/dist/assets/491974d108fe4002b2aa.ttf new file mode 100644 index 00000000..7157aafb Binary files /dev/null and b/dist/assets/491974d108fe4002b2aa.ttf differ diff --git a/dist/assets/527940b104eb2ea366c8.ttf b/dist/assets/527940b104eb2ea366c8.ttf new file mode 100644 index 00000000..8d75dedd Binary files /dev/null and b/dist/assets/527940b104eb2ea366c8.ttf differ diff --git a/dist/assets/77206a6bb316fa0aded5.eot b/dist/assets/77206a6bb316fa0aded5.eot new file mode 100644 index 00000000..a4e59893 Binary files /dev/null and b/dist/assets/77206a6bb316fa0aded5.eot differ diff --git a/dist/assets/7a3337626410ca2f4071.woff2 b/dist/assets/7a3337626410ca2f4071.woff2 new file mode 100644 index 00000000..56328948 Binary files /dev/null and b/dist/assets/7a3337626410ca2f4071.woff2 differ diff --git a/dist/assets/7a8b4f130182d19a2d7c.svg b/dist/assets/7a8b4f130182d19a2d7c.svg new file mode 100644 index 00000000..00296e95 --- /dev/null +++ b/dist/assets/7a8b4f130182d19a2d7c.svg @@ -0,0 +1,5034 @@ + + + + +Created by FontForge 20201107 at Wed Aug 4 12:25:29 2021 + By Robert Madole +Copyright (c) Font Awesome + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dist/assets/9bbb245e67a133f6e486.eot b/dist/assets/9bbb245e67a133f6e486.eot new file mode 100644 index 00000000..e9941719 Binary files /dev/null and b/dist/assets/9bbb245e67a133f6e486.eot differ diff --git a/dist/assets/bb58e57c48a3e911f15f.woff b/dist/assets/bb58e57c48a3e911f15f.woff new file mode 100644 index 00000000..ad077c6b Binary files /dev/null and b/dist/assets/bb58e57c48a3e911f15f.woff differ diff --git a/dist/assets/be9ee23c0c6390141475.ttf b/dist/assets/be9ee23c0c6390141475.ttf new file mode 100644 index 00000000..25abf389 Binary files /dev/null and b/dist/assets/be9ee23c0c6390141475.ttf differ diff --git a/dist/assets/d878b0a6a1144760244f.woff2 b/dist/assets/d878b0a6a1144760244f.woff2 new file mode 100644 index 00000000..402f81c0 Binary files /dev/null and b/dist/assets/d878b0a6a1144760244f.woff2 differ diff --git a/dist/assets/eeccf4f66002c6f2ba24.woff b/dist/assets/eeccf4f66002c6f2ba24.woff new file mode 100644 index 00000000..23ee6634 Binary files /dev/null and b/dist/assets/eeccf4f66002c6f2ba24.woff differ diff --git a/dist/editor.worker.js b/dist/editor.worker.js new file mode 100644 index 00000000..1838a1c8 --- /dev/null +++ b/dist/editor.worker.js @@ -0,0 +1,18494 @@ +/******/ (() => { // webpackBootstrap +/******/ "use strict"; +/******/ var __webpack_modules__ = ({ + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/arrays.js": +/*!*****************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/arrays.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ ArrayQueue: () => (/* binding */ ArrayQueue), +/* harmony export */ CallbackIterable: () => (/* binding */ CallbackIterable), +/* harmony export */ CompareResult: () => (/* binding */ CompareResult), +/* harmony export */ arrayInsert: () => (/* binding */ arrayInsert), +/* harmony export */ asArray: () => (/* binding */ asArray), +/* harmony export */ binarySearch: () => (/* binding */ binarySearch), +/* harmony export */ binarySearch2: () => (/* binding */ binarySearch2), +/* harmony export */ booleanComparator: () => (/* binding */ booleanComparator), +/* harmony export */ coalesce: () => (/* binding */ coalesce), +/* harmony export */ coalesceInPlace: () => (/* binding */ coalesceInPlace), +/* harmony export */ compareBy: () => (/* binding */ compareBy), +/* harmony export */ distinct: () => (/* binding */ distinct), +/* harmony export */ equals: () => (/* binding */ equals), +/* harmony export */ firstOrDefault: () => (/* binding */ firstOrDefault), +/* harmony export */ forEachAdjacent: () => (/* binding */ forEachAdjacent), +/* harmony export */ forEachWithNeighbors: () => (/* binding */ forEachWithNeighbors), +/* harmony export */ groupAdjacentBy: () => (/* binding */ groupAdjacentBy), +/* harmony export */ groupBy: () => (/* binding */ groupBy), +/* harmony export */ insertInto: () => (/* binding */ insertInto), +/* harmony export */ isFalsyOrEmpty: () => (/* binding */ isFalsyOrEmpty), +/* harmony export */ isNonEmptyArray: () => (/* binding */ isNonEmptyArray), +/* harmony export */ numberComparator: () => (/* binding */ numberComparator), +/* harmony export */ pushMany: () => (/* binding */ pushMany), +/* harmony export */ pushToEnd: () => (/* binding */ pushToEnd), +/* harmony export */ pushToStart: () => (/* binding */ pushToStart), +/* harmony export */ quickSelect: () => (/* binding */ quickSelect), +/* harmony export */ range: () => (/* binding */ range), +/* harmony export */ removeFastWithoutKeepingOrder: () => (/* binding */ removeFastWithoutKeepingOrder), +/* harmony export */ reverseOrder: () => (/* binding */ reverseOrder), +/* harmony export */ splice: () => (/* binding */ splice), +/* harmony export */ tail: () => (/* binding */ tail), +/* harmony export */ tail2: () => (/* binding */ tail2), +/* harmony export */ tieBreakComparators: () => (/* binding */ tieBreakComparators) +/* harmony export */ }); +/** + * Returns the last element of an array. + * @param array The array. + * @param n Which element from the end (default is zero). + */ +function tail(array, n = 0) { + return array[array.length - (1 + n)]; +} +function tail2(arr) { + if (arr.length === 0) { + throw new Error('Invalid tail call'); + } + return [arr.slice(0, arr.length - 1), arr[arr.length - 1]]; +} +function equals(one, other, itemEquals = (a, b) => a === b) { + if (one === other) { + return true; + } + if (!one || !other) { + return false; + } + if (one.length !== other.length) { + return false; + } + for (let i = 0, len = one.length; i < len; i++) { + if (!itemEquals(one[i], other[i])) { + return false; + } + } + return true; +} +/** + * Remove the element at `index` by replacing it with the last element. This is faster than `splice` + * but changes the order of the array + */ +function removeFastWithoutKeepingOrder(array, index) { + const last = array.length - 1; + if (index < last) { + array[index] = array[last]; + } + array.pop(); +} +/** + * Performs a binary search algorithm over a sorted array. + * + * @param array The array being searched. + * @param key The value we search for. + * @param comparator A function that takes two array elements and returns zero + * if they are equal, a negative number if the first element precedes the + * second one in the sorting order, or a positive number if the second element + * precedes the first one. + * @return See {@link binarySearch2} + */ +function binarySearch(array, key, comparator) { + return binarySearch2(array.length, i => comparator(array[i], key)); +} +/** + * Performs a binary search algorithm over a sorted collection. Useful for cases + * when we need to perform a binary search over something that isn't actually an + * array, and converting data to an array would defeat the use of binary search + * in the first place. + * + * @param length The collection length. + * @param compareToKey A function that takes an index of an element in the + * collection and returns zero if the value at this index is equal to the + * search key, a negative number if the value precedes the search key in the + * sorting order, or a positive number if the search key precedes the value. + * @return A non-negative index of an element, if found. If not found, the + * result is -(n+1) (or ~n, using bitwise notation), where n is the index + * where the key should be inserted to maintain the sorting order. + */ +function binarySearch2(length, compareToKey) { + let low = 0, high = length - 1; + while (low <= high) { + const mid = ((low + high) / 2) | 0; + const comp = compareToKey(mid); + if (comp < 0) { + low = mid + 1; + } + else if (comp > 0) { + high = mid - 1; + } + else { + return mid; + } + } + return -(low + 1); +} +function quickSelect(nth, data, compare) { + nth = nth | 0; + if (nth >= data.length) { + throw new TypeError('invalid index'); + } + const pivotValue = data[Math.floor(data.length * Math.random())]; + const lower = []; + const higher = []; + const pivots = []; + for (const value of data) { + const val = compare(value, pivotValue); + if (val < 0) { + lower.push(value); + } + else if (val > 0) { + higher.push(value); + } + else { + pivots.push(value); + } + } + if (nth < lower.length) { + return quickSelect(nth, lower, compare); + } + else if (nth < lower.length + pivots.length) { + return pivots[0]; + } + else { + return quickSelect(nth - (lower.length + pivots.length), higher, compare); + } +} +function groupBy(data, compare) { + const result = []; + let currentGroup = undefined; + for (const element of data.slice(0).sort(compare)) { + if (!currentGroup || compare(currentGroup[0], element) !== 0) { + currentGroup = [element]; + result.push(currentGroup); + } + else { + currentGroup.push(element); + } + } + return result; +} +/** + * Splits the given items into a list of (non-empty) groups. + * `shouldBeGrouped` is used to decide if two consecutive items should be in the same group. + * The order of the items is preserved. + */ +function* groupAdjacentBy(items, shouldBeGrouped) { + let currentGroup; + let last; + for (const item of items) { + if (last !== undefined && shouldBeGrouped(last, item)) { + currentGroup.push(item); + } + else { + if (currentGroup) { + yield currentGroup; + } + currentGroup = [item]; + } + last = item; + } + if (currentGroup) { + yield currentGroup; + } +} +function forEachAdjacent(arr, f) { + for (let i = 0; i <= arr.length; i++) { + f(i === 0 ? undefined : arr[i - 1], i === arr.length ? undefined : arr[i]); + } +} +function forEachWithNeighbors(arr, f) { + for (let i = 0; i < arr.length; i++) { + f(i === 0 ? undefined : arr[i - 1], arr[i], i + 1 === arr.length ? undefined : arr[i + 1]); + } +} +/** + * @returns New array with all falsy values removed. The original array IS NOT modified. + */ +function coalesce(array) { + return array.filter(e => !!e); +} +/** + * Remove all falsy values from `array`. The original array IS modified. + */ +function coalesceInPlace(array) { + let to = 0; + for (let i = 0; i < array.length; i++) { + if (!!array[i]) { + array[to] = array[i]; + to += 1; + } + } + array.length = to; +} +/** + * @returns false if the provided object is an array and not empty. + */ +function isFalsyOrEmpty(obj) { + return !Array.isArray(obj) || obj.length === 0; +} +function isNonEmptyArray(obj) { + return Array.isArray(obj) && obj.length > 0; +} +/** + * Removes duplicates from the given array. The optional keyFn allows to specify + * how elements are checked for equality by returning an alternate value for each. + */ +function distinct(array, keyFn = value => value) { + const seen = new Set(); + return array.filter(element => { + const key = keyFn(element); + if (seen.has(key)) { + return false; + } + seen.add(key); + return true; + }); +} +function firstOrDefault(array, notFoundValue) { + return array.length > 0 ? array[0] : notFoundValue; +} +function range(arg, to) { + let from = typeof to === 'number' ? arg : 0; + if (typeof to === 'number') { + from = arg; + } + else { + from = 0; + to = arg; + } + const result = []; + if (from <= to) { + for (let i = from; i < to; i++) { + result.push(i); + } + } + else { + for (let i = from; i > to; i--) { + result.push(i); + } + } + return result; +} +/** + * Insert `insertArr` inside `target` at `insertIndex`. + * Please don't touch unless you understand https://jsperf.com/inserting-an-array-within-an-array + */ +function arrayInsert(target, insertIndex, insertArr) { + const before = target.slice(0, insertIndex); + const after = target.slice(insertIndex); + return before.concat(insertArr, after); +} +/** + * Pushes an element to the start of the array, if found. + */ +function pushToStart(arr, value) { + const index = arr.indexOf(value); + if (index > -1) { + arr.splice(index, 1); + arr.unshift(value); + } +} +/** + * Pushes an element to the end of the array, if found. + */ +function pushToEnd(arr, value) { + const index = arr.indexOf(value); + if (index > -1) { + arr.splice(index, 1); + arr.push(value); + } +} +function pushMany(arr, items) { + for (const item of items) { + arr.push(item); + } +} +function asArray(x) { + return Array.isArray(x) ? x : [x]; +} +/** + * Insert the new items in the array. + * @param array The original array. + * @param start The zero-based location in the array from which to start inserting elements. + * @param newItems The items to be inserted + */ +function insertInto(array, start, newItems) { + const startIdx = getActualStartIndex(array, start); + const originalLength = array.length; + const newItemsLength = newItems.length; + array.length = originalLength + newItemsLength; + // Move the items after the start index, start from the end so that we don't overwrite any value. + for (let i = originalLength - 1; i >= startIdx; i--) { + array[i + newItemsLength] = array[i]; + } + for (let i = 0; i < newItemsLength; i++) { + array[i + startIdx] = newItems[i]; + } +} +/** + * Removes elements from an array and inserts new elements in their place, returning the deleted elements. Alternative to the native Array.splice method, it + * can only support limited number of items due to the maximum call stack size limit. + * @param array The original array. + * @param start The zero-based location in the array from which to start removing elements. + * @param deleteCount The number of elements to remove. + * @returns An array containing the elements that were deleted. + */ +function splice(array, start, deleteCount, newItems) { + const index = getActualStartIndex(array, start); + let result = array.splice(index, deleteCount); + if (result === undefined) { + // see https://bugs.webkit.org/show_bug.cgi?id=261140 + result = []; + } + insertInto(array, index, newItems); + return result; +} +/** + * Determine the actual start index (same logic as the native splice() or slice()) + * If greater than the length of the array, start will be set to the length of the array. In this case, no element will be deleted but the method will behave as an adding function, adding as many element as item[n*] provided. + * If negative, it will begin that many elements from the end of the array. (In this case, the origin -1, meaning -n is the index of the nth last element, and is therefore equivalent to the index of array.length - n.) If array.length + start is less than 0, it will begin from index 0. + * @param array The target array. + * @param start The operation index. + */ +function getActualStartIndex(array, start) { + return start < 0 ? Math.max(start + array.length, 0) : Math.min(start, array.length); +} +var CompareResult; +(function (CompareResult) { + function isLessThan(result) { + return result < 0; + } + CompareResult.isLessThan = isLessThan; + function isLessThanOrEqual(result) { + return result <= 0; + } + CompareResult.isLessThanOrEqual = isLessThanOrEqual; + function isGreaterThan(result) { + return result > 0; + } + CompareResult.isGreaterThan = isGreaterThan; + function isNeitherLessOrGreaterThan(result) { + return result === 0; + } + CompareResult.isNeitherLessOrGreaterThan = isNeitherLessOrGreaterThan; + CompareResult.greaterThan = 1; + CompareResult.lessThan = -1; + CompareResult.neitherLessOrGreaterThan = 0; +})(CompareResult || (CompareResult = {})); +function compareBy(selector, comparator) { + return (a, b) => comparator(selector(a), selector(b)); +} +function tieBreakComparators(...comparators) { + return (item1, item2) => { + for (const comparator of comparators) { + const result = comparator(item1, item2); + if (!CompareResult.isNeitherLessOrGreaterThan(result)) { + return result; + } + } + return CompareResult.neitherLessOrGreaterThan; + }; +} +/** + * The natural order on numbers. +*/ +const numberComparator = (a, b) => a - b; +const booleanComparator = (a, b) => numberComparator(a ? 1 : 0, b ? 1 : 0); +function reverseOrder(comparator) { + return (a, b) => -comparator(a, b); +} +class ArrayQueue { + /** + * Constructs a queue that is backed by the given array. Runtime is O(1). + */ + constructor(items) { + this.items = items; + this.firstIdx = 0; + this.lastIdx = this.items.length - 1; + } + get length() { + return this.lastIdx - this.firstIdx + 1; + } + /** + * Consumes elements from the beginning of the queue as long as the predicate returns true. + * If no elements were consumed, `null` is returned. Has a runtime of O(result.length). + */ + takeWhile(predicate) { + // P(k) := k <= this.lastIdx && predicate(this.items[k]) + // Find s := min { k | k >= this.firstIdx && !P(k) } and return this.data[this.firstIdx...s) + let startIdx = this.firstIdx; + while (startIdx < this.items.length && predicate(this.items[startIdx])) { + startIdx++; + } + const result = startIdx === this.firstIdx ? null : this.items.slice(this.firstIdx, startIdx); + this.firstIdx = startIdx; + return result; + } + /** + * Consumes elements from the end of the queue as long as the predicate returns true. + * If no elements were consumed, `null` is returned. + * The result has the same order as the underlying array! + */ + takeFromEndWhile(predicate) { + // P(k) := this.firstIdx >= k && predicate(this.items[k]) + // Find s := max { k | k <= this.lastIdx && !P(k) } and return this.data(s...this.lastIdx] + let endIdx = this.lastIdx; + while (endIdx >= 0 && predicate(this.items[endIdx])) { + endIdx--; + } + const result = endIdx === this.lastIdx ? null : this.items.slice(endIdx + 1, this.lastIdx + 1); + this.lastIdx = endIdx; + return result; + } + peek() { + if (this.length === 0) { + return undefined; + } + return this.items[this.firstIdx]; + } + dequeue() { + const result = this.items[this.firstIdx]; + this.firstIdx++; + return result; + } + takeCount(count) { + const result = this.items.slice(this.firstIdx, this.firstIdx + count); + this.firstIdx += count; + return result; + } +} +/** + * This class is faster than an iterator and array for lazy computed data. +*/ +class CallbackIterable { + constructor( + /** + * Calls the callback for every item. + * Stops when the callback returns false. + */ + iterate) { + this.iterate = iterate; + } + toArray() { + const result = []; + this.iterate(item => { result.push(item); return true; }); + return result; + } + filter(predicate) { + return new CallbackIterable(cb => this.iterate(item => predicate(item) ? cb(item) : true)); + } + map(mapFn) { + return new CallbackIterable(cb => this.iterate(item => cb(mapFn(item)))); + } + findLast(predicate) { + let result; + this.iterate(item => { + if (predicate(item)) { + result = item; + } + return true; + }); + return result; + } + findLastMaxBy(comparator) { + let result; + let first = true; + this.iterate(item => { + if (first || CompareResult.isGreaterThan(comparator(item, result))) { + first = false; + result = item; + } + return true; + }); + return result; + } +} +CallbackIterable.empty = new CallbackIterable(_callback => { }); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/arraysFind.js": +/*!*********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/arraysFind.js ***! + \*********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ MonotonousArray: () => (/* binding */ MonotonousArray), +/* harmony export */ findFirstIdxMonotonousOrArrLen: () => (/* binding */ findFirstIdxMonotonousOrArrLen), +/* harmony export */ findFirstMaxBy: () => (/* binding */ findFirstMaxBy), +/* harmony export */ findFirstMinBy: () => (/* binding */ findFirstMinBy), +/* harmony export */ findFirstMonotonous: () => (/* binding */ findFirstMonotonous), +/* harmony export */ findLast: () => (/* binding */ findLast), +/* harmony export */ findLastIdx: () => (/* binding */ findLastIdx), +/* harmony export */ findLastIdxMonotonous: () => (/* binding */ findLastIdxMonotonous), +/* harmony export */ findLastMaxBy: () => (/* binding */ findLastMaxBy), +/* harmony export */ findLastMonotonous: () => (/* binding */ findLastMonotonous), +/* harmony export */ findMaxIdxBy: () => (/* binding */ findMaxIdxBy), +/* harmony export */ mapFindFirst: () => (/* binding */ mapFindFirst) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +function findLast(array, predicate, fromIdx) { + const idx = findLastIdx(array, predicate); + if (idx === -1) { + return undefined; + } + return array[idx]; +} +function findLastIdx(array, predicate, fromIndex = array.length - 1) { + for (let i = fromIndex; i >= 0; i--) { + const element = array[i]; + if (predicate(element)) { + return i; + } + } + return -1; +} +/** + * Finds the last item where predicate is true using binary search. + * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`! + * + * @returns `undefined` if no item matches, otherwise the last item that matches the predicate. + */ +function findLastMonotonous(array, predicate) { + const idx = findLastIdxMonotonous(array, predicate); + return idx === -1 ? undefined : array[idx]; +} +/** + * Finds the last item where predicate is true using binary search. + * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`! + * + * @returns `startIdx - 1` if predicate is false for all items, otherwise the index of the last item that matches the predicate. + */ +function findLastIdxMonotonous(array, predicate, startIdx = 0, endIdxEx = array.length) { + let i = startIdx; + let j = endIdxEx; + while (i < j) { + const k = Math.floor((i + j) / 2); + if (predicate(array[k])) { + i = k + 1; + } + else { + j = k; + } + } + return i - 1; +} +/** + * Finds the first item where predicate is true using binary search. + * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`! + * + * @returns `undefined` if no item matches, otherwise the first item that matches the predicate. + */ +function findFirstMonotonous(array, predicate) { + const idx = findFirstIdxMonotonousOrArrLen(array, predicate); + return idx === array.length ? undefined : array[idx]; +} +/** + * Finds the first item where predicate is true using binary search. + * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`! + * + * @returns `endIdxEx` if predicate is false for all items, otherwise the index of the first item that matches the predicate. + */ +function findFirstIdxMonotonousOrArrLen(array, predicate, startIdx = 0, endIdxEx = array.length) { + let i = startIdx; + let j = endIdxEx; + while (i < j) { + const k = Math.floor((i + j) / 2); + if (predicate(array[k])) { + j = k; + } + else { + i = k + 1; + } + } + return i; +} +/** + * Use this when + * * You have a sorted array + * * You query this array with a monotonous predicate to find the last item that has a certain property. + * * You query this array multiple times with monotonous predicates that get weaker and weaker. + */ +class MonotonousArray { + constructor(_array) { + this._array = _array; + this._findLastMonotonousLastIdx = 0; + } + /** + * The predicate must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`! + * For subsequent calls, current predicate must be weaker than (or equal to) the previous predicate, i.e. more entries must be `true`. + */ + findLastMonotonous(predicate) { + if (MonotonousArray.assertInvariants) { + if (this._prevFindLastPredicate) { + for (const item of this._array) { + if (this._prevFindLastPredicate(item) && !predicate(item)) { + throw new Error('MonotonousArray: current predicate must be weaker than (or equal to) the previous predicate.'); + } + } + } + this._prevFindLastPredicate = predicate; + } + const idx = findLastIdxMonotonous(this._array, predicate, this._findLastMonotonousLastIdx); + this._findLastMonotonousLastIdx = idx + 1; + return idx === -1 ? undefined : this._array[idx]; + } +} +MonotonousArray.assertInvariants = false; +/** + * Returns the first item that is equal to or greater than every other item. +*/ +function findFirstMaxBy(array, comparator) { + if (array.length === 0) { + return undefined; + } + let max = array[0]; + for (let i = 1; i < array.length; i++) { + const item = array[i]; + if (comparator(item, max) > 0) { + max = item; + } + } + return max; +} +/** + * Returns the last item that is equal to or greater than every other item. +*/ +function findLastMaxBy(array, comparator) { + if (array.length === 0) { + return undefined; + } + let max = array[0]; + for (let i = 1; i < array.length; i++) { + const item = array[i]; + if (comparator(item, max) >= 0) { + max = item; + } + } + return max; +} +/** + * Returns the first item that is equal to or less than every other item. +*/ +function findFirstMinBy(array, comparator) { + return findFirstMaxBy(array, (a, b) => -comparator(a, b)); +} +function findMaxIdxBy(array, comparator) { + if (array.length === 0) { + return -1; + } + let maxIdx = 0; + for (let i = 1; i < array.length; i++) { + const item = array[i]; + if (comparator(item, array[maxIdx]) > 0) { + maxIdx = i; + } + } + return maxIdx; +} +/** + * Returns the first mapped value of the array which is not undefined. + */ +function mapFindFirst(items, mapFn) { + for (const value of items) { + const mapped = mapFn(value); + if (mapped !== undefined) { + return mapped; + } + } + return undefined; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/assert.js": +/*!*****************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/assert.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ assertFn: () => (/* binding */ assertFn), +/* harmony export */ assertNever: () => (/* binding */ assertNever), +/* harmony export */ checkAdjacentItems: () => (/* binding */ checkAdjacentItems), +/* harmony export */ ok: () => (/* binding */ ok) +/* harmony export */ }); +/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./errors.js */ "./node_modules/monaco-editor/esm/vs/base/common/errors.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * Throws an error with the provided message if the provided value does not evaluate to a true Javascript value. + * + * @deprecated Use `assert(...)` instead. + * This method is usually used like this: + * ```ts + * import * as assert from 'vs/base/common/assert'; + * assert.ok(...); + * ``` + * + * However, `assert` in that example is a user chosen name. + * There is no tooling for generating such an import statement. + * Thus, the `assert(...)` function should be used instead. + */ +function ok(value, message) { + if (!value) { + throw new Error(message ? `Assertion failed (${message})` : 'Assertion Failed'); + } +} +function assertNever(value, message = 'Unreachable') { + throw new Error(message); +} +/** + * condition must be side-effect free! + */ +function assertFn(condition) { + if (!condition()) { + // eslint-disable-next-line no-debugger + debugger; + // Reevaluate `condition` again to make debugging easier + condition(); + (0,_errors_js__WEBPACK_IMPORTED_MODULE_0__.onUnexpectedError)(new _errors_js__WEBPACK_IMPORTED_MODULE_0__.BugIndicatingError('Assertion Failed')); + } +} +function checkAdjacentItems(items, predicate) { + let i = 0; + while (i < items.length - 1) { + const a = items[i]; + const b = items[i + 1]; + if (!predicate(a, b)) { + return false; + } + i++; + } + return true; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/cache.js": +/*!****************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/cache.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ CachedFunction: () => (/* binding */ CachedFunction), +/* harmony export */ LRUCachedFunction: () => (/* binding */ LRUCachedFunction) +/* harmony export */ }); +/** + * Uses a LRU cache to make a given parametrized function cached. + * Caches just the last value. + * The key must be JSON serializable. +*/ +class LRUCachedFunction { + constructor(fn) { + this.fn = fn; + this.lastCache = undefined; + this.lastArgKey = undefined; + } + get(arg) { + const key = JSON.stringify(arg); + if (this.lastArgKey !== key) { + this.lastArgKey = key; + this.lastCache = this.fn(arg); + } + return this.lastCache; + } +} +/** + * Uses an unbounded cache (referential equality) to memoize the results of the given function. +*/ +class CachedFunction { + get cachedValues() { + return this._map; + } + constructor(fn) { + this.fn = fn; + this._map = new Map(); + } + get(arg) { + if (this._map.has(arg)) { + return this._map.get(arg); + } + const value = this.fn(arg); + this._map.set(arg, value); + return value; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/cancellation.js": +/*!***********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/cancellation.js ***! + \***********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ CancellationToken: () => (/* binding */ CancellationToken), +/* harmony export */ CancellationTokenSource: () => (/* binding */ CancellationTokenSource) +/* harmony export */ }); +/* harmony import */ var _event_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./event.js */ "./node_modules/monaco-editor/esm/vs/base/common/event.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +const shortcutEvent = Object.freeze(function (callback, context) { + const handle = setTimeout(callback.bind(context), 0); + return { dispose() { clearTimeout(handle); } }; +}); +var CancellationToken; +(function (CancellationToken) { + function isCancellationToken(thing) { + if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) { + return true; + } + if (thing instanceof MutableToken) { + return true; + } + if (!thing || typeof thing !== 'object') { + return false; + } + return typeof thing.isCancellationRequested === 'boolean' + && typeof thing.onCancellationRequested === 'function'; + } + CancellationToken.isCancellationToken = isCancellationToken; + CancellationToken.None = Object.freeze({ + isCancellationRequested: false, + onCancellationRequested: _event_js__WEBPACK_IMPORTED_MODULE_0__.Event.None + }); + CancellationToken.Cancelled = Object.freeze({ + isCancellationRequested: true, + onCancellationRequested: shortcutEvent + }); +})(CancellationToken || (CancellationToken = {})); +class MutableToken { + constructor() { + this._isCancelled = false; + this._emitter = null; + } + cancel() { + if (!this._isCancelled) { + this._isCancelled = true; + if (this._emitter) { + this._emitter.fire(undefined); + this.dispose(); + } + } + } + get isCancellationRequested() { + return this._isCancelled; + } + get onCancellationRequested() { + if (this._isCancelled) { + return shortcutEvent; + } + if (!this._emitter) { + this._emitter = new _event_js__WEBPACK_IMPORTED_MODULE_0__.Emitter(); + } + return this._emitter.event; + } + dispose() { + if (this._emitter) { + this._emitter.dispose(); + this._emitter = null; + } + } +} +class CancellationTokenSource { + constructor(parent) { + this._token = undefined; + this._parentListener = undefined; + this._parentListener = parent && parent.onCancellationRequested(this.cancel, this); + } + get token() { + if (!this._token) { + // be lazy and create the token only when + // actually needed + this._token = new MutableToken(); + } + return this._token; + } + cancel() { + if (!this._token) { + // save an object by returning the default + // cancelled token when cancellation happens + // before someone asks for the token + this._token = CancellationToken.Cancelled; + } + else if (this._token instanceof MutableToken) { + // actually cancel + this._token.cancel(); + } + } + dispose(cancel = false) { + var _a; + if (cancel) { + this.cancel(); + } + (_a = this._parentListener) === null || _a === void 0 ? void 0 : _a.dispose(); + if (!this._token) { + // ensure to initialize with an empty token if we had none + this._token = CancellationToken.None; + } + else if (this._token instanceof MutableToken) { + // actually dispose + this._token.dispose(); + } + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/codicons.js": +/*!*******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/codicons.js ***! + \*******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Codicon: () => (/* binding */ Codicon), +/* harmony export */ getCodiconFontCharacters: () => (/* binding */ getCodiconFontCharacters) +/* harmony export */ }); +/* harmony import */ var _types_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./types.js */ "./node_modules/monaco-editor/esm/vs/base/common/types.js"); + +const _codiconFontCharacters = Object.create(null); +function register(id, fontCharacter) { + if ((0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isString)(fontCharacter)) { + const val = _codiconFontCharacters[fontCharacter]; + if (val === undefined) { + throw new Error(`${id} references an unknown codicon: ${fontCharacter}`); + } + fontCharacter = val; + } + _codiconFontCharacters[id] = fontCharacter; + return { id }; +} +/** + * Only to be used by the iconRegistry. + */ +function getCodiconFontCharacters() { + return _codiconFontCharacters; +} +/** + * The Codicon library is a set of default icons that are built-in in VS Code. + * + * In the product (outside of base) Codicons should only be used as defaults. In order to have all icons in VS Code + * themeable, component should define new, UI component specific icons using `iconRegistry.registerIcon`. + * In that call a Codicon can be named as default. + */ +const Codicon = { + // built-in icons, with image name + add: register('add', 0xea60), + plus: register('plus', 0xea60), + gistNew: register('gist-new', 0xea60), + repoCreate: register('repo-create', 0xea60), + lightbulb: register('lightbulb', 0xea61), + lightBulb: register('light-bulb', 0xea61), + repo: register('repo', 0xea62), + repoDelete: register('repo-delete', 0xea62), + gistFork: register('gist-fork', 0xea63), + repoForked: register('repo-forked', 0xea63), + gitPullRequest: register('git-pull-request', 0xea64), + gitPullRequestAbandoned: register('git-pull-request-abandoned', 0xea64), + recordKeys: register('record-keys', 0xea65), + keyboard: register('keyboard', 0xea65), + tag: register('tag', 0xea66), + tagAdd: register('tag-add', 0xea66), + tagRemove: register('tag-remove', 0xea66), + gitPullRequestLabel: register('git-pull-request-label', 0xea66), + person: register('person', 0xea67), + personFollow: register('person-follow', 0xea67), + personOutline: register('person-outline', 0xea67), + personFilled: register('person-filled', 0xea67), + gitBranch: register('git-branch', 0xea68), + gitBranchCreate: register('git-branch-create', 0xea68), + gitBranchDelete: register('git-branch-delete', 0xea68), + sourceControl: register('source-control', 0xea68), + mirror: register('mirror', 0xea69), + mirrorPublic: register('mirror-public', 0xea69), + star: register('star', 0xea6a), + starAdd: register('star-add', 0xea6a), + starDelete: register('star-delete', 0xea6a), + starEmpty: register('star-empty', 0xea6a), + comment: register('comment', 0xea6b), + commentAdd: register('comment-add', 0xea6b), + alert: register('alert', 0xea6c), + warning: register('warning', 0xea6c), + search: register('search', 0xea6d), + searchSave: register('search-save', 0xea6d), + logOut: register('log-out', 0xea6e), + signOut: register('sign-out', 0xea6e), + logIn: register('log-in', 0xea6f), + signIn: register('sign-in', 0xea6f), + eye: register('eye', 0xea70), + eyeUnwatch: register('eye-unwatch', 0xea70), + eyeWatch: register('eye-watch', 0xea70), + circleFilled: register('circle-filled', 0xea71), + primitiveDot: register('primitive-dot', 0xea71), + closeDirty: register('close-dirty', 0xea71), + debugBreakpoint: register('debug-breakpoint', 0xea71), + debugBreakpointDisabled: register('debug-breakpoint-disabled', 0xea71), + debugHint: register('debug-hint', 0xea71), + primitiveSquare: register('primitive-square', 0xea72), + edit: register('edit', 0xea73), + pencil: register('pencil', 0xea73), + info: register('info', 0xea74), + issueOpened: register('issue-opened', 0xea74), + gistPrivate: register('gist-private', 0xea75), + gitForkPrivate: register('git-fork-private', 0xea75), + lock: register('lock', 0xea75), + mirrorPrivate: register('mirror-private', 0xea75), + close: register('close', 0xea76), + removeClose: register('remove-close', 0xea76), + x: register('x', 0xea76), + repoSync: register('repo-sync', 0xea77), + sync: register('sync', 0xea77), + clone: register('clone', 0xea78), + desktopDownload: register('desktop-download', 0xea78), + beaker: register('beaker', 0xea79), + microscope: register('microscope', 0xea79), + vm: register('vm', 0xea7a), + deviceDesktop: register('device-desktop', 0xea7a), + file: register('file', 0xea7b), + fileText: register('file-text', 0xea7b), + more: register('more', 0xea7c), + ellipsis: register('ellipsis', 0xea7c), + kebabHorizontal: register('kebab-horizontal', 0xea7c), + mailReply: register('mail-reply', 0xea7d), + reply: register('reply', 0xea7d), + organization: register('organization', 0xea7e), + organizationFilled: register('organization-filled', 0xea7e), + organizationOutline: register('organization-outline', 0xea7e), + newFile: register('new-file', 0xea7f), + fileAdd: register('file-add', 0xea7f), + newFolder: register('new-folder', 0xea80), + fileDirectoryCreate: register('file-directory-create', 0xea80), + trash: register('trash', 0xea81), + trashcan: register('trashcan', 0xea81), + history: register('history', 0xea82), + clock: register('clock', 0xea82), + folder: register('folder', 0xea83), + fileDirectory: register('file-directory', 0xea83), + symbolFolder: register('symbol-folder', 0xea83), + logoGithub: register('logo-github', 0xea84), + markGithub: register('mark-github', 0xea84), + github: register('github', 0xea84), + terminal: register('terminal', 0xea85), + console: register('console', 0xea85), + repl: register('repl', 0xea85), + zap: register('zap', 0xea86), + symbolEvent: register('symbol-event', 0xea86), + error: register('error', 0xea87), + stop: register('stop', 0xea87), + variable: register('variable', 0xea88), + symbolVariable: register('symbol-variable', 0xea88), + array: register('array', 0xea8a), + symbolArray: register('symbol-array', 0xea8a), + symbolModule: register('symbol-module', 0xea8b), + symbolPackage: register('symbol-package', 0xea8b), + symbolNamespace: register('symbol-namespace', 0xea8b), + symbolObject: register('symbol-object', 0xea8b), + symbolMethod: register('symbol-method', 0xea8c), + symbolFunction: register('symbol-function', 0xea8c), + symbolConstructor: register('symbol-constructor', 0xea8c), + symbolBoolean: register('symbol-boolean', 0xea8f), + symbolNull: register('symbol-null', 0xea8f), + symbolNumeric: register('symbol-numeric', 0xea90), + symbolNumber: register('symbol-number', 0xea90), + symbolStructure: register('symbol-structure', 0xea91), + symbolStruct: register('symbol-struct', 0xea91), + symbolParameter: register('symbol-parameter', 0xea92), + symbolTypeParameter: register('symbol-type-parameter', 0xea92), + symbolKey: register('symbol-key', 0xea93), + symbolText: register('symbol-text', 0xea93), + symbolReference: register('symbol-reference', 0xea94), + goToFile: register('go-to-file', 0xea94), + symbolEnum: register('symbol-enum', 0xea95), + symbolValue: register('symbol-value', 0xea95), + symbolRuler: register('symbol-ruler', 0xea96), + symbolUnit: register('symbol-unit', 0xea96), + activateBreakpoints: register('activate-breakpoints', 0xea97), + archive: register('archive', 0xea98), + arrowBoth: register('arrow-both', 0xea99), + arrowDown: register('arrow-down', 0xea9a), + arrowLeft: register('arrow-left', 0xea9b), + arrowRight: register('arrow-right', 0xea9c), + arrowSmallDown: register('arrow-small-down', 0xea9d), + arrowSmallLeft: register('arrow-small-left', 0xea9e), + arrowSmallRight: register('arrow-small-right', 0xea9f), + arrowSmallUp: register('arrow-small-up', 0xeaa0), + arrowUp: register('arrow-up', 0xeaa1), + bell: register('bell', 0xeaa2), + bold: register('bold', 0xeaa3), + book: register('book', 0xeaa4), + bookmark: register('bookmark', 0xeaa5), + debugBreakpointConditionalUnverified: register('debug-breakpoint-conditional-unverified', 0xeaa6), + debugBreakpointConditional: register('debug-breakpoint-conditional', 0xeaa7), + debugBreakpointConditionalDisabled: register('debug-breakpoint-conditional-disabled', 0xeaa7), + debugBreakpointDataUnverified: register('debug-breakpoint-data-unverified', 0xeaa8), + debugBreakpointData: register('debug-breakpoint-data', 0xeaa9), + debugBreakpointDataDisabled: register('debug-breakpoint-data-disabled', 0xeaa9), + debugBreakpointLogUnverified: register('debug-breakpoint-log-unverified', 0xeaaa), + debugBreakpointLog: register('debug-breakpoint-log', 0xeaab), + debugBreakpointLogDisabled: register('debug-breakpoint-log-disabled', 0xeaab), + briefcase: register('briefcase', 0xeaac), + broadcast: register('broadcast', 0xeaad), + browser: register('browser', 0xeaae), + bug: register('bug', 0xeaaf), + calendar: register('calendar', 0xeab0), + caseSensitive: register('case-sensitive', 0xeab1), + check: register('check', 0xeab2), + checklist: register('checklist', 0xeab3), + chevronDown: register('chevron-down', 0xeab4), + dropDownButton: register('drop-down-button', 0xeab4), + chevronLeft: register('chevron-left', 0xeab5), + chevronRight: register('chevron-right', 0xeab6), + chevronUp: register('chevron-up', 0xeab7), + chromeClose: register('chrome-close', 0xeab8), + chromeMaximize: register('chrome-maximize', 0xeab9), + chromeMinimize: register('chrome-minimize', 0xeaba), + chromeRestore: register('chrome-restore', 0xeabb), + circle: register('circle', 0xeabc), + circleOutline: register('circle-outline', 0xeabc), + debugBreakpointUnverified: register('debug-breakpoint-unverified', 0xeabc), + circleSlash: register('circle-slash', 0xeabd), + circuitBoard: register('circuit-board', 0xeabe), + clearAll: register('clear-all', 0xeabf), + clippy: register('clippy', 0xeac0), + closeAll: register('close-all', 0xeac1), + cloudDownload: register('cloud-download', 0xeac2), + cloudUpload: register('cloud-upload', 0xeac3), + code: register('code', 0xeac4), + collapseAll: register('collapse-all', 0xeac5), + colorMode: register('color-mode', 0xeac6), + commentDiscussion: register('comment-discussion', 0xeac7), + compareChanges: register('compare-changes', 0xeafd), + creditCard: register('credit-card', 0xeac9), + dash: register('dash', 0xeacc), + dashboard: register('dashboard', 0xeacd), + database: register('database', 0xeace), + debugContinue: register('debug-continue', 0xeacf), + debugDisconnect: register('debug-disconnect', 0xead0), + debugPause: register('debug-pause', 0xead1), + debugRestart: register('debug-restart', 0xead2), + debugStart: register('debug-start', 0xead3), + debugStepInto: register('debug-step-into', 0xead4), + debugStepOut: register('debug-step-out', 0xead5), + debugStepOver: register('debug-step-over', 0xead6), + debugStop: register('debug-stop', 0xead7), + debug: register('debug', 0xead8), + deviceCameraVideo: register('device-camera-video', 0xead9), + deviceCamera: register('device-camera', 0xeada), + deviceMobile: register('device-mobile', 0xeadb), + diffAdded: register('diff-added', 0xeadc), + diffIgnored: register('diff-ignored', 0xeadd), + diffModified: register('diff-modified', 0xeade), + diffRemoved: register('diff-removed', 0xeadf), + diffRenamed: register('diff-renamed', 0xeae0), + diff: register('diff', 0xeae1), + discard: register('discard', 0xeae2), + editorLayout: register('editor-layout', 0xeae3), + emptyWindow: register('empty-window', 0xeae4), + exclude: register('exclude', 0xeae5), + extensions: register('extensions', 0xeae6), + eyeClosed: register('eye-closed', 0xeae7), + fileBinary: register('file-binary', 0xeae8), + fileCode: register('file-code', 0xeae9), + fileMedia: register('file-media', 0xeaea), + filePdf: register('file-pdf', 0xeaeb), + fileSubmodule: register('file-submodule', 0xeaec), + fileSymlinkDirectory: register('file-symlink-directory', 0xeaed), + fileSymlinkFile: register('file-symlink-file', 0xeaee), + fileZip: register('file-zip', 0xeaef), + files: register('files', 0xeaf0), + filter: register('filter', 0xeaf1), + flame: register('flame', 0xeaf2), + foldDown: register('fold-down', 0xeaf3), + foldUp: register('fold-up', 0xeaf4), + fold: register('fold', 0xeaf5), + folderActive: register('folder-active', 0xeaf6), + folderOpened: register('folder-opened', 0xeaf7), + gear: register('gear', 0xeaf8), + gift: register('gift', 0xeaf9), + gistSecret: register('gist-secret', 0xeafa), + gist: register('gist', 0xeafb), + gitCommit: register('git-commit', 0xeafc), + gitCompare: register('git-compare', 0xeafd), + gitMerge: register('git-merge', 0xeafe), + githubAction: register('github-action', 0xeaff), + githubAlt: register('github-alt', 0xeb00), + globe: register('globe', 0xeb01), + grabber: register('grabber', 0xeb02), + graph: register('graph', 0xeb03), + gripper: register('gripper', 0xeb04), + heart: register('heart', 0xeb05), + home: register('home', 0xeb06), + horizontalRule: register('horizontal-rule', 0xeb07), + hubot: register('hubot', 0xeb08), + inbox: register('inbox', 0xeb09), + issueClosed: register('issue-closed', 0xeba4), + issueReopened: register('issue-reopened', 0xeb0b), + issues: register('issues', 0xeb0c), + italic: register('italic', 0xeb0d), + jersey: register('jersey', 0xeb0e), + json: register('json', 0xeb0f), + bracket: register('bracket', 0xeb0f), + kebabVertical: register('kebab-vertical', 0xeb10), + key: register('key', 0xeb11), + law: register('law', 0xeb12), + lightbulbAutofix: register('lightbulb-autofix', 0xeb13), + linkExternal: register('link-external', 0xeb14), + link: register('link', 0xeb15), + listOrdered: register('list-ordered', 0xeb16), + listUnordered: register('list-unordered', 0xeb17), + liveShare: register('live-share', 0xeb18), + loading: register('loading', 0xeb19), + location: register('location', 0xeb1a), + mailRead: register('mail-read', 0xeb1b), + mail: register('mail', 0xeb1c), + markdown: register('markdown', 0xeb1d), + megaphone: register('megaphone', 0xeb1e), + mention: register('mention', 0xeb1f), + milestone: register('milestone', 0xeb20), + gitPullRequestMilestone: register('git-pull-request-milestone', 0xeb20), + mortarBoard: register('mortar-board', 0xeb21), + move: register('move', 0xeb22), + multipleWindows: register('multiple-windows', 0xeb23), + mute: register('mute', 0xeb24), + noNewline: register('no-newline', 0xeb25), + note: register('note', 0xeb26), + octoface: register('octoface', 0xeb27), + openPreview: register('open-preview', 0xeb28), + package: register('package', 0xeb29), + paintcan: register('paintcan', 0xeb2a), + pin: register('pin', 0xeb2b), + play: register('play', 0xeb2c), + run: register('run', 0xeb2c), + plug: register('plug', 0xeb2d), + preserveCase: register('preserve-case', 0xeb2e), + preview: register('preview', 0xeb2f), + project: register('project', 0xeb30), + pulse: register('pulse', 0xeb31), + question: register('question', 0xeb32), + quote: register('quote', 0xeb33), + radioTower: register('radio-tower', 0xeb34), + reactions: register('reactions', 0xeb35), + references: register('references', 0xeb36), + refresh: register('refresh', 0xeb37), + regex: register('regex', 0xeb38), + remoteExplorer: register('remote-explorer', 0xeb39), + remote: register('remote', 0xeb3a), + remove: register('remove', 0xeb3b), + replaceAll: register('replace-all', 0xeb3c), + replace: register('replace', 0xeb3d), + repoClone: register('repo-clone', 0xeb3e), + repoForcePush: register('repo-force-push', 0xeb3f), + repoPull: register('repo-pull', 0xeb40), + repoPush: register('repo-push', 0xeb41), + report: register('report', 0xeb42), + requestChanges: register('request-changes', 0xeb43), + rocket: register('rocket', 0xeb44), + rootFolderOpened: register('root-folder-opened', 0xeb45), + rootFolder: register('root-folder', 0xeb46), + rss: register('rss', 0xeb47), + ruby: register('ruby', 0xeb48), + saveAll: register('save-all', 0xeb49), + saveAs: register('save-as', 0xeb4a), + save: register('save', 0xeb4b), + screenFull: register('screen-full', 0xeb4c), + screenNormal: register('screen-normal', 0xeb4d), + searchStop: register('search-stop', 0xeb4e), + server: register('server', 0xeb50), + settingsGear: register('settings-gear', 0xeb51), + settings: register('settings', 0xeb52), + shield: register('shield', 0xeb53), + smiley: register('smiley', 0xeb54), + sortPrecedence: register('sort-precedence', 0xeb55), + splitHorizontal: register('split-horizontal', 0xeb56), + splitVertical: register('split-vertical', 0xeb57), + squirrel: register('squirrel', 0xeb58), + starFull: register('star-full', 0xeb59), + starHalf: register('star-half', 0xeb5a), + symbolClass: register('symbol-class', 0xeb5b), + symbolColor: register('symbol-color', 0xeb5c), + symbolCustomColor: register('symbol-customcolor', 0xeb5c), + symbolConstant: register('symbol-constant', 0xeb5d), + symbolEnumMember: register('symbol-enum-member', 0xeb5e), + symbolField: register('symbol-field', 0xeb5f), + symbolFile: register('symbol-file', 0xeb60), + symbolInterface: register('symbol-interface', 0xeb61), + symbolKeyword: register('symbol-keyword', 0xeb62), + symbolMisc: register('symbol-misc', 0xeb63), + symbolOperator: register('symbol-operator', 0xeb64), + symbolProperty: register('symbol-property', 0xeb65), + wrench: register('wrench', 0xeb65), + wrenchSubaction: register('wrench-subaction', 0xeb65), + symbolSnippet: register('symbol-snippet', 0xeb66), + tasklist: register('tasklist', 0xeb67), + telescope: register('telescope', 0xeb68), + textSize: register('text-size', 0xeb69), + threeBars: register('three-bars', 0xeb6a), + thumbsdown: register('thumbsdown', 0xeb6b), + thumbsup: register('thumbsup', 0xeb6c), + tools: register('tools', 0xeb6d), + triangleDown: register('triangle-down', 0xeb6e), + triangleLeft: register('triangle-left', 0xeb6f), + triangleRight: register('triangle-right', 0xeb70), + triangleUp: register('triangle-up', 0xeb71), + twitter: register('twitter', 0xeb72), + unfold: register('unfold', 0xeb73), + unlock: register('unlock', 0xeb74), + unmute: register('unmute', 0xeb75), + unverified: register('unverified', 0xeb76), + verified: register('verified', 0xeb77), + versions: register('versions', 0xeb78), + vmActive: register('vm-active', 0xeb79), + vmOutline: register('vm-outline', 0xeb7a), + vmRunning: register('vm-running', 0xeb7b), + watch: register('watch', 0xeb7c), + whitespace: register('whitespace', 0xeb7d), + wholeWord: register('whole-word', 0xeb7e), + window: register('window', 0xeb7f), + wordWrap: register('word-wrap', 0xeb80), + zoomIn: register('zoom-in', 0xeb81), + zoomOut: register('zoom-out', 0xeb82), + listFilter: register('list-filter', 0xeb83), + listFlat: register('list-flat', 0xeb84), + listSelection: register('list-selection', 0xeb85), + selection: register('selection', 0xeb85), + listTree: register('list-tree', 0xeb86), + debugBreakpointFunctionUnverified: register('debug-breakpoint-function-unverified', 0xeb87), + debugBreakpointFunction: register('debug-breakpoint-function', 0xeb88), + debugBreakpointFunctionDisabled: register('debug-breakpoint-function-disabled', 0xeb88), + debugStackframeActive: register('debug-stackframe-active', 0xeb89), + circleSmallFilled: register('circle-small-filled', 0xeb8a), + debugStackframeDot: register('debug-stackframe-dot', 0xeb8a), + debugStackframe: register('debug-stackframe', 0xeb8b), + debugStackframeFocused: register('debug-stackframe-focused', 0xeb8b), + debugBreakpointUnsupported: register('debug-breakpoint-unsupported', 0xeb8c), + symbolString: register('symbol-string', 0xeb8d), + debugReverseContinue: register('debug-reverse-continue', 0xeb8e), + debugStepBack: register('debug-step-back', 0xeb8f), + debugRestartFrame: register('debug-restart-frame', 0xeb90), + callIncoming: register('call-incoming', 0xeb92), + callOutgoing: register('call-outgoing', 0xeb93), + menu: register('menu', 0xeb94), + expandAll: register('expand-all', 0xeb95), + feedback: register('feedback', 0xeb96), + gitPullRequestReviewer: register('git-pull-request-reviewer', 0xeb96), + groupByRefType: register('group-by-ref-type', 0xeb97), + ungroupByRefType: register('ungroup-by-ref-type', 0xeb98), + account: register('account', 0xeb99), + gitPullRequestAssignee: register('git-pull-request-assignee', 0xeb99), + bellDot: register('bell-dot', 0xeb9a), + debugConsole: register('debug-console', 0xeb9b), + library: register('library', 0xeb9c), + output: register('output', 0xeb9d), + runAll: register('run-all', 0xeb9e), + syncIgnored: register('sync-ignored', 0xeb9f), + pinned: register('pinned', 0xeba0), + githubInverted: register('github-inverted', 0xeba1), + debugAlt: register('debug-alt', 0xeb91), + serverProcess: register('server-process', 0xeba2), + serverEnvironment: register('server-environment', 0xeba3), + pass: register('pass', 0xeba4), + stopCircle: register('stop-circle', 0xeba5), + playCircle: register('play-circle', 0xeba6), + record: register('record', 0xeba7), + debugAltSmall: register('debug-alt-small', 0xeba8), + vmConnect: register('vm-connect', 0xeba9), + cloud: register('cloud', 0xebaa), + merge: register('merge', 0xebab), + exportIcon: register('export', 0xebac), + graphLeft: register('graph-left', 0xebad), + magnet: register('magnet', 0xebae), + notebook: register('notebook', 0xebaf), + redo: register('redo', 0xebb0), + checkAll: register('check-all', 0xebb1), + pinnedDirty: register('pinned-dirty', 0xebb2), + passFilled: register('pass-filled', 0xebb3), + circleLargeFilled: register('circle-large-filled', 0xebb4), + circleLarge: register('circle-large', 0xebb5), + circleLargeOutline: register('circle-large-outline', 0xebb5), + combine: register('combine', 0xebb6), + gather: register('gather', 0xebb6), + table: register('table', 0xebb7), + variableGroup: register('variable-group', 0xebb8), + typeHierarchy: register('type-hierarchy', 0xebb9), + typeHierarchySub: register('type-hierarchy-sub', 0xebba), + typeHierarchySuper: register('type-hierarchy-super', 0xebbb), + gitPullRequestCreate: register('git-pull-request-create', 0xebbc), + runAbove: register('run-above', 0xebbd), + runBelow: register('run-below', 0xebbe), + notebookTemplate: register('notebook-template', 0xebbf), + debugRerun: register('debug-rerun', 0xebc0), + workspaceTrusted: register('workspace-trusted', 0xebc1), + workspaceUntrusted: register('workspace-untrusted', 0xebc2), + workspaceUnspecified: register('workspace-unspecified', 0xebc3), + terminalCmd: register('terminal-cmd', 0xebc4), + terminalDebian: register('terminal-debian', 0xebc5), + terminalLinux: register('terminal-linux', 0xebc6), + terminalPowershell: register('terminal-powershell', 0xebc7), + terminalTmux: register('terminal-tmux', 0xebc8), + terminalUbuntu: register('terminal-ubuntu', 0xebc9), + terminalBash: register('terminal-bash', 0xebca), + arrowSwap: register('arrow-swap', 0xebcb), + copy: register('copy', 0xebcc), + personAdd: register('person-add', 0xebcd), + filterFilled: register('filter-filled', 0xebce), + wand: register('wand', 0xebcf), + debugLineByLine: register('debug-line-by-line', 0xebd0), + inspect: register('inspect', 0xebd1), + layers: register('layers', 0xebd2), + layersDot: register('layers-dot', 0xebd3), + layersActive: register('layers-active', 0xebd4), + compass: register('compass', 0xebd5), + compassDot: register('compass-dot', 0xebd6), + compassActive: register('compass-active', 0xebd7), + azure: register('azure', 0xebd8), + issueDraft: register('issue-draft', 0xebd9), + gitPullRequestClosed: register('git-pull-request-closed', 0xebda), + gitPullRequestDraft: register('git-pull-request-draft', 0xebdb), + debugAll: register('debug-all', 0xebdc), + debugCoverage: register('debug-coverage', 0xebdd), + runErrors: register('run-errors', 0xebde), + folderLibrary: register('folder-library', 0xebdf), + debugContinueSmall: register('debug-continue-small', 0xebe0), + beakerStop: register('beaker-stop', 0xebe1), + graphLine: register('graph-line', 0xebe2), + graphScatter: register('graph-scatter', 0xebe3), + pieChart: register('pie-chart', 0xebe4), + bracketDot: register('bracket-dot', 0xebe5), + bracketError: register('bracket-error', 0xebe6), + lockSmall: register('lock-small', 0xebe7), + azureDevops: register('azure-devops', 0xebe8), + verifiedFilled: register('verified-filled', 0xebe9), + newLine: register('newline', 0xebea), + layout: register('layout', 0xebeb), + layoutActivitybarLeft: register('layout-activitybar-left', 0xebec), + layoutActivitybarRight: register('layout-activitybar-right', 0xebed), + layoutPanelLeft: register('layout-panel-left', 0xebee), + layoutPanelCenter: register('layout-panel-center', 0xebef), + layoutPanelJustify: register('layout-panel-justify', 0xebf0), + layoutPanelRight: register('layout-panel-right', 0xebf1), + layoutPanel: register('layout-panel', 0xebf2), + layoutSidebarLeft: register('layout-sidebar-left', 0xebf3), + layoutSidebarRight: register('layout-sidebar-right', 0xebf4), + layoutStatusbar: register('layout-statusbar', 0xebf5), + layoutMenubar: register('layout-menubar', 0xebf6), + layoutCentered: register('layout-centered', 0xebf7), + layoutSidebarRightOff: register('layout-sidebar-right-off', 0xec00), + layoutPanelOff: register('layout-panel-off', 0xec01), + layoutSidebarLeftOff: register('layout-sidebar-left-off', 0xec02), + target: register('target', 0xebf8), + indent: register('indent', 0xebf9), + recordSmall: register('record-small', 0xebfa), + errorSmall: register('error-small', 0xebfb), + arrowCircleDown: register('arrow-circle-down', 0xebfc), + arrowCircleLeft: register('arrow-circle-left', 0xebfd), + arrowCircleRight: register('arrow-circle-right', 0xebfe), + arrowCircleUp: register('arrow-circle-up', 0xebff), + heartFilled: register('heart-filled', 0xec04), + map: register('map', 0xec05), + mapFilled: register('map-filled', 0xec06), + circleSmall: register('circle-small', 0xec07), + bellSlash: register('bell-slash', 0xec08), + bellSlashDot: register('bell-slash-dot', 0xec09), + commentUnresolved: register('comment-unresolved', 0xec0a), + gitPullRequestGoToChanges: register('git-pull-request-go-to-changes', 0xec0b), + gitPullRequestNewChanges: register('git-pull-request-new-changes', 0xec0c), + searchFuzzy: register('search-fuzzy', 0xec0d), + commentDraft: register('comment-draft', 0xec0e), + send: register('send', 0xec0f), + sparkle: register('sparkle', 0xec10), + insert: register('insert', 0xec11), + mic: register('mic', 0xec12), + thumbsDownFilled: register('thumbsdown-filled', 0xec13), + thumbsUpFilled: register('thumbsup-filled', 0xec14), + coffee: register('coffee', 0xec15), + snake: register('snake', 0xec16), + game: register('game', 0xec17), + vr: register('vr', 0xec18), + chip: register('chip', 0xec19), + piano: register('piano', 0xec1a), + music: register('music', 0xec1b), + micFilled: register('mic-filled', 0xec1c), + gitFetch: register('git-fetch', 0xec1d), + copilot: register('copilot', 0xec1e), + lightbulbSparkle: register('lightbulb-sparkle', 0xec1f), + lightbulbSparkleAutofix: register('lightbulb-sparkle-autofix', 0xec1f), + robot: register('robot', 0xec20), + sparkleFilled: register('sparkle-filled', 0xec21), + diffSingle: register('diff-single', 0xec22), + diffMultiple: register('diff-multiple', 0xec23), + // derived icons, that could become separate icons + dialogError: register('dialog-error', 'error'), + dialogWarning: register('dialog-warning', 'warning'), + dialogInfo: register('dialog-info', 'info'), + dialogClose: register('dialog-close', 'close'), + treeItemExpanded: register('tree-item-expanded', 'chevron-down'), // collapsed is done with rotation + treeFilterOnTypeOn: register('tree-filter-on-type-on', 'list-filter'), + treeFilterOnTypeOff: register('tree-filter-on-type-off', 'list-selection'), + treeFilterClear: register('tree-filter-clear', 'close'), + treeItemLoading: register('tree-item-loading', 'loading'), + menuSelection: register('menu-selection', 'check'), + menuSubmenu: register('menu-submenu', 'chevron-right'), + menuBarMore: register('menubar-more', 'more'), + scrollbarButtonLeft: register('scrollbar-button-left', 'triangle-left'), + scrollbarButtonRight: register('scrollbar-button-right', 'triangle-right'), + scrollbarButtonUp: register('scrollbar-button-up', 'triangle-up'), + scrollbarButtonDown: register('scrollbar-button-down', 'triangle-down'), + toolBarMore: register('toolbar-more', 'more'), + quickInputBack: register('quick-input-back', 'arrow-left') +}; + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/color.js": +/*!****************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/color.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Color: () => (/* binding */ Color), +/* harmony export */ HSLA: () => (/* binding */ HSLA), +/* harmony export */ HSVA: () => (/* binding */ HSVA), +/* harmony export */ RGBA: () => (/* binding */ RGBA) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +function roundFloat(number, decimalPoints) { + const decimal = Math.pow(10, decimalPoints); + return Math.round(number * decimal) / decimal; +} +class RGBA { + constructor(r, g, b, a = 1) { + this._rgbaBrand = undefined; + this.r = Math.min(255, Math.max(0, r)) | 0; + this.g = Math.min(255, Math.max(0, g)) | 0; + this.b = Math.min(255, Math.max(0, b)) | 0; + this.a = roundFloat(Math.max(Math.min(1, a), 0), 3); + } + static equals(a, b) { + return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a; + } +} +class HSLA { + constructor(h, s, l, a) { + this._hslaBrand = undefined; + this.h = Math.max(Math.min(360, h), 0) | 0; + this.s = roundFloat(Math.max(Math.min(1, s), 0), 3); + this.l = roundFloat(Math.max(Math.min(1, l), 0), 3); + this.a = roundFloat(Math.max(Math.min(1, a), 0), 3); + } + static equals(a, b) { + return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a; + } + /** + * Converts an RGB color value to HSL. Conversion formula + * adapted from http://en.wikipedia.org/wiki/HSL_color_space. + * Assumes r, g, and b are contained in the set [0, 255] and + * returns h in the set [0, 360], s, and l in the set [0, 1]. + */ + static fromRGBA(rgba) { + const r = rgba.r / 255; + const g = rgba.g / 255; + const b = rgba.b / 255; + const a = rgba.a; + const max = Math.max(r, g, b); + const min = Math.min(r, g, b); + let h = 0; + let s = 0; + const l = (min + max) / 2; + const chroma = max - min; + if (chroma > 0) { + s = Math.min((l <= 0.5 ? chroma / (2 * l) : chroma / (2 - (2 * l))), 1); + switch (max) { + case r: + h = (g - b) / chroma + (g < b ? 6 : 0); + break; + case g: + h = (b - r) / chroma + 2; + break; + case b: + h = (r - g) / chroma + 4; + break; + } + h *= 60; + h = Math.round(h); + } + return new HSLA(h, s, l, a); + } + static _hue2rgb(p, q, t) { + if (t < 0) { + t += 1; + } + if (t > 1) { + t -= 1; + } + if (t < 1 / 6) { + return p + (q - p) * 6 * t; + } + if (t < 1 / 2) { + return q; + } + if (t < 2 / 3) { + return p + (q - p) * (2 / 3 - t) * 6; + } + return p; + } + /** + * Converts an HSL color value to RGB. Conversion formula + * adapted from http://en.wikipedia.org/wiki/HSL_color_space. + * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and + * returns r, g, and b in the set [0, 255]. + */ + static toRGBA(hsla) { + const h = hsla.h / 360; + const { s, l, a } = hsla; + let r, g, b; + if (s === 0) { + r = g = b = l; // achromatic + } + else { + const q = l < 0.5 ? l * (1 + s) : l + s - l * s; + const p = 2 * l - q; + r = HSLA._hue2rgb(p, q, h + 1 / 3); + g = HSLA._hue2rgb(p, q, h); + b = HSLA._hue2rgb(p, q, h - 1 / 3); + } + return new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a); + } +} +class HSVA { + constructor(h, s, v, a) { + this._hsvaBrand = undefined; + this.h = Math.max(Math.min(360, h), 0) | 0; + this.s = roundFloat(Math.max(Math.min(1, s), 0), 3); + this.v = roundFloat(Math.max(Math.min(1, v), 0), 3); + this.a = roundFloat(Math.max(Math.min(1, a), 0), 3); + } + static equals(a, b) { + return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a; + } + // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm + static fromRGBA(rgba) { + const r = rgba.r / 255; + const g = rgba.g / 255; + const b = rgba.b / 255; + const cmax = Math.max(r, g, b); + const cmin = Math.min(r, g, b); + const delta = cmax - cmin; + const s = cmax === 0 ? 0 : (delta / cmax); + let m; + if (delta === 0) { + m = 0; + } + else if (cmax === r) { + m = ((((g - b) / delta) % 6) + 6) % 6; + } + else if (cmax === g) { + m = ((b - r) / delta) + 2; + } + else { + m = ((r - g) / delta) + 4; + } + return new HSVA(Math.round(m * 60), s, cmax, rgba.a); + } + // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm + static toRGBA(hsva) { + const { h, s, v, a } = hsva; + const c = v * s; + const x = c * (1 - Math.abs((h / 60) % 2 - 1)); + const m = v - c; + let [r, g, b] = [0, 0, 0]; + if (h < 60) { + r = c; + g = x; + } + else if (h < 120) { + r = x; + g = c; + } + else if (h < 180) { + g = c; + b = x; + } + else if (h < 240) { + g = x; + b = c; + } + else if (h < 300) { + r = x; + b = c; + } + else if (h <= 360) { + r = c; + b = x; + } + r = Math.round((r + m) * 255); + g = Math.round((g + m) * 255); + b = Math.round((b + m) * 255); + return new RGBA(r, g, b, a); + } +} +class Color { + static fromHex(hex) { + return Color.Format.CSS.parseHex(hex) || Color.red; + } + static equals(a, b) { + if (!a && !b) { + return true; + } + if (!a || !b) { + return false; + } + return a.equals(b); + } + get hsla() { + if (this._hsla) { + return this._hsla; + } + else { + return HSLA.fromRGBA(this.rgba); + } + } + get hsva() { + if (this._hsva) { + return this._hsva; + } + return HSVA.fromRGBA(this.rgba); + } + constructor(arg) { + if (!arg) { + throw new Error('Color needs a value'); + } + else if (arg instanceof RGBA) { + this.rgba = arg; + } + else if (arg instanceof HSLA) { + this._hsla = arg; + this.rgba = HSLA.toRGBA(arg); + } + else if (arg instanceof HSVA) { + this._hsva = arg; + this.rgba = HSVA.toRGBA(arg); + } + else { + throw new Error('Invalid color ctor argument'); + } + } + equals(other) { + return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva); + } + /** + * http://www.w3.org/TR/WCAG20/#relativeluminancedef + * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white. + */ + getRelativeLuminance() { + const R = Color._relativeLuminanceForComponent(this.rgba.r); + const G = Color._relativeLuminanceForComponent(this.rgba.g); + const B = Color._relativeLuminanceForComponent(this.rgba.b); + const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B; + return roundFloat(luminance, 4); + } + static _relativeLuminanceForComponent(color) { + const c = color / 255; + return (c <= 0.03928) ? c / 12.92 : Math.pow(((c + 0.055) / 1.055), 2.4); + } + /** + * http://24ways.org/2010/calculating-color-contrast + * Return 'true' if lighter color otherwise 'false' + */ + isLighter() { + const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000; + return yiq >= 128; + } + isLighterThan(another) { + const lum1 = this.getRelativeLuminance(); + const lum2 = another.getRelativeLuminance(); + return lum1 > lum2; + } + isDarkerThan(another) { + const lum1 = this.getRelativeLuminance(); + const lum2 = another.getRelativeLuminance(); + return lum1 < lum2; + } + lighten(factor) { + return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a)); + } + darken(factor) { + return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a)); + } + transparent(factor) { + const { r, g, b, a } = this.rgba; + return new Color(new RGBA(r, g, b, a * factor)); + } + isTransparent() { + return this.rgba.a === 0; + } + isOpaque() { + return this.rgba.a === 1; + } + opposite() { + return new Color(new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a)); + } + makeOpaque(opaqueBackground) { + if (this.isOpaque() || opaqueBackground.rgba.a !== 1) { + // only allow to blend onto a non-opaque color onto a opaque color + return this; + } + const { r, g, b, a } = this.rgba; + // https://stackoverflow.com/questions/12228548/finding-equivalent-color-with-opacity + return new Color(new RGBA(opaqueBackground.rgba.r - a * (opaqueBackground.rgba.r - r), opaqueBackground.rgba.g - a * (opaqueBackground.rgba.g - g), opaqueBackground.rgba.b - a * (opaqueBackground.rgba.b - b), 1)); + } + toString() { + if (!this._toString) { + this._toString = Color.Format.CSS.format(this); + } + return this._toString; + } + static getLighterColor(of, relative, factor) { + if (of.isLighterThan(relative)) { + return of; + } + factor = factor ? factor : 0.5; + const lum1 = of.getRelativeLuminance(); + const lum2 = relative.getRelativeLuminance(); + factor = factor * (lum2 - lum1) / lum2; + return of.lighten(factor); + } + static getDarkerColor(of, relative, factor) { + if (of.isDarkerThan(relative)) { + return of; + } + factor = factor ? factor : 0.5; + const lum1 = of.getRelativeLuminance(); + const lum2 = relative.getRelativeLuminance(); + factor = factor * (lum1 - lum2) / lum1; + return of.darken(factor); + } +} +Color.white = new Color(new RGBA(255, 255, 255, 1)); +Color.black = new Color(new RGBA(0, 0, 0, 1)); +Color.red = new Color(new RGBA(255, 0, 0, 1)); +Color.blue = new Color(new RGBA(0, 0, 255, 1)); +Color.green = new Color(new RGBA(0, 255, 0, 1)); +Color.cyan = new Color(new RGBA(0, 255, 255, 1)); +Color.lightgrey = new Color(new RGBA(211, 211, 211, 1)); +Color.transparent = new Color(new RGBA(0, 0, 0, 0)); +(function (Color) { + let Format; + (function (Format) { + let CSS; + (function (CSS) { + function formatRGB(color) { + if (color.rgba.a === 1) { + return `rgb(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b})`; + } + return Color.Format.CSS.formatRGBA(color); + } + CSS.formatRGB = formatRGB; + function formatRGBA(color) { + return `rgba(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b}, ${+(color.rgba.a).toFixed(2)})`; + } + CSS.formatRGBA = formatRGBA; + function formatHSL(color) { + if (color.hsla.a === 1) { + return `hsl(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%)`; + } + return Color.Format.CSS.formatHSLA(color); + } + CSS.formatHSL = formatHSL; + function formatHSLA(color) { + return `hsla(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%, ${color.hsla.a.toFixed(2)})`; + } + CSS.formatHSLA = formatHSLA; + function _toTwoDigitHex(n) { + const r = n.toString(16); + return r.length !== 2 ? '0' + r : r; + } + /** + * Formats the color as #RRGGBB + */ + function formatHex(color) { + return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}`; + } + CSS.formatHex = formatHex; + /** + * Formats the color as #RRGGBBAA + * If 'compact' is set, colors without transparancy will be printed as #RRGGBB + */ + function formatHexA(color, compact = false) { + if (compact && color.rgba.a === 1) { + return Color.Format.CSS.formatHex(color); + } + return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}${_toTwoDigitHex(Math.round(color.rgba.a * 255))}`; + } + CSS.formatHexA = formatHexA; + /** + * The default format will use HEX if opaque and RGBA otherwise. + */ + function format(color) { + if (color.isOpaque()) { + return Color.Format.CSS.formatHex(color); + } + return Color.Format.CSS.formatRGBA(color); + } + CSS.format = format; + /** + * Converts an Hex color value to a Color. + * returns r, g, and b are contained in the set [0, 255] + * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA). + */ + function parseHex(hex) { + const length = hex.length; + if (length === 0) { + // Invalid color + return null; + } + if (hex.charCodeAt(0) !== 35 /* CharCode.Hash */) { + // Does not begin with a # + return null; + } + if (length === 7) { + // #RRGGBB format + const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2)); + const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4)); + const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6)); + return new Color(new RGBA(r, g, b, 1)); + } + if (length === 9) { + // #RRGGBBAA format + const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2)); + const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4)); + const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6)); + const a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8)); + return new Color(new RGBA(r, g, b, a / 255)); + } + if (length === 4) { + // #RGB format + const r = _parseHexDigit(hex.charCodeAt(1)); + const g = _parseHexDigit(hex.charCodeAt(2)); + const b = _parseHexDigit(hex.charCodeAt(3)); + return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b)); + } + if (length === 5) { + // #RGBA format + const r = _parseHexDigit(hex.charCodeAt(1)); + const g = _parseHexDigit(hex.charCodeAt(2)); + const b = _parseHexDigit(hex.charCodeAt(3)); + const a = _parseHexDigit(hex.charCodeAt(4)); + return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255)); + } + // Invalid color + return null; + } + CSS.parseHex = parseHex; + function _parseHexDigit(charCode) { + switch (charCode) { + case 48 /* CharCode.Digit0 */: return 0; + case 49 /* CharCode.Digit1 */: return 1; + case 50 /* CharCode.Digit2 */: return 2; + case 51 /* CharCode.Digit3 */: return 3; + case 52 /* CharCode.Digit4 */: return 4; + case 53 /* CharCode.Digit5 */: return 5; + case 54 /* CharCode.Digit6 */: return 6; + case 55 /* CharCode.Digit7 */: return 7; + case 56 /* CharCode.Digit8 */: return 8; + case 57 /* CharCode.Digit9 */: return 9; + case 97 /* CharCode.a */: return 10; + case 65 /* CharCode.A */: return 10; + case 98 /* CharCode.b */: return 11; + case 66 /* CharCode.B */: return 11; + case 99 /* CharCode.c */: return 12; + case 67 /* CharCode.C */: return 12; + case 100 /* CharCode.d */: return 13; + case 68 /* CharCode.D */: return 13; + case 101 /* CharCode.e */: return 14; + case 69 /* CharCode.E */: return 14; + case 102 /* CharCode.f */: return 15; + case 70 /* CharCode.F */: return 15; + } + return 0; + } + })(CSS = Format.CSS || (Format.CSS = {})); + })(Format = Color.Format || (Color.Format = {})); +})(Color || (Color = {})); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/diff/diff.js": +/*!********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/diff/diff.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LcsDiff: () => (/* binding */ LcsDiff), +/* harmony export */ StringDiffSequence: () => (/* binding */ StringDiffSequence), +/* harmony export */ stringDiff: () => (/* binding */ stringDiff) +/* harmony export */ }); +/* harmony import */ var _diffChange_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./diffChange.js */ "./node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js"); +/* harmony import */ var _hash_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../hash.js */ "./node_modules/monaco-editor/esm/vs/base/common/hash.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +class StringDiffSequence { + constructor(source) { + this.source = source; + } + getElements() { + const source = this.source; + const characters = new Int32Array(source.length); + for (let i = 0, len = source.length; i < len; i++) { + characters[i] = source.charCodeAt(i); + } + return characters; + } +} +function stringDiff(original, modified, pretty) { + return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes; +} +// +// The code below has been ported from a C# implementation in VS +// +class Debug { + static Assert(condition, message) { + if (!condition) { + throw new Error(message); + } + } +} +class MyArray { + /** + * Copies a range of elements from an Array starting at the specified source index and pastes + * them to another Array starting at the specified destination index. The length and the indexes + * are specified as 64-bit integers. + * sourceArray: + * The Array that contains the data to copy. + * sourceIndex: + * A 64-bit integer that represents the index in the sourceArray at which copying begins. + * destinationArray: + * The Array that receives the data. + * destinationIndex: + * A 64-bit integer that represents the index in the destinationArray at which storing begins. + * length: + * A 64-bit integer that represents the number of elements to copy. + */ + static Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length) { + for (let i = 0; i < length; i++) { + destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i]; + } + } + static Copy2(sourceArray, sourceIndex, destinationArray, destinationIndex, length) { + for (let i = 0; i < length; i++) { + destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i]; + } + } +} +/** + * A utility class which helps to create the set of DiffChanges from + * a difference operation. This class accepts original DiffElements and + * modified DiffElements that are involved in a particular change. The + * MarkNextChange() method can be called to mark the separation between + * distinct changes. At the end, the Changes property can be called to retrieve + * the constructed changes. + */ +class DiffChangeHelper { + /** + * Constructs a new DiffChangeHelper for the given DiffSequences. + */ + constructor() { + this.m_changes = []; + this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */; + this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */; + this.m_originalCount = 0; + this.m_modifiedCount = 0; + } + /** + * Marks the beginning of the next change in the set of differences. + */ + MarkNextChange() { + // Only add to the list if there is something to add + if (this.m_originalCount > 0 || this.m_modifiedCount > 0) { + // Add the new change to our list + this.m_changes.push(new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount)); + } + // Reset for the next change + this.m_originalCount = 0; + this.m_modifiedCount = 0; + this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */; + this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */; + } + /** + * Adds the original element at the given position to the elements + * affected by the current change. The modified index gives context + * to the change position with respect to the original sequence. + * @param originalIndex The index of the original element to add. + * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence. + */ + AddOriginalElement(originalIndex, modifiedIndex) { + // The 'true' start index is the smallest of the ones we've seen + this.m_originalStart = Math.min(this.m_originalStart, originalIndex); + this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex); + this.m_originalCount++; + } + /** + * Adds the modified element at the given position to the elements + * affected by the current change. The original index gives context + * to the change position with respect to the modified sequence. + * @param originalIndex The index of the original element that provides corresponding position in the original sequence. + * @param modifiedIndex The index of the modified element to add. + */ + AddModifiedElement(originalIndex, modifiedIndex) { + // The 'true' start index is the smallest of the ones we've seen + this.m_originalStart = Math.min(this.m_originalStart, originalIndex); + this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex); + this.m_modifiedCount++; + } + /** + * Retrieves all of the changes marked by the class. + */ + getChanges() { + if (this.m_originalCount > 0 || this.m_modifiedCount > 0) { + // Finish up on whatever is left + this.MarkNextChange(); + } + return this.m_changes; + } + /** + * Retrieves all of the changes marked by the class in the reverse order + */ + getReverseChanges() { + if (this.m_originalCount > 0 || this.m_modifiedCount > 0) { + // Finish up on whatever is left + this.MarkNextChange(); + } + this.m_changes.reverse(); + return this.m_changes; + } +} +/** + * An implementation of the difference algorithm described in + * "An O(ND) Difference Algorithm and its variations" by Eugene W. Myers + */ +class LcsDiff { + /** + * Constructs the DiffFinder + */ + constructor(originalSequence, modifiedSequence, continueProcessingPredicate = null) { + this.ContinueProcessingPredicate = continueProcessingPredicate; + this._originalSequence = originalSequence; + this._modifiedSequence = modifiedSequence; + const [originalStringElements, originalElementsOrHash, originalHasStrings] = LcsDiff._getElements(originalSequence); + const [modifiedStringElements, modifiedElementsOrHash, modifiedHasStrings] = LcsDiff._getElements(modifiedSequence); + this._hasStrings = (originalHasStrings && modifiedHasStrings); + this._originalStringElements = originalStringElements; + this._originalElementsOrHash = originalElementsOrHash; + this._modifiedStringElements = modifiedStringElements; + this._modifiedElementsOrHash = modifiedElementsOrHash; + this.m_forwardHistory = []; + this.m_reverseHistory = []; + } + static _isStringArray(arr) { + return (arr.length > 0 && typeof arr[0] === 'string'); + } + static _getElements(sequence) { + const elements = sequence.getElements(); + if (LcsDiff._isStringArray(elements)) { + const hashes = new Int32Array(elements.length); + for (let i = 0, len = elements.length; i < len; i++) { + hashes[i] = (0,_hash_js__WEBPACK_IMPORTED_MODULE_1__.stringHash)(elements[i], 0); + } + return [elements, hashes, true]; + } + if (elements instanceof Int32Array) { + return [[], elements, false]; + } + return [[], new Int32Array(elements), false]; + } + ElementsAreEqual(originalIndex, newIndex) { + if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) { + return false; + } + return (this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true); + } + ElementsAreStrictEqual(originalIndex, newIndex) { + if (!this.ElementsAreEqual(originalIndex, newIndex)) { + return false; + } + const originalElement = LcsDiff._getStrictElement(this._originalSequence, originalIndex); + const modifiedElement = LcsDiff._getStrictElement(this._modifiedSequence, newIndex); + return (originalElement === modifiedElement); + } + static _getStrictElement(sequence, index) { + if (typeof sequence.getStrictElement === 'function') { + return sequence.getStrictElement(index); + } + return null; + } + OriginalElementsAreEqual(index1, index2) { + if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) { + return false; + } + return (this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true); + } + ModifiedElementsAreEqual(index1, index2) { + if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) { + return false; + } + return (this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true); + } + ComputeDiff(pretty) { + return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty); + } + /** + * Computes the differences between the original and modified input + * sequences on the bounded range. + * @returns An array of the differences between the two input sequences. + */ + _ComputeDiff(originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) { + const quitEarlyArr = [false]; + let changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr); + if (pretty) { + // We have to clean up the computed diff to be more intuitive + // but it turns out this cannot be done correctly until the entire set + // of diffs have been computed + changes = this.PrettifyChanges(changes); + } + return { + quitEarly: quitEarlyArr[0], + changes: changes + }; + } + /** + * Private helper method which computes the differences on the bounded range + * recursively. + * @returns An array of the differences between the two input sequences. + */ + ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) { + quitEarlyArr[0] = false; + // Find the start of the differences + while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) { + originalStart++; + modifiedStart++; + } + // Find the end of the differences + while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) { + originalEnd--; + modifiedEnd--; + } + // In the special case where we either have all insertions or all deletions or the sequences are identical + if (originalStart > originalEnd || modifiedStart > modifiedEnd) { + let changes; + if (modifiedStart <= modifiedEnd) { + Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd'); + // All insertions + changes = [ + new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1) + ]; + } + else if (originalStart <= originalEnd) { + Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd'); + // All deletions + changes = [ + new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0) + ]; + } + else { + Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd'); + Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd'); + // Identical sequences - No differences + changes = []; + } + return changes; + } + // This problem can be solved using the Divide-And-Conquer technique. + const midOriginalArr = [0]; + const midModifiedArr = [0]; + const result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr); + const midOriginal = midOriginalArr[0]; + const midModified = midModifiedArr[0]; + if (result !== null) { + // Result is not-null when there was enough memory to compute the changes while + // searching for the recursion point + return result; + } + else if (!quitEarlyArr[0]) { + // We can break the problem down recursively by finding the changes in the + // First Half: (originalStart, modifiedStart) to (midOriginal, midModified) + // Second Half: (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd) + // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point + const leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr); + let rightChanges = []; + if (!quitEarlyArr[0]) { + rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr); + } + else { + // We didn't have time to finish the first half, so we don't have time to compute this half. + // Consider the entire rest of the sequence different. + rightChanges = [ + new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1) + ]; + } + return this.ConcatenateChanges(leftChanges, rightChanges); + } + // If we hit here, we quit early, and so can't return anything meaningful + return [ + new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1) + ]; + } + WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) { + let forwardChanges = null; + let reverseChanges = null; + // First, walk backward through the forward diagonals history + let changeHelper = new DiffChangeHelper(); + let diagonalMin = diagonalForwardStart; + let diagonalMax = diagonalForwardEnd; + let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset; + let lastOriginalIndex = -1073741824 /* Constants.MIN_SAFE_SMALL_INTEGER */; + let historyIndex = this.m_forwardHistory.length - 1; + do { + // Get the diagonal index from the relative diagonal number + const diagonal = diagonalRelative + diagonalForwardBase; + // Figure out where we came from + if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) { + // Vertical line (the element is an insert) + originalIndex = forwardPoints[diagonal + 1]; + modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset; + if (originalIndex < lastOriginalIndex) { + changeHelper.MarkNextChange(); + } + lastOriginalIndex = originalIndex; + changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex); + diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration + } + else { + // Horizontal line (the element is a deletion) + originalIndex = forwardPoints[diagonal - 1] + 1; + modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset; + if (originalIndex < lastOriginalIndex) { + changeHelper.MarkNextChange(); + } + lastOriginalIndex = originalIndex - 1; + changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1); + diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration + } + if (historyIndex >= 0) { + forwardPoints = this.m_forwardHistory[historyIndex]; + diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot + diagonalMin = 1; + diagonalMax = forwardPoints.length - 1; + } + } while (--historyIndex >= -1); + // Ironically, we get the forward changes as the reverse of the + // order we added them since we technically added them backwards + forwardChanges = changeHelper.getReverseChanges(); + if (quitEarlyArr[0]) { + // TODO: Calculate a partial from the reverse diagonals. + // For now, just assume everything after the midOriginal/midModified point is a diff + let originalStartPoint = midOriginalArr[0] + 1; + let modifiedStartPoint = midModifiedArr[0] + 1; + if (forwardChanges !== null && forwardChanges.length > 0) { + const lastForwardChange = forwardChanges[forwardChanges.length - 1]; + originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd()); + modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd()); + } + reverseChanges = [ + new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1) + ]; + } + else { + // Now walk backward through the reverse diagonals history + changeHelper = new DiffChangeHelper(); + diagonalMin = diagonalReverseStart; + diagonalMax = diagonalReverseEnd; + diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset; + lastOriginalIndex = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */; + historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2; + do { + // Get the diagonal index from the relative diagonal number + const diagonal = diagonalRelative + diagonalReverseBase; + // Figure out where we came from + if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) { + // Horizontal line (the element is a deletion)) + originalIndex = reversePoints[diagonal + 1] - 1; + modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset; + if (originalIndex > lastOriginalIndex) { + changeHelper.MarkNextChange(); + } + lastOriginalIndex = originalIndex + 1; + changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1); + diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration + } + else { + // Vertical line (the element is an insertion) + originalIndex = reversePoints[diagonal - 1]; + modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset; + if (originalIndex > lastOriginalIndex) { + changeHelper.MarkNextChange(); + } + lastOriginalIndex = originalIndex; + changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1); + diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration + } + if (historyIndex >= 0) { + reversePoints = this.m_reverseHistory[historyIndex]; + diagonalReverseBase = reversePoints[0]; //We stored this in the first spot + diagonalMin = 1; + diagonalMax = reversePoints.length - 1; + } + } while (--historyIndex >= -1); + // There are cases where the reverse history will find diffs that + // are correct, but not intuitive, so we need shift them. + reverseChanges = changeHelper.getChanges(); + } + return this.ConcatenateChanges(forwardChanges, reverseChanges); + } + /** + * Given the range to compute the diff on, this method finds the point: + * (midOriginal, midModified) + * that exists in the middle of the LCS of the two sequences and + * is the point at which the LCS problem may be broken down recursively. + * This method will try to keep the LCS trace in memory. If the LCS recursion + * point is calculated and the full trace is available in memory, then this method + * will return the change list. + * @param originalStart The start bound of the original sequence range + * @param originalEnd The end bound of the original sequence range + * @param modifiedStart The start bound of the modified sequence range + * @param modifiedEnd The end bound of the modified sequence range + * @param midOriginal The middle point of the original sequence range + * @param midModified The middle point of the modified sequence range + * @returns The diff changes, if available, otherwise null + */ + ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) { + let originalIndex = 0, modifiedIndex = 0; + let diagonalForwardStart = 0, diagonalForwardEnd = 0; + let diagonalReverseStart = 0, diagonalReverseEnd = 0; + // To traverse the edit graph and produce the proper LCS, our actual + // start position is just outside the given boundary + originalStart--; + modifiedStart--; + // We set these up to make the compiler happy, but they will + // be replaced before we return with the actual recursion point + midOriginalArr[0] = 0; + midModifiedArr[0] = 0; + // Clear out the history + this.m_forwardHistory = []; + this.m_reverseHistory = []; + // Each cell in the two arrays corresponds to a diagonal in the edit graph. + // The integer value in the cell represents the originalIndex of the furthest + // reaching point found so far that ends in that diagonal. + // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number. + const maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart); + const numDiagonals = maxDifferences + 1; + const forwardPoints = new Int32Array(numDiagonals); + const reversePoints = new Int32Array(numDiagonals); + // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart) + // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd) + const diagonalForwardBase = (modifiedEnd - modifiedStart); + const diagonalReverseBase = (originalEnd - originalStart); + // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the + // diagonal number (relative to diagonalForwardBase) + // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the + // diagonal number (relative to diagonalReverseBase) + const diagonalForwardOffset = (originalStart - modifiedStart); + const diagonalReverseOffset = (originalEnd - modifiedEnd); + // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers + // relative to the start diagonal with diagonal numbers relative to the end diagonal. + // The Even/Oddn-ness of this delta is important for determining when we should check for overlap + const delta = diagonalReverseBase - diagonalForwardBase; + const deltaIsEven = (delta % 2 === 0); + // Here we set up the start and end points as the furthest points found so far + // in both the forward and reverse directions, respectively + forwardPoints[diagonalForwardBase] = originalStart; + reversePoints[diagonalReverseBase] = originalEnd; + // Remember if we quit early, and thus need to do a best-effort result instead of a real result. + quitEarlyArr[0] = false; + // A couple of points: + // --With this method, we iterate on the number of differences between the two sequences. + // The more differences there actually are, the longer this will take. + // --Also, as the number of differences increases, we have to search on diagonals further + // away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse). + // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences + // is even and odd diagonals only when numDifferences is odd. + for (let numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) { + let furthestOriginalIndex = 0; + let furthestModifiedIndex = 0; + // Run the algorithm in the forward direction + diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals); + diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals); + for (let diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) { + // STEP 1: We extend the furthest reaching point in the present diagonal + // by looking at the diagonals above and below and picking the one whose point + // is further away from the start point (originalStart, modifiedStart) + if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) { + originalIndex = forwardPoints[diagonal + 1]; + } + else { + originalIndex = forwardPoints[diagonal - 1] + 1; + } + modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset; + // Save the current originalIndex so we can test for false overlap in step 3 + const tempOriginalIndex = originalIndex; + // STEP 2: We can continue to extend the furthest reaching point in the present diagonal + // so long as the elements are equal. + while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) { + originalIndex++; + modifiedIndex++; + } + forwardPoints[diagonal] = originalIndex; + if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) { + furthestOriginalIndex = originalIndex; + furthestModifiedIndex = modifiedIndex; + } + // STEP 3: If delta is odd (overlap first happens on forward when delta is odd) + // and diagonal is in the range of reverse diagonals computed for numDifferences-1 + // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet) + // then check for overlap. + if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) { + if (originalIndex >= reversePoints[diagonal]) { + midOriginalArr[0] = originalIndex; + midModifiedArr[0] = modifiedIndex; + if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) { + // BINGO! We overlapped, and we have the full trace in memory! + return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr); + } + else { + // Either false overlap, or we didn't have enough memory for the full trace + // Just return the recursion point + return null; + } + } + } + } + // Check to see if we should be quitting early, before moving on to the next iteration. + const matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2; + if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) { + // We can't finish, so skip ahead to generating a result from what we have. + quitEarlyArr[0] = true; + // Use the furthest distance we got in the forward direction. + midOriginalArr[0] = furthestOriginalIndex; + midModifiedArr[0] = furthestModifiedIndex; + if (matchLengthOfLongest > 0 && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) { + // Enough of the history is in memory to walk it backwards + return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr); + } + else { + // We didn't actually remember enough of the history. + //Since we are quitting the diff early, we need to shift back the originalStart and modified start + //back into the boundary limits since we decremented their value above beyond the boundary limit. + originalStart++; + modifiedStart++; + return [ + new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1) + ]; + } + } + // Run the algorithm in the reverse direction + diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals); + diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals); + for (let diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) { + // STEP 1: We extend the furthest reaching point in the present diagonal + // by looking at the diagonals above and below and picking the one whose point + // is further away from the start point (originalEnd, modifiedEnd) + if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) { + originalIndex = reversePoints[diagonal + 1] - 1; + } + else { + originalIndex = reversePoints[diagonal - 1]; + } + modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset; + // Save the current originalIndex so we can test for false overlap + const tempOriginalIndex = originalIndex; + // STEP 2: We can continue to extend the furthest reaching point in the present diagonal + // as long as the elements are equal. + while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) { + originalIndex--; + modifiedIndex--; + } + reversePoints[diagonal] = originalIndex; + // STEP 4: If delta is even (overlap first happens on reverse when delta is even) + // and diagonal is in the range of forward diagonals computed for numDifferences + // then check for overlap. + if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) { + if (originalIndex <= forwardPoints[diagonal]) { + midOriginalArr[0] = originalIndex; + midModifiedArr[0] = modifiedIndex; + if (tempOriginalIndex >= forwardPoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) { + // BINGO! We overlapped, and we have the full trace in memory! + return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr); + } + else { + // Either false overlap, or we didn't have enough memory for the full trace + // Just return the recursion point + return null; + } + } + } + } + // Save current vectors to history before the next iteration + if (numDifferences <= 1447 /* LocalConstants.MaxDifferencesHistory */) { + // We are allocating space for one extra int, which we fill with + // the index of the diagonal base index + let temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2); + temp[0] = diagonalForwardBase - diagonalForwardStart + 1; + MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1); + this.m_forwardHistory.push(temp); + temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2); + temp[0] = diagonalReverseBase - diagonalReverseStart + 1; + MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1); + this.m_reverseHistory.push(temp); + } + } + // If we got here, then we have the full trace in history. We just have to convert it to a change list + // NOTE: This part is a bit messy + return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr); + } + /** + * Shifts the given changes to provide a more intuitive diff. + * While the first element in a diff matches the first element after the diff, + * we shift the diff down. + * + * @param changes The list of changes to shift + * @returns The shifted changes + */ + PrettifyChanges(changes) { + // Shift all the changes down first + for (let i = 0; i < changes.length; i++) { + const change = changes[i]; + const originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this._originalElementsOrHash.length; + const modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length; + const checkOriginal = change.originalLength > 0; + const checkModified = change.modifiedLength > 0; + while (change.originalStart + change.originalLength < originalStop + && change.modifiedStart + change.modifiedLength < modifiedStop + && (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength)) + && (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) { + const startStrictEqual = this.ElementsAreStrictEqual(change.originalStart, change.modifiedStart); + const endStrictEqual = this.ElementsAreStrictEqual(change.originalStart + change.originalLength, change.modifiedStart + change.modifiedLength); + if (endStrictEqual && !startStrictEqual) { + // moving the change down would create an equal change, but the elements are not strict equal + break; + } + change.originalStart++; + change.modifiedStart++; + } + const mergedChangeArr = [null]; + if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) { + changes[i] = mergedChangeArr[0]; + changes.splice(i + 1, 1); + i--; + continue; + } + } + // Shift changes back up until we hit empty or whitespace-only lines + for (let i = changes.length - 1; i >= 0; i--) { + const change = changes[i]; + let originalStop = 0; + let modifiedStop = 0; + if (i > 0) { + const prevChange = changes[i - 1]; + originalStop = prevChange.originalStart + prevChange.originalLength; + modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength; + } + const checkOriginal = change.originalLength > 0; + const checkModified = change.modifiedLength > 0; + let bestDelta = 0; + let bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength); + for (let delta = 1;; delta++) { + const originalStart = change.originalStart - delta; + const modifiedStart = change.modifiedStart - delta; + if (originalStart < originalStop || modifiedStart < modifiedStop) { + break; + } + if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) { + break; + } + if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) { + break; + } + const touchingPreviousChange = (originalStart === originalStop && modifiedStart === modifiedStop); + const score = ((touchingPreviousChange ? 5 : 0) + + this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength)); + if (score > bestScore) { + bestScore = score; + bestDelta = delta; + } + } + change.originalStart -= bestDelta; + change.modifiedStart -= bestDelta; + const mergedChangeArr = [null]; + if (i > 0 && this.ChangesOverlap(changes[i - 1], changes[i], mergedChangeArr)) { + changes[i - 1] = mergedChangeArr[0]; + changes.splice(i, 1); + i++; + continue; + } + } + // There could be multiple longest common substrings. + // Give preference to the ones containing longer lines + if (this._hasStrings) { + for (let i = 1, len = changes.length; i < len; i++) { + const aChange = changes[i - 1]; + const bChange = changes[i]; + const matchedLength = bChange.originalStart - aChange.originalStart - aChange.originalLength; + const aOriginalStart = aChange.originalStart; + const bOriginalEnd = bChange.originalStart + bChange.originalLength; + const abOriginalLength = bOriginalEnd - aOriginalStart; + const aModifiedStart = aChange.modifiedStart; + const bModifiedEnd = bChange.modifiedStart + bChange.modifiedLength; + const abModifiedLength = bModifiedEnd - aModifiedStart; + // Avoid wasting a lot of time with these searches + if (matchedLength < 5 && abOriginalLength < 20 && abModifiedLength < 20) { + const t = this._findBetterContiguousSequence(aOriginalStart, abOriginalLength, aModifiedStart, abModifiedLength, matchedLength); + if (t) { + const [originalMatchStart, modifiedMatchStart] = t; + if (originalMatchStart !== aChange.originalStart + aChange.originalLength || modifiedMatchStart !== aChange.modifiedStart + aChange.modifiedLength) { + // switch to another sequence that has a better score + aChange.originalLength = originalMatchStart - aChange.originalStart; + aChange.modifiedLength = modifiedMatchStart - aChange.modifiedStart; + bChange.originalStart = originalMatchStart + matchedLength; + bChange.modifiedStart = modifiedMatchStart + matchedLength; + bChange.originalLength = bOriginalEnd - bChange.originalStart; + bChange.modifiedLength = bModifiedEnd - bChange.modifiedStart; + } + } + } + } + } + return changes; + } + _findBetterContiguousSequence(originalStart, originalLength, modifiedStart, modifiedLength, desiredLength) { + if (originalLength < desiredLength || modifiedLength < desiredLength) { + return null; + } + const originalMax = originalStart + originalLength - desiredLength + 1; + const modifiedMax = modifiedStart + modifiedLength - desiredLength + 1; + let bestScore = 0; + let bestOriginalStart = 0; + let bestModifiedStart = 0; + for (let i = originalStart; i < originalMax; i++) { + for (let j = modifiedStart; j < modifiedMax; j++) { + const score = this._contiguousSequenceScore(i, j, desiredLength); + if (score > 0 && score > bestScore) { + bestScore = score; + bestOriginalStart = i; + bestModifiedStart = j; + } + } + } + if (bestScore > 0) { + return [bestOriginalStart, bestModifiedStart]; + } + return null; + } + _contiguousSequenceScore(originalStart, modifiedStart, length) { + let score = 0; + for (let l = 0; l < length; l++) { + if (!this.ElementsAreEqual(originalStart + l, modifiedStart + l)) { + return 0; + } + score += this._originalStringElements[originalStart + l].length; + } + return score; + } + _OriginalIsBoundary(index) { + if (index <= 0 || index >= this._originalElementsOrHash.length - 1) { + return true; + } + return (this._hasStrings && /^\s*$/.test(this._originalStringElements[index])); + } + _OriginalRegionIsBoundary(originalStart, originalLength) { + if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) { + return true; + } + if (originalLength > 0) { + const originalEnd = originalStart + originalLength; + if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) { + return true; + } + } + return false; + } + _ModifiedIsBoundary(index) { + if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) { + return true; + } + return (this._hasStrings && /^\s*$/.test(this._modifiedStringElements[index])); + } + _ModifiedRegionIsBoundary(modifiedStart, modifiedLength) { + if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) { + return true; + } + if (modifiedLength > 0) { + const modifiedEnd = modifiedStart + modifiedLength; + if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) { + return true; + } + } + return false; + } + _boundaryScore(originalStart, originalLength, modifiedStart, modifiedLength) { + const originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0); + const modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0); + return (originalScore + modifiedScore); + } + /** + * Concatenates the two input DiffChange lists and returns the resulting + * list. + * @param The left changes + * @param The right changes + * @returns The concatenated list + */ + ConcatenateChanges(left, right) { + const mergedChangeArr = []; + if (left.length === 0 || right.length === 0) { + return (right.length > 0) ? right : left; + } + else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) { + // Since we break the problem down recursively, it is possible that we + // might recurse in the middle of a change thereby splitting it into + // two changes. Here in the combining stage, we detect and fuse those + // changes back together + const result = new Array(left.length + right.length - 1); + MyArray.Copy(left, 0, result, 0, left.length - 1); + result[left.length - 1] = mergedChangeArr[0]; + MyArray.Copy(right, 1, result, left.length, right.length - 1); + return result; + } + else { + const result = new Array(left.length + right.length); + MyArray.Copy(left, 0, result, 0, left.length); + MyArray.Copy(right, 0, result, left.length, right.length); + return result; + } + } + /** + * Returns true if the two changes overlap and can be merged into a single + * change + * @param left The left change + * @param right The right change + * @param mergedChange The merged change if the two overlap, null otherwise + * @returns True if the two changes overlap + */ + ChangesOverlap(left, right, mergedChangeArr) { + Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change'); + Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change'); + if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) { + const originalStart = left.originalStart; + let originalLength = left.originalLength; + const modifiedStart = left.modifiedStart; + let modifiedLength = left.modifiedLength; + if (left.originalStart + left.originalLength >= right.originalStart) { + originalLength = right.originalStart + right.originalLength - left.originalStart; + } + if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) { + modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart; + } + mergedChangeArr[0] = new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__.DiffChange(originalStart, originalLength, modifiedStart, modifiedLength); + return true; + } + else { + mergedChangeArr[0] = null; + return false; + } + } + /** + * Helper method used to clip a diagonal index to the range of valid + * diagonals. This also decides whether or not the diagonal index, + * if it exceeds the boundary, should be clipped to the boundary or clipped + * one inside the boundary depending on the Even/Odd status of the boundary + * and numDifferences. + * @param diagonal The index of the diagonal to clip. + * @param numDifferences The current number of differences being iterated upon. + * @param diagonalBaseIndex The base reference diagonal. + * @param numDiagonals The total number of diagonals. + * @returns The clipped diagonal index. + */ + ClipDiagonalBound(diagonal, numDifferences, diagonalBaseIndex, numDiagonals) { + if (diagonal >= 0 && diagonal < numDiagonals) { + // Nothing to clip, its in range + return diagonal; + } + // diagonalsBelow: The number of diagonals below the reference diagonal + // diagonalsAbove: The number of diagonals above the reference diagonal + const diagonalsBelow = diagonalBaseIndex; + const diagonalsAbove = numDiagonals - diagonalBaseIndex - 1; + const diffEven = (numDifferences % 2 === 0); + if (diagonal < 0) { + const lowerBoundEven = (diagonalsBelow % 2 === 0); + return (diffEven === lowerBoundEven) ? 0 : 1; + } + else { + const upperBoundEven = (diagonalsAbove % 2 === 0); + return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2; + } + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js": +/*!**************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js ***! + \**************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DiffChange: () => (/* binding */ DiffChange) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/** + * Represents information about a specific difference between two sequences. + */ +class DiffChange { + /** + * Constructs a new DiffChange with the given sequence information + * and content. + */ + constructor(originalStart, originalLength, modifiedStart, modifiedLength) { + //Debug.Assert(originalLength > 0 || modifiedLength > 0, "originalLength and modifiedLength cannot both be <= 0"); + this.originalStart = originalStart; + this.originalLength = originalLength; + this.modifiedStart = modifiedStart; + this.modifiedLength = modifiedLength; + } + /** + * The end point (exclusive) of the change in the original sequence. + */ + getOriginalEnd() { + return this.originalStart + this.originalLength; + } + /** + * The end point (exclusive) of the change in the modified sequence. + */ + getModifiedEnd() { + return this.modifiedStart + this.modifiedLength; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/errors.js": +/*!*****************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/errors.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ BugIndicatingError: () => (/* binding */ BugIndicatingError), +/* harmony export */ CancellationError: () => (/* binding */ CancellationError), +/* harmony export */ ErrorHandler: () => (/* binding */ ErrorHandler), +/* harmony export */ ErrorNoTelemetry: () => (/* binding */ ErrorNoTelemetry), +/* harmony export */ NotSupportedError: () => (/* binding */ NotSupportedError), +/* harmony export */ canceled: () => (/* binding */ canceled), +/* harmony export */ errorHandler: () => (/* binding */ errorHandler), +/* harmony export */ illegalArgument: () => (/* binding */ illegalArgument), +/* harmony export */ illegalState: () => (/* binding */ illegalState), +/* harmony export */ isCancellationError: () => (/* binding */ isCancellationError), +/* harmony export */ onUnexpectedError: () => (/* binding */ onUnexpectedError), +/* harmony export */ onUnexpectedExternalError: () => (/* binding */ onUnexpectedExternalError), +/* harmony export */ transformErrorForSerialization: () => (/* binding */ transformErrorForSerialization) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +// Avoid circular dependency on EventEmitter by implementing a subset of the interface. +class ErrorHandler { + constructor() { + this.listeners = []; + this.unexpectedErrorHandler = function (e) { + setTimeout(() => { + if (e.stack) { + if (ErrorNoTelemetry.isErrorNoTelemetry(e)) { + throw new ErrorNoTelemetry(e.message + '\n\n' + e.stack); + } + throw new Error(e.message + '\n\n' + e.stack); + } + throw e; + }, 0); + }; + } + emit(e) { + this.listeners.forEach((listener) => { + listener(e); + }); + } + onUnexpectedError(e) { + this.unexpectedErrorHandler(e); + this.emit(e); + } + // For external errors, we don't want the listeners to be called + onUnexpectedExternalError(e) { + this.unexpectedErrorHandler(e); + } +} +const errorHandler = new ErrorHandler(); +function onUnexpectedError(e) { + // ignore errors from cancelled promises + if (!isCancellationError(e)) { + errorHandler.onUnexpectedError(e); + } + return undefined; +} +function onUnexpectedExternalError(e) { + // ignore errors from cancelled promises + if (!isCancellationError(e)) { + errorHandler.onUnexpectedExternalError(e); + } + return undefined; +} +function transformErrorForSerialization(error) { + if (error instanceof Error) { + const { name, message } = error; + const stack = error.stacktrace || error.stack; + return { + $isError: true, + name, + message, + stack, + noTelemetry: ErrorNoTelemetry.isErrorNoTelemetry(error) + }; + } + // return as is + return error; +} +const canceledName = 'Canceled'; +/** + * Checks if the given error is a promise in canceled state + */ +function isCancellationError(error) { + if (error instanceof CancellationError) { + return true; + } + return error instanceof Error && error.name === canceledName && error.message === canceledName; +} +// !!!IMPORTANT!!! +// Do NOT change this class because it is also used as an API-type. +class CancellationError extends Error { + constructor() { + super(canceledName); + this.name = this.message; + } +} +/** + * @deprecated use {@link CancellationError `new CancellationError()`} instead + */ +function canceled() { + const error = new Error(canceledName); + error.name = error.message; + return error; +} +function illegalArgument(name) { + if (name) { + return new Error(`Illegal argument: ${name}`); + } + else { + return new Error('Illegal argument'); + } +} +function illegalState(name) { + if (name) { + return new Error(`Illegal state: ${name}`); + } + else { + return new Error('Illegal state'); + } +} +class NotSupportedError extends Error { + constructor(message) { + super('NotSupported'); + if (message) { + this.message = message; + } + } +} +/** + * Error that when thrown won't be logged in telemetry as an unhandled error. + */ +class ErrorNoTelemetry extends Error { + constructor(msg) { + super(msg); + this.name = 'CodeExpectedError'; + } + static fromError(err) { + if (err instanceof ErrorNoTelemetry) { + return err; + } + const result = new ErrorNoTelemetry(); + result.message = err.message; + result.stack = err.stack; + return result; + } + static isErrorNoTelemetry(err) { + return err.name === 'CodeExpectedError'; + } +} +/** + * This error indicates a bug. + * Do not throw this for invalid user input. + * Only catch this error to recover gracefully from bugs. + */ +class BugIndicatingError extends Error { + constructor(message) { + super(message || 'An unexpected bug occurred.'); + Object.setPrototypeOf(this, BugIndicatingError.prototype); + // Because we know for sure only buggy code throws this, + // we definitely want to break here and fix the bug. + // eslint-disable-next-line no-debugger + // debugger; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/event.js": +/*!****************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/event.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DebounceEmitter: () => (/* binding */ DebounceEmitter), +/* harmony export */ Emitter: () => (/* binding */ Emitter), +/* harmony export */ Event: () => (/* binding */ Event), +/* harmony export */ EventBufferer: () => (/* binding */ EventBufferer), +/* harmony export */ EventMultiplexer: () => (/* binding */ EventMultiplexer), +/* harmony export */ EventProfiling: () => (/* binding */ EventProfiling), +/* harmony export */ MicrotaskEmitter: () => (/* binding */ MicrotaskEmitter), +/* harmony export */ PauseableEmitter: () => (/* binding */ PauseableEmitter), +/* harmony export */ Relay: () => (/* binding */ Relay), +/* harmony export */ createEventDeliveryQueue: () => (/* binding */ createEventDeliveryQueue) +/* harmony export */ }); +/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./errors.js */ "./node_modules/monaco-editor/esm/vs/base/common/errors.js"); +/* harmony import */ var _functional_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./functional.js */ "./node_modules/monaco-editor/esm/vs/base/common/functional.js"); +/* harmony import */ var _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./lifecycle.js */ "./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js"); +/* harmony import */ var _linkedList_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./linkedList.js */ "./node_modules/monaco-editor/esm/vs/base/common/linkedList.js"); +/* harmony import */ var _stopwatch_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./stopwatch.js */ "./node_modules/monaco-editor/esm/vs/base/common/stopwatch.js"); + + + + + +// ----------------------------------------------------------------------------------------------------------------------- +// Uncomment the next line to print warnings whenever an emitter with listeners is disposed. That is a sign of code smell. +// ----------------------------------------------------------------------------------------------------------------------- +const _enableDisposeWithListenerWarning = false; +// _enableDisposeWithListenerWarning = Boolean("TRUE"); // causes a linter warning so that it cannot be pushed +// ----------------------------------------------------------------------------------------------------------------------- +// Uncomment the next line to print warnings whenever a snapshotted event is used repeatedly without cleanup. +// See https://github.com/microsoft/vscode/issues/142851 +// ----------------------------------------------------------------------------------------------------------------------- +const _enableSnapshotPotentialLeakWarning = false; +var Event; +(function (Event) { + Event.None = () => _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.Disposable.None; + function _addLeakageTraceLogic(options) { + if (_enableSnapshotPotentialLeakWarning) { + const { onDidAddListener: origListenerDidAdd } = options; + const stack = Stacktrace.create(); + let count = 0; + options.onDidAddListener = () => { + if (++count === 2) { + console.warn('snapshotted emitter LIKELY used public and SHOULD HAVE BEEN created with DisposableStore. snapshotted here'); + stack.print(); + } + origListenerDidAdd === null || origListenerDidAdd === void 0 ? void 0 : origListenerDidAdd(); + }; + } + } + /** + * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared + * `setTimeout`. The event is converted into a signal (`Event`) to avoid additional object creation as a + * result of merging events and to try prevent race conditions that could arise when using related deferred and + * non-deferred events. + * + * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work + * (eg. latency of keypress to text rendered). + * + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + * + * @param event The event source for the new event. + * @param disposable A disposable store to add the new EventEmitter to. + */ + function defer(event, disposable) { + return debounce(event, () => void 0, 0, undefined, true, undefined, disposable); + } + Event.defer = defer; + /** + * Given an event, returns another event which only fires once. + * + * @param event The event source for the new event. + */ + function once(event) { + return (listener, thisArgs = null, disposables) => { + // we need this, in case the event fires during the listener call + let didFire = false; + let result = undefined; + result = event(e => { + if (didFire) { + return; + } + else if (result) { + result.dispose(); + } + else { + didFire = true; + } + return listener.call(thisArgs, e); + }, null, disposables); + if (didFire) { + result.dispose(); + } + return result; + }; + } + Event.once = once; + /** + * Maps an event of one type into an event of another type using a mapping function, similar to how + * `Array.prototype.map` works. + * + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + * + * @param event The event source for the new event. + * @param map The mapping function. + * @param disposable A disposable store to add the new EventEmitter to. + */ + function map(event, map, disposable) { + return snapshot((listener, thisArgs = null, disposables) => event(i => listener.call(thisArgs, map(i)), null, disposables), disposable); + } + Event.map = map; + /** + * Wraps an event in another event that performs some function on the event object before firing. + * + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + * + * @param event The event source for the new event. + * @param each The function to perform on the event object. + * @param disposable A disposable store to add the new EventEmitter to. + */ + function forEach(event, each, disposable) { + return snapshot((listener, thisArgs = null, disposables) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables), disposable); + } + Event.forEach = forEach; + function filter(event, filter, disposable) { + return snapshot((listener, thisArgs = null, disposables) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables), disposable); + } + Event.filter = filter; + /** + * Given an event, returns the same event but typed as `Event`. + */ + function signal(event) { + return event; + } + Event.signal = signal; + function any(...events) { + return (listener, thisArgs = null, disposables) => { + const disposable = (0,_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.combinedDisposable)(...events.map(event => event(e => listener.call(thisArgs, e)))); + return addAndReturnDisposable(disposable, disposables); + }; + } + Event.any = any; + /** + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + */ + function reduce(event, merge, initial, disposable) { + let output = initial; + return map(event, e => { + output = merge(output, e); + return output; + }, disposable); + } + Event.reduce = reduce; + function snapshot(event, disposable) { + let listener; + const options = { + onWillAddFirstListener() { + listener = event(emitter.fire, emitter); + }, + onDidRemoveLastListener() { + listener === null || listener === void 0 ? void 0 : listener.dispose(); + } + }; + if (!disposable) { + _addLeakageTraceLogic(options); + } + const emitter = new Emitter(options); + disposable === null || disposable === void 0 ? void 0 : disposable.add(emitter); + return emitter.event; + } + /** + * Adds the IDisposable to the store if it's set, and returns it. Useful to + * Event function implementation. + */ + function addAndReturnDisposable(d, store) { + if (store instanceof Array) { + store.push(d); + } + else if (store) { + store.add(d); + } + return d; + } + function debounce(event, merge, delay = 100, leading = false, flushOnListenerRemove = false, leakWarningThreshold, disposable) { + let subscription; + let output = undefined; + let handle = undefined; + let numDebouncedCalls = 0; + let doFire; + const options = { + leakWarningThreshold, + onWillAddFirstListener() { + subscription = event(cur => { + numDebouncedCalls++; + output = merge(output, cur); + if (leading && !handle) { + emitter.fire(output); + output = undefined; + } + doFire = () => { + const _output = output; + output = undefined; + handle = undefined; + if (!leading || numDebouncedCalls > 1) { + emitter.fire(_output); + } + numDebouncedCalls = 0; + }; + if (typeof delay === 'number') { + clearTimeout(handle); + handle = setTimeout(doFire, delay); + } + else { + if (handle === undefined) { + handle = 0; + queueMicrotask(doFire); + } + } + }); + }, + onWillRemoveListener() { + if (flushOnListenerRemove && numDebouncedCalls > 0) { + doFire === null || doFire === void 0 ? void 0 : doFire(); + } + }, + onDidRemoveLastListener() { + doFire = undefined; + subscription.dispose(); + } + }; + if (!disposable) { + _addLeakageTraceLogic(options); + } + const emitter = new Emitter(options); + disposable === null || disposable === void 0 ? void 0 : disposable.add(emitter); + return emitter.event; + } + Event.debounce = debounce; + /** + * Debounces an event, firing after some delay (default=0) with an array of all event original objects. + * + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + */ + function accumulate(event, delay = 0, disposable) { + return Event.debounce(event, (last, e) => { + if (!last) { + return [e]; + } + last.push(e); + return last; + }, delay, undefined, true, undefined, disposable); + } + Event.accumulate = accumulate; + /** + * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate + * event objects from different sources do not fire the same event object. + * + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + * + * @param event The event source for the new event. + * @param equals The equality condition. + * @param disposable A disposable store to add the new EventEmitter to. + * + * @example + * ``` + * // Fire only one time when a single window is opened or focused + * Event.latch(Event.any(onDidOpenWindow, onDidFocusWindow)) + * ``` + */ + function latch(event, equals = (a, b) => a === b, disposable) { + let firstCall = true; + let cache; + return filter(event, value => { + const shouldEmit = firstCall || !equals(value, cache); + firstCall = false; + cache = value; + return shouldEmit; + }, disposable); + } + Event.latch = latch; + /** + * Splits an event whose parameter is a union type into 2 separate events for each type in the union. + * + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + * + * @example + * ``` + * const event = new EventEmitter().event; + * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined); + * ``` + * + * @param event The event source for the new event. + * @param isT A function that determines what event is of the first type. + * @param disposable A disposable store to add the new EventEmitter to. + */ + function split(event, isT, disposable) { + return [ + Event.filter(event, isT, disposable), + Event.filter(event, e => !isT(e), disposable), + ]; + } + Event.split = split; + /** + * Buffers an event until it has a listener attached. + * + * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned + * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the + * returned event causes this utility to leak a listener on the original event. + * + * @param event The event source for the new event. + * @param flushAfterTimeout Determines whether to flush the buffer after a timeout immediately or after a + * `setTimeout` when the first event listener is added. + * @param _buffer Internal: A source event array used for tests. + * + * @example + * ``` + * // Start accumulating events, when the first listener is attached, flush + * // the event after a timeout such that multiple listeners attached before + * // the timeout would receive the event + * this.onInstallExtension = Event.buffer(service.onInstallExtension, true); + * ``` + */ + function buffer(event, flushAfterTimeout = false, _buffer = [], disposable) { + let buffer = _buffer.slice(); + let listener = event(e => { + if (buffer) { + buffer.push(e); + } + else { + emitter.fire(e); + } + }); + if (disposable) { + disposable.add(listener); + } + const flush = () => { + buffer === null || buffer === void 0 ? void 0 : buffer.forEach(e => emitter.fire(e)); + buffer = null; + }; + const emitter = new Emitter({ + onWillAddFirstListener() { + if (!listener) { + listener = event(e => emitter.fire(e)); + if (disposable) { + disposable.add(listener); + } + } + }, + onDidAddFirstListener() { + if (buffer) { + if (flushAfterTimeout) { + setTimeout(flush); + } + else { + flush(); + } + } + }, + onDidRemoveLastListener() { + if (listener) { + listener.dispose(); + } + listener = null; + } + }); + if (disposable) { + disposable.add(emitter); + } + return emitter.event; + } + Event.buffer = buffer; + /** + * Wraps the event in an {@link IChainableEvent}, allowing a more functional programming style. + * + * @example + * ``` + * // Normal + * const onEnterPressNormal = Event.filter( + * Event.map(onKeyPress.event, e => new StandardKeyboardEvent(e)), + * e.keyCode === KeyCode.Enter + * ).event; + * + * // Using chain + * const onEnterPressChain = Event.chain(onKeyPress.event, $ => $ + * .map(e => new StandardKeyboardEvent(e)) + * .filter(e => e.keyCode === KeyCode.Enter) + * ); + * ``` + */ + function chain(event, sythensize) { + const fn = (listener, thisArgs, disposables) => { + const cs = sythensize(new ChainableSynthesis()); + return event(function (value) { + const result = cs.evaluate(value); + if (result !== HaltChainable) { + listener.call(thisArgs, result); + } + }, undefined, disposables); + }; + return fn; + } + Event.chain = chain; + const HaltChainable = Symbol('HaltChainable'); + class ChainableSynthesis { + constructor() { + this.steps = []; + } + map(fn) { + this.steps.push(fn); + return this; + } + forEach(fn) { + this.steps.push(v => { + fn(v); + return v; + }); + return this; + } + filter(fn) { + this.steps.push(v => fn(v) ? v : HaltChainable); + return this; + } + reduce(merge, initial) { + let last = initial; + this.steps.push(v => { + last = merge(last, v); + return last; + }); + return this; + } + latch(equals = (a, b) => a === b) { + let firstCall = true; + let cache; + this.steps.push(value => { + const shouldEmit = firstCall || !equals(value, cache); + firstCall = false; + cache = value; + return shouldEmit ? value : HaltChainable; + }); + return this; + } + evaluate(value) { + for (const step of this.steps) { + value = step(value); + if (value === HaltChainable) { + break; + } + } + return value; + } + } + /** + * Creates an {@link Event} from a node event emitter. + */ + function fromNodeEventEmitter(emitter, eventName, map = id => id) { + const fn = (...args) => result.fire(map(...args)); + const onFirstListenerAdd = () => emitter.on(eventName, fn); + const onLastListenerRemove = () => emitter.removeListener(eventName, fn); + const result = new Emitter({ onWillAddFirstListener: onFirstListenerAdd, onDidRemoveLastListener: onLastListenerRemove }); + return result.event; + } + Event.fromNodeEventEmitter = fromNodeEventEmitter; + /** + * Creates an {@link Event} from a DOM event emitter. + */ + function fromDOMEventEmitter(emitter, eventName, map = id => id) { + const fn = (...args) => result.fire(map(...args)); + const onFirstListenerAdd = () => emitter.addEventListener(eventName, fn); + const onLastListenerRemove = () => emitter.removeEventListener(eventName, fn); + const result = new Emitter({ onWillAddFirstListener: onFirstListenerAdd, onDidRemoveLastListener: onLastListenerRemove }); + return result.event; + } + Event.fromDOMEventEmitter = fromDOMEventEmitter; + /** + * Creates a promise out of an event, using the {@link Event.once} helper. + */ + function toPromise(event) { + return new Promise(resolve => once(event)(resolve)); + } + Event.toPromise = toPromise; + /** + * Creates an event out of a promise that fires once when the promise is + * resolved with the result of the promise or `undefined`. + */ + function fromPromise(promise) { + const result = new Emitter(); + promise.then(res => { + result.fire(res); + }, () => { + result.fire(undefined); + }).finally(() => { + result.dispose(); + }); + return result.event; + } + Event.fromPromise = fromPromise; + function runAndSubscribe(event, handler, initial) { + handler(initial); + return event(e => handler(e)); + } + Event.runAndSubscribe = runAndSubscribe; + /** + * Adds a listener to an event and calls the listener immediately with undefined as the event object. A new + * {@link DisposableStore} is passed to the listener which is disposed when the returned disposable is disposed. + */ + function runAndSubscribeWithStore(event, handler) { + let store = null; + function run(e) { + store === null || store === void 0 ? void 0 : store.dispose(); + store = new _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.DisposableStore(); + handler(e, store); + } + run(undefined); + const disposable = event(e => run(e)); + return (0,_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.toDisposable)(() => { + disposable.dispose(); + store === null || store === void 0 ? void 0 : store.dispose(); + }); + } + Event.runAndSubscribeWithStore = runAndSubscribeWithStore; + class EmitterObserver { + constructor(_observable, store) { + this._observable = _observable; + this._counter = 0; + this._hasChanged = false; + const options = { + onWillAddFirstListener: () => { + _observable.addObserver(this); + }, + onDidRemoveLastListener: () => { + _observable.removeObserver(this); + } + }; + if (!store) { + _addLeakageTraceLogic(options); + } + this.emitter = new Emitter(options); + if (store) { + store.add(this.emitter); + } + } + beginUpdate(_observable) { + // assert(_observable === this.obs); + this._counter++; + } + handlePossibleChange(_observable) { + // assert(_observable === this.obs); + } + handleChange(_observable, _change) { + // assert(_observable === this.obs); + this._hasChanged = true; + } + endUpdate(_observable) { + // assert(_observable === this.obs); + this._counter--; + if (this._counter === 0) { + this._observable.reportChanges(); + if (this._hasChanged) { + this._hasChanged = false; + this.emitter.fire(this._observable.get()); + } + } + } + } + /** + * Creates an event emitter that is fired when the observable changes. + * Each listeners subscribes to the emitter. + */ + function fromObservable(obs, store) { + const observer = new EmitterObserver(obs, store); + return observer.emitter.event; + } + Event.fromObservable = fromObservable; + /** + * Each listener is attached to the observable directly. + */ + function fromObservableLight(observable) { + return (listener, thisArgs, disposables) => { + let count = 0; + let didChange = false; + const observer = { + beginUpdate() { + count++; + }, + endUpdate() { + count--; + if (count === 0) { + observable.reportChanges(); + if (didChange) { + didChange = false; + listener.call(thisArgs); + } + } + }, + handlePossibleChange() { + // noop + }, + handleChange() { + didChange = true; + } + }; + observable.addObserver(observer); + observable.reportChanges(); + const disposable = { + dispose() { + observable.removeObserver(observer); + } + }; + if (disposables instanceof _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.DisposableStore) { + disposables.add(disposable); + } + else if (Array.isArray(disposables)) { + disposables.push(disposable); + } + return disposable; + }; + } + Event.fromObservableLight = fromObservableLight; +})(Event || (Event = {})); +class EventProfiling { + constructor(name) { + this.listenerCount = 0; + this.invocationCount = 0; + this.elapsedOverall = 0; + this.durations = []; + this.name = `${name}_${EventProfiling._idPool++}`; + EventProfiling.all.add(this); + } + start(listenerCount) { + this._stopWatch = new _stopwatch_js__WEBPACK_IMPORTED_MODULE_4__.StopWatch(); + this.listenerCount = listenerCount; + } + stop() { + if (this._stopWatch) { + const elapsed = this._stopWatch.elapsed(); + this.durations.push(elapsed); + this.elapsedOverall += elapsed; + this.invocationCount += 1; + this._stopWatch = undefined; + } + } +} +EventProfiling.all = new Set(); +EventProfiling._idPool = 0; +let _globalLeakWarningThreshold = -1; +class LeakageMonitor { + constructor(threshold, name = Math.random().toString(18).slice(2, 5)) { + this.threshold = threshold; + this.name = name; + this._warnCountdown = 0; + } + dispose() { + var _a; + (_a = this._stacks) === null || _a === void 0 ? void 0 : _a.clear(); + } + check(stack, listenerCount) { + const threshold = this.threshold; + if (threshold <= 0 || listenerCount < threshold) { + return undefined; + } + if (!this._stacks) { + this._stacks = new Map(); + } + const count = (this._stacks.get(stack.value) || 0); + this._stacks.set(stack.value, count + 1); + this._warnCountdown -= 1; + if (this._warnCountdown <= 0) { + // only warn on first exceed and then every time the limit + // is exceeded by 50% again + this._warnCountdown = threshold * 0.5; + // find most frequent listener and print warning + let topStack; + let topCount = 0; + for (const [stack, count] of this._stacks) { + if (!topStack || topCount < count) { + topStack = stack; + topCount = count; + } + } + console.warn(`[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`); + console.warn(topStack); + } + return () => { + const count = (this._stacks.get(stack.value) || 0); + this._stacks.set(stack.value, count - 1); + }; + } +} +class Stacktrace { + static create() { + var _a; + return new Stacktrace((_a = new Error().stack) !== null && _a !== void 0 ? _a : ''); + } + constructor(value) { + this.value = value; + } + print() { + console.warn(this.value.split('\n').slice(2).join('\n')); + } +} +class UniqueContainer { + constructor(value) { + this.value = value; + } +} +const compactionThreshold = 2; +const forEachListener = (listeners, fn) => { + if (listeners instanceof UniqueContainer) { + fn(listeners); + } + else { + for (let i = 0; i < listeners.length; i++) { + const l = listeners[i]; + if (l) { + fn(l); + } + } + } +}; +/** + * The Emitter can be used to expose an Event to the public + * to fire it from the insides. + * Sample: + class Document { + + private readonly _onDidChange = new Emitter<(value:string)=>any>(); + + public onDidChange = this._onDidChange.event; + + // getter-style + // get onDidChange(): Event<(value:string)=>any> { + // return this._onDidChange.event; + // } + + private _doIt() { + //... + this._onDidChange.fire(value); + } + } + */ +class Emitter { + constructor(options) { + var _a, _b, _c, _d, _e; + this._size = 0; + this._options = options; + this._leakageMon = _globalLeakWarningThreshold > 0 || ((_a = this._options) === null || _a === void 0 ? void 0 : _a.leakWarningThreshold) ? new LeakageMonitor((_c = (_b = this._options) === null || _b === void 0 ? void 0 : _b.leakWarningThreshold) !== null && _c !== void 0 ? _c : _globalLeakWarningThreshold) : undefined; + this._perfMon = ((_d = this._options) === null || _d === void 0 ? void 0 : _d._profName) ? new EventProfiling(this._options._profName) : undefined; + this._deliveryQueue = (_e = this._options) === null || _e === void 0 ? void 0 : _e.deliveryQueue; + } + dispose() { + var _a, _b, _c, _d; + if (!this._disposed) { + this._disposed = true; + // It is bad to have listeners at the time of disposing an emitter, it is worst to have listeners keep the emitter + // alive via the reference that's embedded in their disposables. Therefore we loop over all remaining listeners and + // unset their subscriptions/disposables. Looping and blaming remaining listeners is done on next tick because the + // the following programming pattern is very popular: + // + // const someModel = this._disposables.add(new ModelObject()); // (1) create and register model + // this._disposables.add(someModel.onDidChange(() => { ... }); // (2) subscribe and register model-event listener + // ...later... + // this._disposables.dispose(); disposes (1) then (2): don't warn after (1) but after the "overall dispose" is done + if (((_a = this._deliveryQueue) === null || _a === void 0 ? void 0 : _a.current) === this) { + this._deliveryQueue.reset(); + } + if (this._listeners) { + if (_enableDisposeWithListenerWarning) { + const listeners = this._listeners; + queueMicrotask(() => { + forEachListener(listeners, l => { var _a; return (_a = l.stack) === null || _a === void 0 ? void 0 : _a.print(); }); + }); + } + this._listeners = undefined; + this._size = 0; + } + (_c = (_b = this._options) === null || _b === void 0 ? void 0 : _b.onDidRemoveLastListener) === null || _c === void 0 ? void 0 : _c.call(_b); + (_d = this._leakageMon) === null || _d === void 0 ? void 0 : _d.dispose(); + } + } + /** + * For the public to allow to subscribe + * to events from this Emitter + */ + get event() { + var _a; + (_a = this._event) !== null && _a !== void 0 ? _a : (this._event = (callback, thisArgs, disposables) => { + var _a, _b, _c, _d, _e; + if (this._leakageMon && this._size > this._leakageMon.threshold * 3) { + console.warn(`[${this._leakageMon.name}] REFUSES to accept new listeners because it exceeded its threshold by far`); + return _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.Disposable.None; + } + if (this._disposed) { + // todo: should we warn if a listener is added to a disposed emitter? This happens often + return _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.Disposable.None; + } + if (thisArgs) { + callback = callback.bind(thisArgs); + } + const contained = new UniqueContainer(callback); + let removeMonitor; + let stack; + if (this._leakageMon && this._size >= Math.ceil(this._leakageMon.threshold * 0.2)) { + // check and record this emitter for potential leakage + contained.stack = Stacktrace.create(); + removeMonitor = this._leakageMon.check(contained.stack, this._size + 1); + } + if (_enableDisposeWithListenerWarning) { + contained.stack = stack !== null && stack !== void 0 ? stack : Stacktrace.create(); + } + if (!this._listeners) { + (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.onWillAddFirstListener) === null || _b === void 0 ? void 0 : _b.call(_a, this); + this._listeners = contained; + (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.onDidAddFirstListener) === null || _d === void 0 ? void 0 : _d.call(_c, this); + } + else if (this._listeners instanceof UniqueContainer) { + (_e = this._deliveryQueue) !== null && _e !== void 0 ? _e : (this._deliveryQueue = new EventDeliveryQueuePrivate()); + this._listeners = [this._listeners, contained]; + } + else { + this._listeners.push(contained); + } + this._size++; + const result = (0,_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.toDisposable)(() => { removeMonitor === null || removeMonitor === void 0 ? void 0 : removeMonitor(); this._removeListener(contained); }); + if (disposables instanceof _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.DisposableStore) { + disposables.add(result); + } + else if (Array.isArray(disposables)) { + disposables.push(result); + } + return result; + }); + return this._event; + } + _removeListener(listener) { + var _a, _b, _c, _d; + (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.onWillRemoveListener) === null || _b === void 0 ? void 0 : _b.call(_a, this); + if (!this._listeners) { + return; // expected if a listener gets disposed + } + if (this._size === 1) { + this._listeners = undefined; + (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.onDidRemoveLastListener) === null || _d === void 0 ? void 0 : _d.call(_c, this); + this._size = 0; + return; + } + // size > 1 which requires that listeners be a list: + const listeners = this._listeners; + const index = listeners.indexOf(listener); + if (index === -1) { + console.log('disposed?', this._disposed); + console.log('size?', this._size); + console.log('arr?', JSON.stringify(this._listeners)); + throw new Error('Attempted to dispose unknown listener'); + } + this._size--; + listeners[index] = undefined; + const adjustDeliveryQueue = this._deliveryQueue.current === this; + if (this._size * compactionThreshold <= listeners.length) { + let n = 0; + for (let i = 0; i < listeners.length; i++) { + if (listeners[i]) { + listeners[n++] = listeners[i]; + } + else if (adjustDeliveryQueue) { + this._deliveryQueue.end--; + if (n < this._deliveryQueue.i) { + this._deliveryQueue.i--; + } + } + } + listeners.length = n; + } + } + _deliver(listener, value) { + var _a; + if (!listener) { + return; + } + const errorHandler = ((_a = this._options) === null || _a === void 0 ? void 0 : _a.onListenerError) || _errors_js__WEBPACK_IMPORTED_MODULE_0__.onUnexpectedError; + if (!errorHandler) { + listener.value(value); + return; + } + try { + listener.value(value); + } + catch (e) { + errorHandler(e); + } + } + /** Delivers items in the queue. Assumes the queue is ready to go. */ + _deliverQueue(dq) { + const listeners = dq.current._listeners; + while (dq.i < dq.end) { + // important: dq.i is incremented before calling deliver() because it might reenter deliverQueue() + this._deliver(listeners[dq.i++], dq.value); + } + dq.reset(); + } + /** + * To be kept private to fire an event to + * subscribers + */ + fire(event) { + var _a, _b, _c, _d; + if ((_a = this._deliveryQueue) === null || _a === void 0 ? void 0 : _a.current) { + this._deliverQueue(this._deliveryQueue); + (_b = this._perfMon) === null || _b === void 0 ? void 0 : _b.stop(); // last fire() will have starting perfmon, stop it before starting the next dispatch + } + (_c = this._perfMon) === null || _c === void 0 ? void 0 : _c.start(this._size); + if (!this._listeners) { + // no-op + } + else if (this._listeners instanceof UniqueContainer) { + this._deliver(this._listeners, event); + } + else { + const dq = this._deliveryQueue; + dq.enqueue(this, event, this._listeners.length); + this._deliverQueue(dq); + } + (_d = this._perfMon) === null || _d === void 0 ? void 0 : _d.stop(); + } + hasListeners() { + return this._size > 0; + } +} +const createEventDeliveryQueue = () => new EventDeliveryQueuePrivate(); +class EventDeliveryQueuePrivate { + constructor() { + /** + * Index in current's listener list. + */ + this.i = -1; + /** + * The last index in the listener's list to deliver. + */ + this.end = 0; + } + enqueue(emitter, value, end) { + this.i = 0; + this.end = end; + this.current = emitter; + this.value = value; + } + reset() { + this.i = this.end; // force any current emission loop to stop, mainly for during dispose + this.current = undefined; + this.value = undefined; + } +} +class PauseableEmitter extends Emitter { + constructor(options) { + super(options); + this._isPaused = 0; + this._eventQueue = new _linkedList_js__WEBPACK_IMPORTED_MODULE_3__.LinkedList(); + this._mergeFn = options === null || options === void 0 ? void 0 : options.merge; + } + pause() { + this._isPaused++; + } + resume() { + if (this._isPaused !== 0 && --this._isPaused === 0) { + if (this._mergeFn) { + // use the merge function to create a single composite + // event. make a copy in case firing pauses this emitter + if (this._eventQueue.size > 0) { + const events = Array.from(this._eventQueue); + this._eventQueue.clear(); + super.fire(this._mergeFn(events)); + } + } + else { + // no merging, fire each event individually and test + // that this emitter isn't paused halfway through + while (!this._isPaused && this._eventQueue.size !== 0) { + super.fire(this._eventQueue.shift()); + } + } + } + } + fire(event) { + if (this._size) { + if (this._isPaused !== 0) { + this._eventQueue.push(event); + } + else { + super.fire(event); + } + } + } +} +class DebounceEmitter extends PauseableEmitter { + constructor(options) { + var _a; + super(options); + this._delay = (_a = options.delay) !== null && _a !== void 0 ? _a : 100; + } + fire(event) { + if (!this._handle) { + this.pause(); + this._handle = setTimeout(() => { + this._handle = undefined; + this.resume(); + }, this._delay); + } + super.fire(event); + } +} +/** + * An emitter which queue all events and then process them at the + * end of the event loop. + */ +class MicrotaskEmitter extends Emitter { + constructor(options) { + super(options); + this._queuedEvents = []; + this._mergeFn = options === null || options === void 0 ? void 0 : options.merge; + } + fire(event) { + if (!this.hasListeners()) { + return; + } + this._queuedEvents.push(event); + if (this._queuedEvents.length === 1) { + queueMicrotask(() => { + if (this._mergeFn) { + super.fire(this._mergeFn(this._queuedEvents)); + } + else { + this._queuedEvents.forEach(e => super.fire(e)); + } + this._queuedEvents = []; + }); + } + } +} +/** + * An event emitter that multiplexes many events into a single event. + * + * @example Listen to the `onData` event of all `Thing`s, dynamically adding and removing `Thing`s + * to the multiplexer as needed. + * + * ```typescript + * const anythingDataMultiplexer = new EventMultiplexer<{ data: string }>(); + * + * const thingListeners = DisposableMap(); + * + * thingService.onDidAddThing(thing => { + * thingListeners.set(thing, anythingDataMultiplexer.add(thing.onData); + * }); + * thingService.onDidRemoveThing(thing => { + * thingListeners.deleteAndDispose(thing); + * }); + * + * anythingDataMultiplexer.event(e => { + * console.log('Something fired data ' + e.data) + * }); + * ``` + */ +class EventMultiplexer { + constructor() { + this.hasListeners = false; + this.events = []; + this.emitter = new Emitter({ + onWillAddFirstListener: () => this.onFirstListenerAdd(), + onDidRemoveLastListener: () => this.onLastListenerRemove() + }); + } + get event() { + return this.emitter.event; + } + add(event) { + const e = { event: event, listener: null }; + this.events.push(e); + if (this.hasListeners) { + this.hook(e); + } + const dispose = () => { + if (this.hasListeners) { + this.unhook(e); + } + const idx = this.events.indexOf(e); + this.events.splice(idx, 1); + }; + return (0,_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.toDisposable)((0,_functional_js__WEBPACK_IMPORTED_MODULE_1__.createSingleCallFunction)(dispose)); + } + onFirstListenerAdd() { + this.hasListeners = true; + this.events.forEach(e => this.hook(e)); + } + onLastListenerRemove() { + this.hasListeners = false; + this.events.forEach(e => this.unhook(e)); + } + hook(e) { + e.listener = e.event(r => this.emitter.fire(r)); + } + unhook(e) { + if (e.listener) { + e.listener.dispose(); + } + e.listener = null; + } + dispose() { + this.emitter.dispose(); + } +} +/** + * The EventBufferer is useful in situations in which you want + * to delay firing your events during some code. + * You can wrap that code and be sure that the event will not + * be fired during that wrap. + * + * ``` + * const emitter: Emitter; + * const delayer = new EventDelayer(); + * const delayedEvent = delayer.wrapEvent(emitter.event); + * + * delayedEvent(console.log); + * + * delayer.bufferEvents(() => { + * emitter.fire(); // event will not be fired yet + * }); + * + * // event will only be fired at this point + * ``` + */ +class EventBufferer { + constructor() { + this.buffers = []; + } + wrapEvent(event) { + return (listener, thisArgs, disposables) => { + return event(i => { + const buffer = this.buffers[this.buffers.length - 1]; + if (buffer) { + buffer.push(() => listener.call(thisArgs, i)); + } + else { + listener.call(thisArgs, i); + } + }, undefined, disposables); + }; + } + bufferEvents(fn) { + const buffer = []; + this.buffers.push(buffer); + const r = fn(); + this.buffers.pop(); + buffer.forEach(flush => flush()); + return r; + } +} +/** + * A Relay is an event forwarder which functions as a replugabble event pipe. + * Once created, you can connect an input event to it and it will simply forward + * events from that input event through its own `event` property. The `input` + * can be changed at any point in time. + */ +class Relay { + constructor() { + this.listening = false; + this.inputEvent = Event.None; + this.inputEventListener = _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.Disposable.None; + this.emitter = new Emitter({ + onDidAddFirstListener: () => { + this.listening = true; + this.inputEventListener = this.inputEvent(this.emitter.fire, this.emitter); + }, + onDidRemoveLastListener: () => { + this.listening = false; + this.inputEventListener.dispose(); + } + }); + this.event = this.emitter.event; + } + set input(event) { + this.inputEvent = event; + if (this.listening) { + this.inputEventListener.dispose(); + this.inputEventListener = event(this.emitter.fire, this.emitter); + } + } + dispose() { + this.inputEventListener.dispose(); + this.emitter.dispose(); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/functional.js": +/*!*********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/functional.js ***! + \*********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ createSingleCallFunction: () => (/* binding */ createSingleCallFunction) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/** + * Given a function, returns a function that is only calling that function once. + */ +function createSingleCallFunction(fn, fnDidRunCallback) { + const _this = this; + let didCall = false; + let result; + return function () { + if (didCall) { + return result; + } + didCall = true; + if (fnDidRunCallback) { + try { + result = fn.apply(_this, arguments); + } + finally { + fnDidRunCallback(); + } + } + else { + result = fn.apply(_this, arguments); + } + return result; + }; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/hash.js": +/*!***************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/hash.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ StringSHA1: () => (/* binding */ StringSHA1), +/* harmony export */ doHash: () => (/* binding */ doHash), +/* harmony export */ hash: () => (/* binding */ hash), +/* harmony export */ numberHash: () => (/* binding */ numberHash), +/* harmony export */ stringHash: () => (/* binding */ stringHash), +/* harmony export */ toHexString: () => (/* binding */ toHexString) +/* harmony export */ }); +/* harmony import */ var _strings_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./strings.js */ "./node_modules/monaco-editor/esm/vs/base/common/strings.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * Return a hash value for an object. + */ +function hash(obj) { + return doHash(obj, 0); +} +function doHash(obj, hashVal) { + switch (typeof obj) { + case 'object': + if (obj === null) { + return numberHash(349, hashVal); + } + else if (Array.isArray(obj)) { + return arrayHash(obj, hashVal); + } + return objectHash(obj, hashVal); + case 'string': + return stringHash(obj, hashVal); + case 'boolean': + return booleanHash(obj, hashVal); + case 'number': + return numberHash(obj, hashVal); + case 'undefined': + return numberHash(937, hashVal); + default: + return numberHash(617, hashVal); + } +} +function numberHash(val, initialHashVal) { + return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32 +} +function booleanHash(b, initialHashVal) { + return numberHash(b ? 433 : 863, initialHashVal); +} +function stringHash(s, hashVal) { + hashVal = numberHash(149417, hashVal); + for (let i = 0, length = s.length; i < length; i++) { + hashVal = numberHash(s.charCodeAt(i), hashVal); + } + return hashVal; +} +function arrayHash(arr, initialHashVal) { + initialHashVal = numberHash(104579, initialHashVal); + return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal); +} +function objectHash(obj, initialHashVal) { + initialHashVal = numberHash(181387, initialHashVal); + return Object.keys(obj).sort().reduce((hashVal, key) => { + hashVal = stringHash(key, hashVal); + return doHash(obj[key], hashVal); + }, initialHashVal); +} +function leftRotate(value, bits, totalBits = 32) { + // delta + bits = totalBits + const delta = totalBits - bits; + // All ones, expect `delta` zeros aligned to the right + const mask = ~((1 << delta) - 1); + // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits) + return ((value << bits) | ((mask & value) >>> delta)) >>> 0; +} +function fill(dest, index = 0, count = dest.byteLength, value = 0) { + for (let i = 0; i < count; i++) { + dest[index + i] = value; + } +} +function leftPad(value, length, char = '0') { + while (value.length < length) { + value = char + value; + } + return value; +} +function toHexString(bufferOrValue, bitsize = 32) { + if (bufferOrValue instanceof ArrayBuffer) { + return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join(''); + } + return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4); +} +/** + * A SHA1 implementation that works with strings and does not allocate. + */ +class StringSHA1 { + constructor() { + this._h0 = 0x67452301; + this._h1 = 0xEFCDAB89; + this._h2 = 0x98BADCFE; + this._h3 = 0x10325476; + this._h4 = 0xC3D2E1F0; + this._buff = new Uint8Array(64 /* SHA1Constant.BLOCK_SIZE */ + 3 /* to fit any utf-8 */); + this._buffDV = new DataView(this._buff.buffer); + this._buffLen = 0; + this._totalLen = 0; + this._leftoverHighSurrogate = 0; + this._finished = false; + } + update(str) { + const strLen = str.length; + if (strLen === 0) { + return; + } + const buff = this._buff; + let buffLen = this._buffLen; + let leftoverHighSurrogate = this._leftoverHighSurrogate; + let charCode; + let offset; + if (leftoverHighSurrogate !== 0) { + charCode = leftoverHighSurrogate; + offset = -1; + leftoverHighSurrogate = 0; + } + else { + charCode = str.charCodeAt(0); + offset = 0; + } + while (true) { + let codePoint = charCode; + if (_strings_js__WEBPACK_IMPORTED_MODULE_0__.isHighSurrogate(charCode)) { + if (offset + 1 < strLen) { + const nextCharCode = str.charCodeAt(offset + 1); + if (_strings_js__WEBPACK_IMPORTED_MODULE_0__.isLowSurrogate(nextCharCode)) { + offset++; + codePoint = _strings_js__WEBPACK_IMPORTED_MODULE_0__.computeCodePoint(charCode, nextCharCode); + } + else { + // illegal => unicode replacement character + codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */; + } + } + else { + // last character is a surrogate pair + leftoverHighSurrogate = charCode; + break; + } + } + else if (_strings_js__WEBPACK_IMPORTED_MODULE_0__.isLowSurrogate(charCode)) { + // illegal => unicode replacement character + codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */; + } + buffLen = this._push(buff, buffLen, codePoint); + offset++; + if (offset < strLen) { + charCode = str.charCodeAt(offset); + } + else { + break; + } + } + this._buffLen = buffLen; + this._leftoverHighSurrogate = leftoverHighSurrogate; + } + _push(buff, buffLen, codePoint) { + if (codePoint < 0x0080) { + buff[buffLen++] = codePoint; + } + else if (codePoint < 0x0800) { + buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6); + buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0); + } + else if (codePoint < 0x10000) { + buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12); + buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6); + buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0); + } + else { + buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18); + buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12); + buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6); + buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0); + } + if (buffLen >= 64 /* SHA1Constant.BLOCK_SIZE */) { + this._step(); + buffLen -= 64 /* SHA1Constant.BLOCK_SIZE */; + this._totalLen += 64 /* SHA1Constant.BLOCK_SIZE */; + // take last 3 in case of UTF8 overflow + buff[0] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 0]; + buff[1] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 1]; + buff[2] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 2]; + } + return buffLen; + } + digest() { + if (!this._finished) { + this._finished = true; + if (this._leftoverHighSurrogate) { + // illegal => unicode replacement character + this._leftoverHighSurrogate = 0; + this._buffLen = this._push(this._buff, this._buffLen, 65533 /* SHA1Constant.UNICODE_REPLACEMENT */); + } + this._totalLen += this._buffLen; + this._wrapUp(); + } + return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4); + } + _wrapUp() { + this._buff[this._buffLen++] = 0x80; + fill(this._buff, this._buffLen); + if (this._buffLen > 56) { + this._step(); + fill(this._buff); + } + // this will fit because the mantissa can cover up to 52 bits + const ml = 8 * this._totalLen; + this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false); + this._buffDV.setUint32(60, ml % 4294967296, false); + this._step(); + } + _step() { + const bigBlock32 = StringSHA1._bigBlock32; + const data = this._buffDV; + for (let j = 0; j < 64 /* 16*4 */; j += 4) { + bigBlock32.setUint32(j, data.getUint32(j, false), false); + } + for (let j = 64; j < 320 /* 80*4 */; j += 4) { + bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false); + } + let a = this._h0; + let b = this._h1; + let c = this._h2; + let d = this._h3; + let e = this._h4; + let f, k; + let temp; + for (let j = 0; j < 80; j++) { + if (j < 20) { + f = (b & c) | ((~b) & d); + k = 0x5A827999; + } + else if (j < 40) { + f = b ^ c ^ d; + k = 0x6ED9EBA1; + } + else if (j < 60) { + f = (b & c) | (b & d) | (c & d); + k = 0x8F1BBCDC; + } + else { + f = b ^ c ^ d; + k = 0xCA62C1D6; + } + temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff; + e = d; + d = c; + c = leftRotate(b, 30); + b = a; + a = temp; + } + this._h0 = (this._h0 + a) & 0xffffffff; + this._h1 = (this._h1 + b) & 0xffffffff; + this._h2 = (this._h2 + c) & 0xffffffff; + this._h3 = (this._h3 + d) & 0xffffffff; + this._h4 = (this._h4 + e) & 0xffffffff; + } +} +StringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320 + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/iterator.js": +/*!*******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/iterator.js ***! + \*******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Iterable: () => (/* binding */ Iterable) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +var Iterable; +(function (Iterable) { + function is(thing) { + return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function'; + } + Iterable.is = is; + const _empty = Object.freeze([]); + function empty() { + return _empty; + } + Iterable.empty = empty; + function* single(element) { + yield element; + } + Iterable.single = single; + function wrap(iterableOrElement) { + if (is(iterableOrElement)) { + return iterableOrElement; + } + else { + return single(iterableOrElement); + } + } + Iterable.wrap = wrap; + function from(iterable) { + return iterable || _empty; + } + Iterable.from = from; + function* reverse(array) { + for (let i = array.length - 1; i >= 0; i--) { + yield array[i]; + } + } + Iterable.reverse = reverse; + function isEmpty(iterable) { + return !iterable || iterable[Symbol.iterator]().next().done === true; + } + Iterable.isEmpty = isEmpty; + function first(iterable) { + return iterable[Symbol.iterator]().next().value; + } + Iterable.first = first; + function some(iterable, predicate) { + for (const element of iterable) { + if (predicate(element)) { + return true; + } + } + return false; + } + Iterable.some = some; + function find(iterable, predicate) { + for (const element of iterable) { + if (predicate(element)) { + return element; + } + } + return undefined; + } + Iterable.find = find; + function* filter(iterable, predicate) { + for (const element of iterable) { + if (predicate(element)) { + yield element; + } + } + } + Iterable.filter = filter; + function* map(iterable, fn) { + let index = 0; + for (const element of iterable) { + yield fn(element, index++); + } + } + Iterable.map = map; + function* concat(...iterables) { + for (const iterable of iterables) { + yield* iterable; + } + } + Iterable.concat = concat; + function reduce(iterable, reducer, initialValue) { + let value = initialValue; + for (const element of iterable) { + value = reducer(value, element); + } + return value; + } + Iterable.reduce = reduce; + /** + * Returns an iterable slice of the array, with the same semantics as `array.slice()`. + */ + function* slice(arr, from, to = arr.length) { + if (from < 0) { + from += arr.length; + } + if (to < 0) { + to += arr.length; + } + else if (to > arr.length) { + to = arr.length; + } + for (; from < to; from++) { + yield arr[from]; + } + } + Iterable.slice = slice; + /** + * Consumes `atMost` elements from iterable and returns the consumed elements, + * and an iterable for the rest of the elements. + */ + function consume(iterable, atMost = Number.POSITIVE_INFINITY) { + const consumed = []; + if (atMost === 0) { + return [consumed, iterable]; + } + const iterator = iterable[Symbol.iterator](); + for (let i = 0; i < atMost; i++) { + const next = iterator.next(); + if (next.done) { + return [consumed, Iterable.empty()]; + } + consumed.push(next.value); + } + return [consumed, { [Symbol.iterator]() { return iterator; } }]; + } + Iterable.consume = consume; +})(Iterable || (Iterable = {})); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/keyCodes.js": +/*!*******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/keyCodes.js ***! + \*******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ EVENT_KEY_CODE_MAP: () => (/* binding */ EVENT_KEY_CODE_MAP), +/* harmony export */ IMMUTABLE_CODE_TO_KEY_CODE: () => (/* binding */ IMMUTABLE_CODE_TO_KEY_CODE), +/* harmony export */ IMMUTABLE_KEY_CODE_TO_CODE: () => (/* binding */ IMMUTABLE_KEY_CODE_TO_CODE), +/* harmony export */ KeyChord: () => (/* binding */ KeyChord), +/* harmony export */ KeyCodeUtils: () => (/* binding */ KeyCodeUtils), +/* harmony export */ NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE: () => (/* binding */ NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +class KeyCodeStrMap { + constructor() { + this._keyCodeToStr = []; + this._strToKeyCode = Object.create(null); + } + define(keyCode, str) { + this._keyCodeToStr[keyCode] = str; + this._strToKeyCode[str.toLowerCase()] = keyCode; + } + keyCodeToStr(keyCode) { + return this._keyCodeToStr[keyCode]; + } + strToKeyCode(str) { + return this._strToKeyCode[str.toLowerCase()] || 0 /* KeyCode.Unknown */; + } +} +const uiMap = new KeyCodeStrMap(); +const userSettingsUSMap = new KeyCodeStrMap(); +const userSettingsGeneralMap = new KeyCodeStrMap(); +const EVENT_KEY_CODE_MAP = new Array(230); +const NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE = {}; +const scanCodeIntToStr = []; +const scanCodeStrToInt = Object.create(null); +const scanCodeLowerCaseStrToInt = Object.create(null); +/** + * -1 if a ScanCode => KeyCode mapping depends on kb layout. + */ +const IMMUTABLE_CODE_TO_KEY_CODE = []; +/** + * -1 if a KeyCode => ScanCode mapping depends on kb layout. + */ +const IMMUTABLE_KEY_CODE_TO_CODE = []; +for (let i = 0; i <= 193 /* ScanCode.MAX_VALUE */; i++) { + IMMUTABLE_CODE_TO_KEY_CODE[i] = -1 /* KeyCode.DependsOnKbLayout */; +} +for (let i = 0; i <= 132 /* KeyCode.MAX_VALUE */; i++) { + IMMUTABLE_KEY_CODE_TO_CODE[i] = -1 /* ScanCode.DependsOnKbLayout */; +} +(function () { + // See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx + // See https://github.com/microsoft/node-native-keymap/blob/88c0b0e5/deps/chromium/keyboard_codes_win.h + const empty = ''; + const mappings = [ + // immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel + [1, 0 /* ScanCode.None */, 'None', 0 /* KeyCode.Unknown */, 'unknown', 0, 'VK_UNKNOWN', empty, empty], + [1, 1 /* ScanCode.Hyper */, 'Hyper', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 2 /* ScanCode.Super */, 'Super', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 3 /* ScanCode.Fn */, 'Fn', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 4 /* ScanCode.FnLock */, 'FnLock', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 5 /* ScanCode.Suspend */, 'Suspend', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 6 /* ScanCode.Resume */, 'Resume', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 7 /* ScanCode.Turbo */, 'Turbo', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 8 /* ScanCode.Sleep */, 'Sleep', 0 /* KeyCode.Unknown */, empty, 0, 'VK_SLEEP', empty, empty], + [1, 9 /* ScanCode.WakeUp */, 'WakeUp', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [0, 10 /* ScanCode.KeyA */, 'KeyA', 31 /* KeyCode.KeyA */, 'A', 65, 'VK_A', empty, empty], + [0, 11 /* ScanCode.KeyB */, 'KeyB', 32 /* KeyCode.KeyB */, 'B', 66, 'VK_B', empty, empty], + [0, 12 /* ScanCode.KeyC */, 'KeyC', 33 /* KeyCode.KeyC */, 'C', 67, 'VK_C', empty, empty], + [0, 13 /* ScanCode.KeyD */, 'KeyD', 34 /* KeyCode.KeyD */, 'D', 68, 'VK_D', empty, empty], + [0, 14 /* ScanCode.KeyE */, 'KeyE', 35 /* KeyCode.KeyE */, 'E', 69, 'VK_E', empty, empty], + [0, 15 /* ScanCode.KeyF */, 'KeyF', 36 /* KeyCode.KeyF */, 'F', 70, 'VK_F', empty, empty], + [0, 16 /* ScanCode.KeyG */, 'KeyG', 37 /* KeyCode.KeyG */, 'G', 71, 'VK_G', empty, empty], + [0, 17 /* ScanCode.KeyH */, 'KeyH', 38 /* KeyCode.KeyH */, 'H', 72, 'VK_H', empty, empty], + [0, 18 /* ScanCode.KeyI */, 'KeyI', 39 /* KeyCode.KeyI */, 'I', 73, 'VK_I', empty, empty], + [0, 19 /* ScanCode.KeyJ */, 'KeyJ', 40 /* KeyCode.KeyJ */, 'J', 74, 'VK_J', empty, empty], + [0, 20 /* ScanCode.KeyK */, 'KeyK', 41 /* KeyCode.KeyK */, 'K', 75, 'VK_K', empty, empty], + [0, 21 /* ScanCode.KeyL */, 'KeyL', 42 /* KeyCode.KeyL */, 'L', 76, 'VK_L', empty, empty], + [0, 22 /* ScanCode.KeyM */, 'KeyM', 43 /* KeyCode.KeyM */, 'M', 77, 'VK_M', empty, empty], + [0, 23 /* ScanCode.KeyN */, 'KeyN', 44 /* KeyCode.KeyN */, 'N', 78, 'VK_N', empty, empty], + [0, 24 /* ScanCode.KeyO */, 'KeyO', 45 /* KeyCode.KeyO */, 'O', 79, 'VK_O', empty, empty], + [0, 25 /* ScanCode.KeyP */, 'KeyP', 46 /* KeyCode.KeyP */, 'P', 80, 'VK_P', empty, empty], + [0, 26 /* ScanCode.KeyQ */, 'KeyQ', 47 /* KeyCode.KeyQ */, 'Q', 81, 'VK_Q', empty, empty], + [0, 27 /* ScanCode.KeyR */, 'KeyR', 48 /* KeyCode.KeyR */, 'R', 82, 'VK_R', empty, empty], + [0, 28 /* ScanCode.KeyS */, 'KeyS', 49 /* KeyCode.KeyS */, 'S', 83, 'VK_S', empty, empty], + [0, 29 /* ScanCode.KeyT */, 'KeyT', 50 /* KeyCode.KeyT */, 'T', 84, 'VK_T', empty, empty], + [0, 30 /* ScanCode.KeyU */, 'KeyU', 51 /* KeyCode.KeyU */, 'U', 85, 'VK_U', empty, empty], + [0, 31 /* ScanCode.KeyV */, 'KeyV', 52 /* KeyCode.KeyV */, 'V', 86, 'VK_V', empty, empty], + [0, 32 /* ScanCode.KeyW */, 'KeyW', 53 /* KeyCode.KeyW */, 'W', 87, 'VK_W', empty, empty], + [0, 33 /* ScanCode.KeyX */, 'KeyX', 54 /* KeyCode.KeyX */, 'X', 88, 'VK_X', empty, empty], + [0, 34 /* ScanCode.KeyY */, 'KeyY', 55 /* KeyCode.KeyY */, 'Y', 89, 'VK_Y', empty, empty], + [0, 35 /* ScanCode.KeyZ */, 'KeyZ', 56 /* KeyCode.KeyZ */, 'Z', 90, 'VK_Z', empty, empty], + [0, 36 /* ScanCode.Digit1 */, 'Digit1', 22 /* KeyCode.Digit1 */, '1', 49, 'VK_1', empty, empty], + [0, 37 /* ScanCode.Digit2 */, 'Digit2', 23 /* KeyCode.Digit2 */, '2', 50, 'VK_2', empty, empty], + [0, 38 /* ScanCode.Digit3 */, 'Digit3', 24 /* KeyCode.Digit3 */, '3', 51, 'VK_3', empty, empty], + [0, 39 /* ScanCode.Digit4 */, 'Digit4', 25 /* KeyCode.Digit4 */, '4', 52, 'VK_4', empty, empty], + [0, 40 /* ScanCode.Digit5 */, 'Digit5', 26 /* KeyCode.Digit5 */, '5', 53, 'VK_5', empty, empty], + [0, 41 /* ScanCode.Digit6 */, 'Digit6', 27 /* KeyCode.Digit6 */, '6', 54, 'VK_6', empty, empty], + [0, 42 /* ScanCode.Digit7 */, 'Digit7', 28 /* KeyCode.Digit7 */, '7', 55, 'VK_7', empty, empty], + [0, 43 /* ScanCode.Digit8 */, 'Digit8', 29 /* KeyCode.Digit8 */, '8', 56, 'VK_8', empty, empty], + [0, 44 /* ScanCode.Digit9 */, 'Digit9', 30 /* KeyCode.Digit9 */, '9', 57, 'VK_9', empty, empty], + [0, 45 /* ScanCode.Digit0 */, 'Digit0', 21 /* KeyCode.Digit0 */, '0', 48, 'VK_0', empty, empty], + [1, 46 /* ScanCode.Enter */, 'Enter', 3 /* KeyCode.Enter */, 'Enter', 13, 'VK_RETURN', empty, empty], + [1, 47 /* ScanCode.Escape */, 'Escape', 9 /* KeyCode.Escape */, 'Escape', 27, 'VK_ESCAPE', empty, empty], + [1, 48 /* ScanCode.Backspace */, 'Backspace', 1 /* KeyCode.Backspace */, 'Backspace', 8, 'VK_BACK', empty, empty], + [1, 49 /* ScanCode.Tab */, 'Tab', 2 /* KeyCode.Tab */, 'Tab', 9, 'VK_TAB', empty, empty], + [1, 50 /* ScanCode.Space */, 'Space', 10 /* KeyCode.Space */, 'Space', 32, 'VK_SPACE', empty, empty], + [0, 51 /* ScanCode.Minus */, 'Minus', 88 /* KeyCode.Minus */, '-', 189, 'VK_OEM_MINUS', '-', 'OEM_MINUS'], + [0, 52 /* ScanCode.Equal */, 'Equal', 86 /* KeyCode.Equal */, '=', 187, 'VK_OEM_PLUS', '=', 'OEM_PLUS'], + [0, 53 /* ScanCode.BracketLeft */, 'BracketLeft', 92 /* KeyCode.BracketLeft */, '[', 219, 'VK_OEM_4', '[', 'OEM_4'], + [0, 54 /* ScanCode.BracketRight */, 'BracketRight', 94 /* KeyCode.BracketRight */, ']', 221, 'VK_OEM_6', ']', 'OEM_6'], + [0, 55 /* ScanCode.Backslash */, 'Backslash', 93 /* KeyCode.Backslash */, '\\', 220, 'VK_OEM_5', '\\', 'OEM_5'], + [0, 56 /* ScanCode.IntlHash */, 'IntlHash', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], // has been dropped from the w3c spec + [0, 57 /* ScanCode.Semicolon */, 'Semicolon', 85 /* KeyCode.Semicolon */, ';', 186, 'VK_OEM_1', ';', 'OEM_1'], + [0, 58 /* ScanCode.Quote */, 'Quote', 95 /* KeyCode.Quote */, '\'', 222, 'VK_OEM_7', '\'', 'OEM_7'], + [0, 59 /* ScanCode.Backquote */, 'Backquote', 91 /* KeyCode.Backquote */, '`', 192, 'VK_OEM_3', '`', 'OEM_3'], + [0, 60 /* ScanCode.Comma */, 'Comma', 87 /* KeyCode.Comma */, ',', 188, 'VK_OEM_COMMA', ',', 'OEM_COMMA'], + [0, 61 /* ScanCode.Period */, 'Period', 89 /* KeyCode.Period */, '.', 190, 'VK_OEM_PERIOD', '.', 'OEM_PERIOD'], + [0, 62 /* ScanCode.Slash */, 'Slash', 90 /* KeyCode.Slash */, '/', 191, 'VK_OEM_2', '/', 'OEM_2'], + [1, 63 /* ScanCode.CapsLock */, 'CapsLock', 8 /* KeyCode.CapsLock */, 'CapsLock', 20, 'VK_CAPITAL', empty, empty], + [1, 64 /* ScanCode.F1 */, 'F1', 59 /* KeyCode.F1 */, 'F1', 112, 'VK_F1', empty, empty], + [1, 65 /* ScanCode.F2 */, 'F2', 60 /* KeyCode.F2 */, 'F2', 113, 'VK_F2', empty, empty], + [1, 66 /* ScanCode.F3 */, 'F3', 61 /* KeyCode.F3 */, 'F3', 114, 'VK_F3', empty, empty], + [1, 67 /* ScanCode.F4 */, 'F4', 62 /* KeyCode.F4 */, 'F4', 115, 'VK_F4', empty, empty], + [1, 68 /* ScanCode.F5 */, 'F5', 63 /* KeyCode.F5 */, 'F5', 116, 'VK_F5', empty, empty], + [1, 69 /* ScanCode.F6 */, 'F6', 64 /* KeyCode.F6 */, 'F6', 117, 'VK_F6', empty, empty], + [1, 70 /* ScanCode.F7 */, 'F7', 65 /* KeyCode.F7 */, 'F7', 118, 'VK_F7', empty, empty], + [1, 71 /* ScanCode.F8 */, 'F8', 66 /* KeyCode.F8 */, 'F8', 119, 'VK_F8', empty, empty], + [1, 72 /* ScanCode.F9 */, 'F9', 67 /* KeyCode.F9 */, 'F9', 120, 'VK_F9', empty, empty], + [1, 73 /* ScanCode.F10 */, 'F10', 68 /* KeyCode.F10 */, 'F10', 121, 'VK_F10', empty, empty], + [1, 74 /* ScanCode.F11 */, 'F11', 69 /* KeyCode.F11 */, 'F11', 122, 'VK_F11', empty, empty], + [1, 75 /* ScanCode.F12 */, 'F12', 70 /* KeyCode.F12 */, 'F12', 123, 'VK_F12', empty, empty], + [1, 76 /* ScanCode.PrintScreen */, 'PrintScreen', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 77 /* ScanCode.ScrollLock */, 'ScrollLock', 84 /* KeyCode.ScrollLock */, 'ScrollLock', 145, 'VK_SCROLL', empty, empty], + [1, 78 /* ScanCode.Pause */, 'Pause', 7 /* KeyCode.PauseBreak */, 'PauseBreak', 19, 'VK_PAUSE', empty, empty], + [1, 79 /* ScanCode.Insert */, 'Insert', 19 /* KeyCode.Insert */, 'Insert', 45, 'VK_INSERT', empty, empty], + [1, 80 /* ScanCode.Home */, 'Home', 14 /* KeyCode.Home */, 'Home', 36, 'VK_HOME', empty, empty], + [1, 81 /* ScanCode.PageUp */, 'PageUp', 11 /* KeyCode.PageUp */, 'PageUp', 33, 'VK_PRIOR', empty, empty], + [1, 82 /* ScanCode.Delete */, 'Delete', 20 /* KeyCode.Delete */, 'Delete', 46, 'VK_DELETE', empty, empty], + [1, 83 /* ScanCode.End */, 'End', 13 /* KeyCode.End */, 'End', 35, 'VK_END', empty, empty], + [1, 84 /* ScanCode.PageDown */, 'PageDown', 12 /* KeyCode.PageDown */, 'PageDown', 34, 'VK_NEXT', empty, empty], + [1, 85 /* ScanCode.ArrowRight */, 'ArrowRight', 17 /* KeyCode.RightArrow */, 'RightArrow', 39, 'VK_RIGHT', 'Right', empty], + [1, 86 /* ScanCode.ArrowLeft */, 'ArrowLeft', 15 /* KeyCode.LeftArrow */, 'LeftArrow', 37, 'VK_LEFT', 'Left', empty], + [1, 87 /* ScanCode.ArrowDown */, 'ArrowDown', 18 /* KeyCode.DownArrow */, 'DownArrow', 40, 'VK_DOWN', 'Down', empty], + [1, 88 /* ScanCode.ArrowUp */, 'ArrowUp', 16 /* KeyCode.UpArrow */, 'UpArrow', 38, 'VK_UP', 'Up', empty], + [1, 89 /* ScanCode.NumLock */, 'NumLock', 83 /* KeyCode.NumLock */, 'NumLock', 144, 'VK_NUMLOCK', empty, empty], + [1, 90 /* ScanCode.NumpadDivide */, 'NumpadDivide', 113 /* KeyCode.NumpadDivide */, 'NumPad_Divide', 111, 'VK_DIVIDE', empty, empty], + [1, 91 /* ScanCode.NumpadMultiply */, 'NumpadMultiply', 108 /* KeyCode.NumpadMultiply */, 'NumPad_Multiply', 106, 'VK_MULTIPLY', empty, empty], + [1, 92 /* ScanCode.NumpadSubtract */, 'NumpadSubtract', 111 /* KeyCode.NumpadSubtract */, 'NumPad_Subtract', 109, 'VK_SUBTRACT', empty, empty], + [1, 93 /* ScanCode.NumpadAdd */, 'NumpadAdd', 109 /* KeyCode.NumpadAdd */, 'NumPad_Add', 107, 'VK_ADD', empty, empty], + [1, 94 /* ScanCode.NumpadEnter */, 'NumpadEnter', 3 /* KeyCode.Enter */, empty, 0, empty, empty, empty], + [1, 95 /* ScanCode.Numpad1 */, 'Numpad1', 99 /* KeyCode.Numpad1 */, 'NumPad1', 97, 'VK_NUMPAD1', empty, empty], + [1, 96 /* ScanCode.Numpad2 */, 'Numpad2', 100 /* KeyCode.Numpad2 */, 'NumPad2', 98, 'VK_NUMPAD2', empty, empty], + [1, 97 /* ScanCode.Numpad3 */, 'Numpad3', 101 /* KeyCode.Numpad3 */, 'NumPad3', 99, 'VK_NUMPAD3', empty, empty], + [1, 98 /* ScanCode.Numpad4 */, 'Numpad4', 102 /* KeyCode.Numpad4 */, 'NumPad4', 100, 'VK_NUMPAD4', empty, empty], + [1, 99 /* ScanCode.Numpad5 */, 'Numpad5', 103 /* KeyCode.Numpad5 */, 'NumPad5', 101, 'VK_NUMPAD5', empty, empty], + [1, 100 /* ScanCode.Numpad6 */, 'Numpad6', 104 /* KeyCode.Numpad6 */, 'NumPad6', 102, 'VK_NUMPAD6', empty, empty], + [1, 101 /* ScanCode.Numpad7 */, 'Numpad7', 105 /* KeyCode.Numpad7 */, 'NumPad7', 103, 'VK_NUMPAD7', empty, empty], + [1, 102 /* ScanCode.Numpad8 */, 'Numpad8', 106 /* KeyCode.Numpad8 */, 'NumPad8', 104, 'VK_NUMPAD8', empty, empty], + [1, 103 /* ScanCode.Numpad9 */, 'Numpad9', 107 /* KeyCode.Numpad9 */, 'NumPad9', 105, 'VK_NUMPAD9', empty, empty], + [1, 104 /* ScanCode.Numpad0 */, 'Numpad0', 98 /* KeyCode.Numpad0 */, 'NumPad0', 96, 'VK_NUMPAD0', empty, empty], + [1, 105 /* ScanCode.NumpadDecimal */, 'NumpadDecimal', 112 /* KeyCode.NumpadDecimal */, 'NumPad_Decimal', 110, 'VK_DECIMAL', empty, empty], + [0, 106 /* ScanCode.IntlBackslash */, 'IntlBackslash', 97 /* KeyCode.IntlBackslash */, 'OEM_102', 226, 'VK_OEM_102', empty, empty], + [1, 107 /* ScanCode.ContextMenu */, 'ContextMenu', 58 /* KeyCode.ContextMenu */, 'ContextMenu', 93, empty, empty, empty], + [1, 108 /* ScanCode.Power */, 'Power', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 109 /* ScanCode.NumpadEqual */, 'NumpadEqual', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 110 /* ScanCode.F13 */, 'F13', 71 /* KeyCode.F13 */, 'F13', 124, 'VK_F13', empty, empty], + [1, 111 /* ScanCode.F14 */, 'F14', 72 /* KeyCode.F14 */, 'F14', 125, 'VK_F14', empty, empty], + [1, 112 /* ScanCode.F15 */, 'F15', 73 /* KeyCode.F15 */, 'F15', 126, 'VK_F15', empty, empty], + [1, 113 /* ScanCode.F16 */, 'F16', 74 /* KeyCode.F16 */, 'F16', 127, 'VK_F16', empty, empty], + [1, 114 /* ScanCode.F17 */, 'F17', 75 /* KeyCode.F17 */, 'F17', 128, 'VK_F17', empty, empty], + [1, 115 /* ScanCode.F18 */, 'F18', 76 /* KeyCode.F18 */, 'F18', 129, 'VK_F18', empty, empty], + [1, 116 /* ScanCode.F19 */, 'F19', 77 /* KeyCode.F19 */, 'F19', 130, 'VK_F19', empty, empty], + [1, 117 /* ScanCode.F20 */, 'F20', 78 /* KeyCode.F20 */, 'F20', 131, 'VK_F20', empty, empty], + [1, 118 /* ScanCode.F21 */, 'F21', 79 /* KeyCode.F21 */, 'F21', 132, 'VK_F21', empty, empty], + [1, 119 /* ScanCode.F22 */, 'F22', 80 /* KeyCode.F22 */, 'F22', 133, 'VK_F22', empty, empty], + [1, 120 /* ScanCode.F23 */, 'F23', 81 /* KeyCode.F23 */, 'F23', 134, 'VK_F23', empty, empty], + [1, 121 /* ScanCode.F24 */, 'F24', 82 /* KeyCode.F24 */, 'F24', 135, 'VK_F24', empty, empty], + [1, 122 /* ScanCode.Open */, 'Open', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 123 /* ScanCode.Help */, 'Help', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 124 /* ScanCode.Select */, 'Select', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 125 /* ScanCode.Again */, 'Again', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 126 /* ScanCode.Undo */, 'Undo', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 127 /* ScanCode.Cut */, 'Cut', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 128 /* ScanCode.Copy */, 'Copy', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 129 /* ScanCode.Paste */, 'Paste', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 130 /* ScanCode.Find */, 'Find', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 131 /* ScanCode.AudioVolumeMute */, 'AudioVolumeMute', 117 /* KeyCode.AudioVolumeMute */, 'AudioVolumeMute', 173, 'VK_VOLUME_MUTE', empty, empty], + [1, 132 /* ScanCode.AudioVolumeUp */, 'AudioVolumeUp', 118 /* KeyCode.AudioVolumeUp */, 'AudioVolumeUp', 175, 'VK_VOLUME_UP', empty, empty], + [1, 133 /* ScanCode.AudioVolumeDown */, 'AudioVolumeDown', 119 /* KeyCode.AudioVolumeDown */, 'AudioVolumeDown', 174, 'VK_VOLUME_DOWN', empty, empty], + [1, 134 /* ScanCode.NumpadComma */, 'NumpadComma', 110 /* KeyCode.NUMPAD_SEPARATOR */, 'NumPad_Separator', 108, 'VK_SEPARATOR', empty, empty], + [0, 135 /* ScanCode.IntlRo */, 'IntlRo', 115 /* KeyCode.ABNT_C1 */, 'ABNT_C1', 193, 'VK_ABNT_C1', empty, empty], + [1, 136 /* ScanCode.KanaMode */, 'KanaMode', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [0, 137 /* ScanCode.IntlYen */, 'IntlYen', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 138 /* ScanCode.Convert */, 'Convert', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 139 /* ScanCode.NonConvert */, 'NonConvert', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 140 /* ScanCode.Lang1 */, 'Lang1', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 141 /* ScanCode.Lang2 */, 'Lang2', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 142 /* ScanCode.Lang3 */, 'Lang3', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 143 /* ScanCode.Lang4 */, 'Lang4', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 144 /* ScanCode.Lang5 */, 'Lang5', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 145 /* ScanCode.Abort */, 'Abort', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 146 /* ScanCode.Props */, 'Props', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 147 /* ScanCode.NumpadParenLeft */, 'NumpadParenLeft', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 148 /* ScanCode.NumpadParenRight */, 'NumpadParenRight', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 149 /* ScanCode.NumpadBackspace */, 'NumpadBackspace', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 150 /* ScanCode.NumpadMemoryStore */, 'NumpadMemoryStore', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 151 /* ScanCode.NumpadMemoryRecall */, 'NumpadMemoryRecall', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 152 /* ScanCode.NumpadMemoryClear */, 'NumpadMemoryClear', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 153 /* ScanCode.NumpadMemoryAdd */, 'NumpadMemoryAdd', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 154 /* ScanCode.NumpadMemorySubtract */, 'NumpadMemorySubtract', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 155 /* ScanCode.NumpadClear */, 'NumpadClear', 131 /* KeyCode.Clear */, 'Clear', 12, 'VK_CLEAR', empty, empty], + [1, 156 /* ScanCode.NumpadClearEntry */, 'NumpadClearEntry', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 0 /* ScanCode.None */, empty, 5 /* KeyCode.Ctrl */, 'Ctrl', 17, 'VK_CONTROL', empty, empty], + [1, 0 /* ScanCode.None */, empty, 4 /* KeyCode.Shift */, 'Shift', 16, 'VK_SHIFT', empty, empty], + [1, 0 /* ScanCode.None */, empty, 6 /* KeyCode.Alt */, 'Alt', 18, 'VK_MENU', empty, empty], + [1, 0 /* ScanCode.None */, empty, 57 /* KeyCode.Meta */, 'Meta', 91, 'VK_COMMAND', empty, empty], + [1, 157 /* ScanCode.ControlLeft */, 'ControlLeft', 5 /* KeyCode.Ctrl */, empty, 0, 'VK_LCONTROL', empty, empty], + [1, 158 /* ScanCode.ShiftLeft */, 'ShiftLeft', 4 /* KeyCode.Shift */, empty, 0, 'VK_LSHIFT', empty, empty], + [1, 159 /* ScanCode.AltLeft */, 'AltLeft', 6 /* KeyCode.Alt */, empty, 0, 'VK_LMENU', empty, empty], + [1, 160 /* ScanCode.MetaLeft */, 'MetaLeft', 57 /* KeyCode.Meta */, empty, 0, 'VK_LWIN', empty, empty], + [1, 161 /* ScanCode.ControlRight */, 'ControlRight', 5 /* KeyCode.Ctrl */, empty, 0, 'VK_RCONTROL', empty, empty], + [1, 162 /* ScanCode.ShiftRight */, 'ShiftRight', 4 /* KeyCode.Shift */, empty, 0, 'VK_RSHIFT', empty, empty], + [1, 163 /* ScanCode.AltRight */, 'AltRight', 6 /* KeyCode.Alt */, empty, 0, 'VK_RMENU', empty, empty], + [1, 164 /* ScanCode.MetaRight */, 'MetaRight', 57 /* KeyCode.Meta */, empty, 0, 'VK_RWIN', empty, empty], + [1, 165 /* ScanCode.BrightnessUp */, 'BrightnessUp', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 166 /* ScanCode.BrightnessDown */, 'BrightnessDown', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 167 /* ScanCode.MediaPlay */, 'MediaPlay', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 168 /* ScanCode.MediaRecord */, 'MediaRecord', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 169 /* ScanCode.MediaFastForward */, 'MediaFastForward', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 170 /* ScanCode.MediaRewind */, 'MediaRewind', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 171 /* ScanCode.MediaTrackNext */, 'MediaTrackNext', 124 /* KeyCode.MediaTrackNext */, 'MediaTrackNext', 176, 'VK_MEDIA_NEXT_TRACK', empty, empty], + [1, 172 /* ScanCode.MediaTrackPrevious */, 'MediaTrackPrevious', 125 /* KeyCode.MediaTrackPrevious */, 'MediaTrackPrevious', 177, 'VK_MEDIA_PREV_TRACK', empty, empty], + [1, 173 /* ScanCode.MediaStop */, 'MediaStop', 126 /* KeyCode.MediaStop */, 'MediaStop', 178, 'VK_MEDIA_STOP', empty, empty], + [1, 174 /* ScanCode.Eject */, 'Eject', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 175 /* ScanCode.MediaPlayPause */, 'MediaPlayPause', 127 /* KeyCode.MediaPlayPause */, 'MediaPlayPause', 179, 'VK_MEDIA_PLAY_PAUSE', empty, empty], + [1, 176 /* ScanCode.MediaSelect */, 'MediaSelect', 128 /* KeyCode.LaunchMediaPlayer */, 'LaunchMediaPlayer', 181, 'VK_MEDIA_LAUNCH_MEDIA_SELECT', empty, empty], + [1, 177 /* ScanCode.LaunchMail */, 'LaunchMail', 129 /* KeyCode.LaunchMail */, 'LaunchMail', 180, 'VK_MEDIA_LAUNCH_MAIL', empty, empty], + [1, 178 /* ScanCode.LaunchApp2 */, 'LaunchApp2', 130 /* KeyCode.LaunchApp2 */, 'LaunchApp2', 183, 'VK_MEDIA_LAUNCH_APP2', empty, empty], + [1, 179 /* ScanCode.LaunchApp1 */, 'LaunchApp1', 0 /* KeyCode.Unknown */, empty, 0, 'VK_MEDIA_LAUNCH_APP1', empty, empty], + [1, 180 /* ScanCode.SelectTask */, 'SelectTask', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 181 /* ScanCode.LaunchScreenSaver */, 'LaunchScreenSaver', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 182 /* ScanCode.BrowserSearch */, 'BrowserSearch', 120 /* KeyCode.BrowserSearch */, 'BrowserSearch', 170, 'VK_BROWSER_SEARCH', empty, empty], + [1, 183 /* ScanCode.BrowserHome */, 'BrowserHome', 121 /* KeyCode.BrowserHome */, 'BrowserHome', 172, 'VK_BROWSER_HOME', empty, empty], + [1, 184 /* ScanCode.BrowserBack */, 'BrowserBack', 122 /* KeyCode.BrowserBack */, 'BrowserBack', 166, 'VK_BROWSER_BACK', empty, empty], + [1, 185 /* ScanCode.BrowserForward */, 'BrowserForward', 123 /* KeyCode.BrowserForward */, 'BrowserForward', 167, 'VK_BROWSER_FORWARD', empty, empty], + [1, 186 /* ScanCode.BrowserStop */, 'BrowserStop', 0 /* KeyCode.Unknown */, empty, 0, 'VK_BROWSER_STOP', empty, empty], + [1, 187 /* ScanCode.BrowserRefresh */, 'BrowserRefresh', 0 /* KeyCode.Unknown */, empty, 0, 'VK_BROWSER_REFRESH', empty, empty], + [1, 188 /* ScanCode.BrowserFavorites */, 'BrowserFavorites', 0 /* KeyCode.Unknown */, empty, 0, 'VK_BROWSER_FAVORITES', empty, empty], + [1, 189 /* ScanCode.ZoomToggle */, 'ZoomToggle', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 190 /* ScanCode.MailReply */, 'MailReply', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 191 /* ScanCode.MailForward */, 'MailForward', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + [1, 192 /* ScanCode.MailSend */, 'MailSend', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], + // See https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html + // If an Input Method Editor is processing key input and the event is keydown, return 229. + [1, 0 /* ScanCode.None */, empty, 114 /* KeyCode.KEY_IN_COMPOSITION */, 'KeyInComposition', 229, empty, empty, empty], + [1, 0 /* ScanCode.None */, empty, 116 /* KeyCode.ABNT_C2 */, 'ABNT_C2', 194, 'VK_ABNT_C2', empty, empty], + [1, 0 /* ScanCode.None */, empty, 96 /* KeyCode.OEM_8 */, 'OEM_8', 223, 'VK_OEM_8', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_KANA', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_HANGUL', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_JUNJA', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_FINAL', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_HANJA', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_KANJI', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_CONVERT', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_NONCONVERT', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_ACCEPT', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_MODECHANGE', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_SELECT', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PRINT', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_EXECUTE', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_SNAPSHOT', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_HELP', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_APPS', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PROCESSKEY', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PACKET', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_DBE_SBCSCHAR', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_DBE_DBCSCHAR', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_ATTN', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_CRSEL', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_EXSEL', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_EREOF', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PLAY', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_ZOOM', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_NONAME', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PA1', empty, empty], + [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_OEM_CLEAR', empty, empty], + ]; + const seenKeyCode = []; + const seenScanCode = []; + for (const mapping of mappings) { + const [immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel] = mapping; + if (!seenScanCode[scanCode]) { + seenScanCode[scanCode] = true; + scanCodeIntToStr[scanCode] = scanCodeStr; + scanCodeStrToInt[scanCodeStr] = scanCode; + scanCodeLowerCaseStrToInt[scanCodeStr.toLowerCase()] = scanCode; + if (immutable) { + IMMUTABLE_CODE_TO_KEY_CODE[scanCode] = keyCode; + if ((keyCode !== 0 /* KeyCode.Unknown */) + && (keyCode !== 3 /* KeyCode.Enter */) + && (keyCode !== 5 /* KeyCode.Ctrl */) + && (keyCode !== 4 /* KeyCode.Shift */) + && (keyCode !== 6 /* KeyCode.Alt */) + && (keyCode !== 57 /* KeyCode.Meta */)) { + IMMUTABLE_KEY_CODE_TO_CODE[keyCode] = scanCode; + } + } + } + if (!seenKeyCode[keyCode]) { + seenKeyCode[keyCode] = true; + if (!keyCodeStr) { + throw new Error(`String representation missing for key code ${keyCode} around scan code ${scanCodeStr}`); + } + uiMap.define(keyCode, keyCodeStr); + userSettingsUSMap.define(keyCode, usUserSettingsLabel || keyCodeStr); + userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel || usUserSettingsLabel || keyCodeStr); + } + if (eventKeyCode) { + EVENT_KEY_CODE_MAP[eventKeyCode] = keyCode; + } + if (vkey) { + NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[vkey] = keyCode; + } + } + // Manually added due to the exclusion above (due to duplication with NumpadEnter) + IMMUTABLE_KEY_CODE_TO_CODE[3 /* KeyCode.Enter */] = 46 /* ScanCode.Enter */; +})(); +var KeyCodeUtils; +(function (KeyCodeUtils) { + function toString(keyCode) { + return uiMap.keyCodeToStr(keyCode); + } + KeyCodeUtils.toString = toString; + function fromString(key) { + return uiMap.strToKeyCode(key); + } + KeyCodeUtils.fromString = fromString; + function toUserSettingsUS(keyCode) { + return userSettingsUSMap.keyCodeToStr(keyCode); + } + KeyCodeUtils.toUserSettingsUS = toUserSettingsUS; + function toUserSettingsGeneral(keyCode) { + return userSettingsGeneralMap.keyCodeToStr(keyCode); + } + KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral; + function fromUserSettings(key) { + return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key); + } + KeyCodeUtils.fromUserSettings = fromUserSettings; + function toElectronAccelerator(keyCode) { + if (keyCode >= 98 /* KeyCode.Numpad0 */ && keyCode <= 113 /* KeyCode.NumpadDivide */) { + // [Electron Accelerators] Electron is able to parse numpad keys, but unfortunately it + // renders them just as regular keys in menus. For example, num0 is rendered as "0", + // numdiv is rendered as "/", numsub is rendered as "-". + // + // This can lead to incredible confusion, as it makes numpad based keybindings indistinguishable + // from keybindings based on regular keys. + // + // We therefore need to fall back to custom rendering for numpad keys. + return null; + } + switch (keyCode) { + case 16 /* KeyCode.UpArrow */: + return 'Up'; + case 18 /* KeyCode.DownArrow */: + return 'Down'; + case 15 /* KeyCode.LeftArrow */: + return 'Left'; + case 17 /* KeyCode.RightArrow */: + return 'Right'; + } + return uiMap.keyCodeToStr(keyCode); + } + KeyCodeUtils.toElectronAccelerator = toElectronAccelerator; +})(KeyCodeUtils || (KeyCodeUtils = {})); +function KeyChord(firstPart, secondPart) { + const chordPart = ((secondPart & 0x0000FFFF) << 16) >>> 0; + return (firstPart | chordPart) >>> 0; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/lazy.js": +/*!***************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/lazy.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Lazy: () => (/* binding */ Lazy) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +class Lazy { + constructor(executor) { + this.executor = executor; + this._didRun = false; + } + /** + * Get the wrapped value. + * + * This will force evaluation of the lazy value if it has not been resolved yet. Lazy values are only + * resolved once. `getValue` will re-throw exceptions that are hit while resolving the value + */ + get value() { + if (!this._didRun) { + try { + this._value = this.executor(); + } + catch (err) { + this._error = err; + } + finally { + this._didRun = true; + } + } + if (this._error) { + throw this._error; + } + return this._value; + } + /** + * Get the wrapped value without forcing evaluation. + */ + get rawValue() { return this._value; } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js": +/*!********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Disposable: () => (/* binding */ Disposable), +/* harmony export */ DisposableMap: () => (/* binding */ DisposableMap), +/* harmony export */ DisposableStore: () => (/* binding */ DisposableStore), +/* harmony export */ ImmortalReference: () => (/* binding */ ImmortalReference), +/* harmony export */ MutableDisposable: () => (/* binding */ MutableDisposable), +/* harmony export */ RefCountedDisposable: () => (/* binding */ RefCountedDisposable), +/* harmony export */ combinedDisposable: () => (/* binding */ combinedDisposable), +/* harmony export */ dispose: () => (/* binding */ dispose), +/* harmony export */ isDisposable: () => (/* binding */ isDisposable), +/* harmony export */ markAsDisposed: () => (/* binding */ markAsDisposed), +/* harmony export */ markAsSingleton: () => (/* binding */ markAsSingleton), +/* harmony export */ setDisposableTracker: () => (/* binding */ setDisposableTracker), +/* harmony export */ toDisposable: () => (/* binding */ toDisposable), +/* harmony export */ trackDisposable: () => (/* binding */ trackDisposable) +/* harmony export */ }); +/* harmony import */ var _functional_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./functional.js */ "./node_modules/monaco-editor/esm/vs/base/common/functional.js"); +/* harmony import */ var _iterator_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./iterator.js */ "./node_modules/monaco-editor/esm/vs/base/common/iterator.js"); + + +// #region Disposable Tracking +/** + * Enables logging of potentially leaked disposables. + * + * A disposable is considered leaked if it is not disposed or not registered as the child of + * another disposable. This tracking is very simple an only works for classes that either + * extend Disposable or use a DisposableStore. This means there are a lot of false positives. + */ +const TRACK_DISPOSABLES = false; +let disposableTracker = null; +function setDisposableTracker(tracker) { + disposableTracker = tracker; +} +if (TRACK_DISPOSABLES) { + const __is_disposable_tracked__ = '__is_disposable_tracked__'; + setDisposableTracker(new class { + trackDisposable(x) { + const stack = new Error('Potentially leaked disposable').stack; + setTimeout(() => { + if (!x[__is_disposable_tracked__]) { + console.log(stack); + } + }, 3000); + } + setParent(child, parent) { + if (child && child !== Disposable.None) { + try { + child[__is_disposable_tracked__] = true; + } + catch (_a) { + // noop + } + } + } + markAsDisposed(disposable) { + if (disposable && disposable !== Disposable.None) { + try { + disposable[__is_disposable_tracked__] = true; + } + catch (_a) { + // noop + } + } + } + markAsSingleton(disposable) { } + }); +} +function trackDisposable(x) { + disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.trackDisposable(x); + return x; +} +function markAsDisposed(disposable) { + disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsDisposed(disposable); +} +function setParentOfDisposable(child, parent) { + disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.setParent(child, parent); +} +function setParentOfDisposables(children, parent) { + if (!disposableTracker) { + return; + } + for (const child of children) { + disposableTracker.setParent(child, parent); + } +} +/** + * Indicates that the given object is a singleton which does not need to be disposed. +*/ +function markAsSingleton(singleton) { + disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsSingleton(singleton); + return singleton; +} +/** + * Check if `thing` is {@link IDisposable disposable}. + */ +function isDisposable(thing) { + return typeof thing.dispose === 'function' && thing.dispose.length === 0; +} +function dispose(arg) { + if (_iterator_js__WEBPACK_IMPORTED_MODULE_1__.Iterable.is(arg)) { + const errors = []; + for (const d of arg) { + if (d) { + try { + d.dispose(); + } + catch (e) { + errors.push(e); + } + } + } + if (errors.length === 1) { + throw errors[0]; + } + else if (errors.length > 1) { + throw new AggregateError(errors, 'Encountered errors while disposing of store'); + } + return Array.isArray(arg) ? [] : arg; + } + else if (arg) { + arg.dispose(); + return arg; + } +} +/** + * Combine multiple disposable values into a single {@link IDisposable}. + */ +function combinedDisposable(...disposables) { + const parent = toDisposable(() => dispose(disposables)); + setParentOfDisposables(disposables, parent); + return parent; +} +/** + * Turn a function that implements dispose into an {@link IDisposable}. + * + * @param fn Clean up function, guaranteed to be called only **once**. + */ +function toDisposable(fn) { + const self = trackDisposable({ + dispose: (0,_functional_js__WEBPACK_IMPORTED_MODULE_0__.createSingleCallFunction)(() => { + markAsDisposed(self); + fn(); + }) + }); + return self; +} +/** + * Manages a collection of disposable values. + * + * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an + * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a + * store that has already been disposed of. + */ +class DisposableStore { + constructor() { + this._toDispose = new Set(); + this._isDisposed = false; + trackDisposable(this); + } + /** + * Dispose of all registered disposables and mark this object as disposed. + * + * Any future disposables added to this object will be disposed of on `add`. + */ + dispose() { + if (this._isDisposed) { + return; + } + markAsDisposed(this); + this._isDisposed = true; + this.clear(); + } + /** + * @return `true` if this object has been disposed of. + */ + get isDisposed() { + return this._isDisposed; + } + /** + * Dispose of all registered disposables but do not mark this object as disposed. + */ + clear() { + if (this._toDispose.size === 0) { + return; + } + try { + dispose(this._toDispose); + } + finally { + this._toDispose.clear(); + } + } + /** + * Add a new {@link IDisposable disposable} to the collection. + */ + add(o) { + if (!o) { + return o; + } + if (o === this) { + throw new Error('Cannot register a disposable on itself!'); + } + setParentOfDisposable(o, this); + if (this._isDisposed) { + if (!DisposableStore.DISABLE_DISPOSED_WARNING) { + console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack); + } + } + else { + this._toDispose.add(o); + } + return o; + } + /** + * Deletes the value from the store, but does not dispose it. + */ + deleteAndLeak(o) { + if (!o) { + return; + } + if (this._toDispose.has(o)) { + this._toDispose.delete(o); + setParentOfDisposable(o, null); + } + } +} +DisposableStore.DISABLE_DISPOSED_WARNING = false; +/** + * Abstract base class for a {@link IDisposable disposable} object. + * + * Subclasses can {@linkcode _register} disposables that will be automatically cleaned up when this object is disposed of. + */ +class Disposable { + constructor() { + this._store = new DisposableStore(); + trackDisposable(this); + setParentOfDisposable(this._store, this); + } + dispose() { + markAsDisposed(this); + this._store.dispose(); + } + /** + * Adds `o` to the collection of disposables managed by this object. + */ + _register(o) { + if (o === this) { + throw new Error('Cannot register a disposable on itself!'); + } + return this._store.add(o); + } +} +/** + * A disposable that does nothing when it is disposed of. + * + * TODO: This should not be a static property. + */ +Disposable.None = Object.freeze({ dispose() { } }); +/** + * Manages the lifecycle of a disposable value that may be changed. + * + * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can + * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up. + */ +class MutableDisposable { + constructor() { + this._isDisposed = false; + trackDisposable(this); + } + get value() { + return this._isDisposed ? undefined : this._value; + } + set value(value) { + var _a; + if (this._isDisposed || value === this._value) { + return; + } + (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose(); + if (value) { + setParentOfDisposable(value, this); + } + this._value = value; + } + /** + * Resets the stored value and disposed of the previously stored value. + */ + clear() { + this.value = undefined; + } + dispose() { + var _a; + this._isDisposed = true; + markAsDisposed(this); + (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose(); + this._value = undefined; + } +} +class RefCountedDisposable { + constructor(_disposable) { + this._disposable = _disposable; + this._counter = 1; + } + acquire() { + this._counter++; + return this; + } + release() { + if (--this._counter === 0) { + this._disposable.dispose(); + } + return this; + } +} +class ImmortalReference { + constructor(object) { + this.object = object; + } + dispose() { } +} +/** + * A map the manages the lifecycle of the values that it stores. + */ +class DisposableMap { + constructor() { + this._store = new Map(); + this._isDisposed = false; + trackDisposable(this); + } + /** + * Disposes of all stored values and mark this object as disposed. + * + * Trying to use this object after it has been disposed of is an error. + */ + dispose() { + markAsDisposed(this); + this._isDisposed = true; + this.clearAndDisposeAll(); + } + /** + * Disposes of all stored values and clear the map, but DO NOT mark this object as disposed. + */ + clearAndDisposeAll() { + if (!this._store.size) { + return; + } + try { + dispose(this._store.values()); + } + finally { + this._store.clear(); + } + } + get(key) { + return this._store.get(key); + } + set(key, value, skipDisposeOnOverwrite = false) { + var _a; + if (this._isDisposed) { + console.warn(new Error('Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!').stack); + } + if (!skipDisposeOnOverwrite) { + (_a = this._store.get(key)) === null || _a === void 0 ? void 0 : _a.dispose(); + } + this._store.set(key, value); + } + /** + * Delete the value stored for `key` from this map and also dispose of it. + */ + deleteAndDispose(key) { + var _a; + (_a = this._store.get(key)) === null || _a === void 0 ? void 0 : _a.dispose(); + this._store.delete(key); + } + [Symbol.iterator]() { + return this._store[Symbol.iterator](); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/linkedList.js": +/*!*********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/linkedList.js ***! + \*********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LinkedList: () => (/* binding */ LinkedList) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +class Node { + constructor(element) { + this.element = element; + this.next = Node.Undefined; + this.prev = Node.Undefined; + } +} +Node.Undefined = new Node(undefined); +class LinkedList { + constructor() { + this._first = Node.Undefined; + this._last = Node.Undefined; + this._size = 0; + } + get size() { + return this._size; + } + isEmpty() { + return this._first === Node.Undefined; + } + clear() { + let node = this._first; + while (node !== Node.Undefined) { + const next = node.next; + node.prev = Node.Undefined; + node.next = Node.Undefined; + node = next; + } + this._first = Node.Undefined; + this._last = Node.Undefined; + this._size = 0; + } + unshift(element) { + return this._insert(element, false); + } + push(element) { + return this._insert(element, true); + } + _insert(element, atTheEnd) { + const newNode = new Node(element); + if (this._first === Node.Undefined) { + this._first = newNode; + this._last = newNode; + } + else if (atTheEnd) { + // push + const oldLast = this._last; + this._last = newNode; + newNode.prev = oldLast; + oldLast.next = newNode; + } + else { + // unshift + const oldFirst = this._first; + this._first = newNode; + newNode.next = oldFirst; + oldFirst.prev = newNode; + } + this._size += 1; + let didRemove = false; + return () => { + if (!didRemove) { + didRemove = true; + this._remove(newNode); + } + }; + } + shift() { + if (this._first === Node.Undefined) { + return undefined; + } + else { + const res = this._first.element; + this._remove(this._first); + return res; + } + } + pop() { + if (this._last === Node.Undefined) { + return undefined; + } + else { + const res = this._last.element; + this._remove(this._last); + return res; + } + } + _remove(node) { + if (node.prev !== Node.Undefined && node.next !== Node.Undefined) { + // middle + const anchor = node.prev; + anchor.next = node.next; + node.next.prev = anchor; + } + else if (node.prev === Node.Undefined && node.next === Node.Undefined) { + // only node + this._first = Node.Undefined; + this._last = Node.Undefined; + } + else if (node.next === Node.Undefined) { + // last + this._last = this._last.prev; + this._last.next = Node.Undefined; + } + else if (node.prev === Node.Undefined) { + // first + this._first = this._first.next; + this._first.prev = Node.Undefined; + } + // done + this._size -= 1; + } + *[Symbol.iterator]() { + let node = this._first; + while (node !== Node.Undefined) { + yield node.element; + node = node.next; + } + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/map.js": +/*!**************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/map.js ***! + \**************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ BidirectionalMap: () => (/* binding */ BidirectionalMap), +/* harmony export */ LRUCache: () => (/* binding */ LRUCache), +/* harmony export */ LinkedMap: () => (/* binding */ LinkedMap), +/* harmony export */ ResourceMap: () => (/* binding */ ResourceMap), +/* harmony export */ SetMap: () => (/* binding */ SetMap) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +var _a, _b; +class ResourceMapEntry { + constructor(uri, value) { + this.uri = uri; + this.value = value; + } +} +function isEntries(arg) { + return Array.isArray(arg); +} +class ResourceMap { + constructor(arg, toKey) { + this[_a] = 'ResourceMap'; + if (arg instanceof ResourceMap) { + this.map = new Map(arg.map); + this.toKey = toKey !== null && toKey !== void 0 ? toKey : ResourceMap.defaultToKey; + } + else if (isEntries(arg)) { + this.map = new Map(); + this.toKey = toKey !== null && toKey !== void 0 ? toKey : ResourceMap.defaultToKey; + for (const [resource, value] of arg) { + this.set(resource, value); + } + } + else { + this.map = new Map(); + this.toKey = arg !== null && arg !== void 0 ? arg : ResourceMap.defaultToKey; + } + } + set(resource, value) { + this.map.set(this.toKey(resource), new ResourceMapEntry(resource, value)); + return this; + } + get(resource) { + var _c; + return (_c = this.map.get(this.toKey(resource))) === null || _c === void 0 ? void 0 : _c.value; + } + has(resource) { + return this.map.has(this.toKey(resource)); + } + get size() { + return this.map.size; + } + clear() { + this.map.clear(); + } + delete(resource) { + return this.map.delete(this.toKey(resource)); + } + forEach(clb, thisArg) { + if (typeof thisArg !== 'undefined') { + clb = clb.bind(thisArg); + } + for (const [_, entry] of this.map) { + clb(entry.value, entry.uri, this); + } + } + *values() { + for (const entry of this.map.values()) { + yield entry.value; + } + } + *keys() { + for (const entry of this.map.values()) { + yield entry.uri; + } + } + *entries() { + for (const entry of this.map.values()) { + yield [entry.uri, entry.value]; + } + } + *[(_a = Symbol.toStringTag, Symbol.iterator)]() { + for (const [, entry] of this.map) { + yield [entry.uri, entry.value]; + } + } +} +ResourceMap.defaultToKey = (resource) => resource.toString(); +class LinkedMap { + constructor() { + this[_b] = 'LinkedMap'; + this._map = new Map(); + this._head = undefined; + this._tail = undefined; + this._size = 0; + this._state = 0; + } + clear() { + this._map.clear(); + this._head = undefined; + this._tail = undefined; + this._size = 0; + this._state++; + } + isEmpty() { + return !this._head && !this._tail; + } + get size() { + return this._size; + } + get first() { + var _c; + return (_c = this._head) === null || _c === void 0 ? void 0 : _c.value; + } + get last() { + var _c; + return (_c = this._tail) === null || _c === void 0 ? void 0 : _c.value; + } + has(key) { + return this._map.has(key); + } + get(key, touch = 0 /* Touch.None */) { + const item = this._map.get(key); + if (!item) { + return undefined; + } + if (touch !== 0 /* Touch.None */) { + this.touch(item, touch); + } + return item.value; + } + set(key, value, touch = 0 /* Touch.None */) { + let item = this._map.get(key); + if (item) { + item.value = value; + if (touch !== 0 /* Touch.None */) { + this.touch(item, touch); + } + } + else { + item = { key, value, next: undefined, previous: undefined }; + switch (touch) { + case 0 /* Touch.None */: + this.addItemLast(item); + break; + case 1 /* Touch.AsOld */: + this.addItemFirst(item); + break; + case 2 /* Touch.AsNew */: + this.addItemLast(item); + break; + default: + this.addItemLast(item); + break; + } + this._map.set(key, item); + this._size++; + } + return this; + } + delete(key) { + return !!this.remove(key); + } + remove(key) { + const item = this._map.get(key); + if (!item) { + return undefined; + } + this._map.delete(key); + this.removeItem(item); + this._size--; + return item.value; + } + shift() { + if (!this._head && !this._tail) { + return undefined; + } + if (!this._head || !this._tail) { + throw new Error('Invalid list'); + } + const item = this._head; + this._map.delete(item.key); + this.removeItem(item); + this._size--; + return item.value; + } + forEach(callbackfn, thisArg) { + const state = this._state; + let current = this._head; + while (current) { + if (thisArg) { + callbackfn.bind(thisArg)(current.value, current.key, this); + } + else { + callbackfn(current.value, current.key, this); + } + if (this._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + current = current.next; + } + } + keys() { + const map = this; + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]() { + return iterator; + }, + next() { + if (map._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { value: current.key, done: false }; + current = current.next; + return result; + } + else { + return { value: undefined, done: true }; + } + } + }; + return iterator; + } + values() { + const map = this; + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]() { + return iterator; + }, + next() { + if (map._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { value: current.value, done: false }; + current = current.next; + return result; + } + else { + return { value: undefined, done: true }; + } + } + }; + return iterator; + } + entries() { + const map = this; + const state = this._state; + let current = this._head; + const iterator = { + [Symbol.iterator]() { + return iterator; + }, + next() { + if (map._state !== state) { + throw new Error(`LinkedMap got modified during iteration.`); + } + if (current) { + const result = { value: [current.key, current.value], done: false }; + current = current.next; + return result; + } + else { + return { value: undefined, done: true }; + } + } + }; + return iterator; + } + [(_b = Symbol.toStringTag, Symbol.iterator)]() { + return this.entries(); + } + trimOld(newSize) { + if (newSize >= this.size) { + return; + } + if (newSize === 0) { + this.clear(); + return; + } + let current = this._head; + let currentSize = this.size; + while (current && currentSize > newSize) { + this._map.delete(current.key); + current = current.next; + currentSize--; + } + this._head = current; + this._size = currentSize; + if (current) { + current.previous = undefined; + } + this._state++; + } + addItemFirst(item) { + // First time Insert + if (!this._head && !this._tail) { + this._tail = item; + } + else if (!this._head) { + throw new Error('Invalid list'); + } + else { + item.next = this._head; + this._head.previous = item; + } + this._head = item; + this._state++; + } + addItemLast(item) { + // First time Insert + if (!this._head && !this._tail) { + this._head = item; + } + else if (!this._tail) { + throw new Error('Invalid list'); + } + else { + item.previous = this._tail; + this._tail.next = item; + } + this._tail = item; + this._state++; + } + removeItem(item) { + if (item === this._head && item === this._tail) { + this._head = undefined; + this._tail = undefined; + } + else if (item === this._head) { + // This can only happen if size === 1 which is handled + // by the case above. + if (!item.next) { + throw new Error('Invalid list'); + } + item.next.previous = undefined; + this._head = item.next; + } + else if (item === this._tail) { + // This can only happen if size === 1 which is handled + // by the case above. + if (!item.previous) { + throw new Error('Invalid list'); + } + item.previous.next = undefined; + this._tail = item.previous; + } + else { + const next = item.next; + const previous = item.previous; + if (!next || !previous) { + throw new Error('Invalid list'); + } + next.previous = previous; + previous.next = next; + } + item.next = undefined; + item.previous = undefined; + this._state++; + } + touch(item, touch) { + if (!this._head || !this._tail) { + throw new Error('Invalid list'); + } + if ((touch !== 1 /* Touch.AsOld */ && touch !== 2 /* Touch.AsNew */)) { + return; + } + if (touch === 1 /* Touch.AsOld */) { + if (item === this._head) { + return; + } + const next = item.next; + const previous = item.previous; + // Unlink the item + if (item === this._tail) { + // previous must be defined since item was not head but is tail + // So there are more than on item in the map + previous.next = undefined; + this._tail = previous; + } + else { + // Both next and previous are not undefined since item was neither head nor tail. + next.previous = previous; + previous.next = next; + } + // Insert the node at head + item.previous = undefined; + item.next = this._head; + this._head.previous = item; + this._head = item; + this._state++; + } + else if (touch === 2 /* Touch.AsNew */) { + if (item === this._tail) { + return; + } + const next = item.next; + const previous = item.previous; + // Unlink the item. + if (item === this._head) { + // next must be defined since item was not tail but is head + // So there are more than on item in the map + next.previous = undefined; + this._head = next; + } + else { + // Both next and previous are not undefined since item was neither head nor tail. + next.previous = previous; + previous.next = next; + } + item.next = undefined; + item.previous = this._tail; + this._tail.next = item; + this._tail = item; + this._state++; + } + } + toJSON() { + const data = []; + this.forEach((value, key) => { + data.push([key, value]); + }); + return data; + } + fromJSON(data) { + this.clear(); + for (const [key, value] of data) { + this.set(key, value); + } + } +} +class LRUCache extends LinkedMap { + constructor(limit, ratio = 1) { + super(); + this._limit = limit; + this._ratio = Math.min(Math.max(0, ratio), 1); + } + get limit() { + return this._limit; + } + set limit(limit) { + this._limit = limit; + this.checkTrim(); + } + get(key, touch = 2 /* Touch.AsNew */) { + return super.get(key, touch); + } + peek(key) { + return super.get(key, 0 /* Touch.None */); + } + set(key, value) { + super.set(key, value, 2 /* Touch.AsNew */); + this.checkTrim(); + return this; + } + checkTrim() { + if (this.size > this._limit) { + this.trimOld(Math.round(this._limit * this._ratio)); + } + } +} +/** + * A map that allows access both by keys and values. + * **NOTE**: values need to be unique. + */ +class BidirectionalMap { + constructor(entries) { + this._m1 = new Map(); + this._m2 = new Map(); + if (entries) { + for (const [key, value] of entries) { + this.set(key, value); + } + } + } + clear() { + this._m1.clear(); + this._m2.clear(); + } + set(key, value) { + this._m1.set(key, value); + this._m2.set(value, key); + } + get(key) { + return this._m1.get(key); + } + getKey(value) { + return this._m2.get(value); + } + delete(key) { + const value = this._m1.get(key); + if (value === undefined) { + return false; + } + this._m1.delete(key); + this._m2.delete(value); + return true; + } + keys() { + return this._m1.keys(); + } + values() { + return this._m1.values(); + } +} +class SetMap { + constructor() { + this.map = new Map(); + } + add(key, value) { + let values = this.map.get(key); + if (!values) { + values = new Set(); + this.map.set(key, values); + } + values.add(value); + } + delete(key, value) { + const values = this.map.get(key); + if (!values) { + return; + } + values.delete(value); + if (values.size === 0) { + this.map.delete(key); + } + } + forEach(key, fn) { + const values = this.map.get(key); + if (!values) { + return; + } + values.forEach(fn); + } + get(key) { + const values = this.map.get(key); + if (!values) { + return new Set(); + } + return values; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/objects.js": +/*!******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/objects.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ cloneAndChange: () => (/* binding */ cloneAndChange), +/* harmony export */ createProxyObject: () => (/* binding */ createProxyObject), +/* harmony export */ deepClone: () => (/* binding */ deepClone), +/* harmony export */ deepFreeze: () => (/* binding */ deepFreeze), +/* harmony export */ equals: () => (/* binding */ equals), +/* harmony export */ getAllMethodNames: () => (/* binding */ getAllMethodNames), +/* harmony export */ getAllPropertyNames: () => (/* binding */ getAllPropertyNames), +/* harmony export */ mixin: () => (/* binding */ mixin) +/* harmony export */ }); +/* harmony import */ var _types_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./types.js */ "./node_modules/monaco-editor/esm/vs/base/common/types.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +function deepClone(obj) { + if (!obj || typeof obj !== 'object') { + return obj; + } + if (obj instanceof RegExp) { + return obj; + } + const result = Array.isArray(obj) ? [] : {}; + Object.entries(obj).forEach(([key, value]) => { + result[key] = value && typeof value === 'object' ? deepClone(value) : value; + }); + return result; +} +function deepFreeze(obj) { + if (!obj || typeof obj !== 'object') { + return obj; + } + const stack = [obj]; + while (stack.length > 0) { + const obj = stack.shift(); + Object.freeze(obj); + for (const key in obj) { + if (_hasOwnProperty.call(obj, key)) { + const prop = obj[key]; + if (typeof prop === 'object' && !Object.isFrozen(prop) && !(0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isTypedArray)(prop)) { + stack.push(prop); + } + } + } + } + return obj; +} +const _hasOwnProperty = Object.prototype.hasOwnProperty; +function cloneAndChange(obj, changer) { + return _cloneAndChange(obj, changer, new Set()); +} +function _cloneAndChange(obj, changer, seen) { + if ((0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isUndefinedOrNull)(obj)) { + return obj; + } + const changed = changer(obj); + if (typeof changed !== 'undefined') { + return changed; + } + if (Array.isArray(obj)) { + const r1 = []; + for (const e of obj) { + r1.push(_cloneAndChange(e, changer, seen)); + } + return r1; + } + if ((0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isObject)(obj)) { + if (seen.has(obj)) { + throw new Error('Cannot clone recursive data-structure'); + } + seen.add(obj); + const r2 = {}; + for (const i2 in obj) { + if (_hasOwnProperty.call(obj, i2)) { + r2[i2] = _cloneAndChange(obj[i2], changer, seen); + } + } + seen.delete(obj); + return r2; + } + return obj; +} +/** + * Copies all properties of source into destination. The optional parameter "overwrite" allows to control + * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite). + */ +function mixin(destination, source, overwrite = true) { + if (!(0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isObject)(destination)) { + return source; + } + if ((0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isObject)(source)) { + Object.keys(source).forEach(key => { + if (key in destination) { + if (overwrite) { + if ((0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isObject)(destination[key]) && (0,_types_js__WEBPACK_IMPORTED_MODULE_0__.isObject)(source[key])) { + mixin(destination[key], source[key], overwrite); + } + else { + destination[key] = source[key]; + } + } + } + else { + destination[key] = source[key]; + } + }); + } + return destination; +} +function equals(one, other) { + if (one === other) { + return true; + } + if (one === null || one === undefined || other === null || other === undefined) { + return false; + } + if (typeof one !== typeof other) { + return false; + } + if (typeof one !== 'object') { + return false; + } + if ((Array.isArray(one)) !== (Array.isArray(other))) { + return false; + } + let i; + let key; + if (Array.isArray(one)) { + if (one.length !== other.length) { + return false; + } + for (i = 0; i < one.length; i++) { + if (!equals(one[i], other[i])) { + return false; + } + } + } + else { + const oneKeys = []; + for (key in one) { + oneKeys.push(key); + } + oneKeys.sort(); + const otherKeys = []; + for (key in other) { + otherKeys.push(key); + } + otherKeys.sort(); + if (!equals(oneKeys, otherKeys)) { + return false; + } + for (i = 0; i < oneKeys.length; i++) { + if (!equals(one[oneKeys[i]], other[oneKeys[i]])) { + return false; + } + } + } + return true; +} +function getAllPropertyNames(obj) { + let res = []; + while (Object.prototype !== obj) { + res = res.concat(Object.getOwnPropertyNames(obj)); + obj = Object.getPrototypeOf(obj); + } + return res; +} +function getAllMethodNames(obj) { + const methods = []; + for (const prop of getAllPropertyNames(obj)) { + if (typeof obj[prop] === 'function') { + methods.push(prop); + } + } + return methods; +} +function createProxyObject(methodNames, invoke) { + const createProxyMethod = (method) => { + return function () { + const args = Array.prototype.slice.call(arguments, 0); + return invoke(method, args); + }; + }; + const result = {}; + for (const methodName of methodNames) { + result[methodName] = createProxyMethod(methodName); + } + return result; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/path.js": +/*!***************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/path.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ basename: () => (/* binding */ basename), +/* harmony export */ dirname: () => (/* binding */ dirname), +/* harmony export */ extname: () => (/* binding */ extname), +/* harmony export */ normalize: () => (/* binding */ normalize), +/* harmony export */ posix: () => (/* binding */ posix), +/* harmony export */ relative: () => (/* binding */ relative), +/* harmony export */ resolve: () => (/* binding */ resolve), +/* harmony export */ sep: () => (/* binding */ sep), +/* harmony export */ win32: () => (/* binding */ win32) +/* harmony export */ }); +/* harmony import */ var _process_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./process.js */ "./node_modules/monaco-editor/esm/vs/base/common/process.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +// NOTE: VSCode's copy of nodejs path library to be usable in common (non-node) namespace +// Copied from: https://github.com/nodejs/node/blob/v16.14.2/lib/path.js +/** + * Copyright Joyent, Inc. and other Node contributors. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do so, subject to the + * following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +const CHAR_UPPERCASE_A = 65; /* A */ +const CHAR_LOWERCASE_A = 97; /* a */ +const CHAR_UPPERCASE_Z = 90; /* Z */ +const CHAR_LOWERCASE_Z = 122; /* z */ +const CHAR_DOT = 46; /* . */ +const CHAR_FORWARD_SLASH = 47; /* / */ +const CHAR_BACKWARD_SLASH = 92; /* \ */ +const CHAR_COLON = 58; /* : */ +const CHAR_QUESTION_MARK = 63; /* ? */ +class ErrorInvalidArgType extends Error { + constructor(name, expected, actual) { + // determiner: 'must be' or 'must not be' + let determiner; + if (typeof expected === 'string' && expected.indexOf('not ') === 0) { + determiner = 'must not be'; + expected = expected.replace(/^not /, ''); + } + else { + determiner = 'must be'; + } + const type = name.indexOf('.') !== -1 ? 'property' : 'argument'; + let msg = `The "${name}" ${type} ${determiner} of type ${expected}`; + msg += `. Received type ${typeof actual}`; + super(msg); + this.code = 'ERR_INVALID_ARG_TYPE'; + } +} +function validateObject(pathObject, name) { + if (pathObject === null || typeof pathObject !== 'object') { + throw new ErrorInvalidArgType(name, 'Object', pathObject); + } +} +function validateString(value, name) { + if (typeof value !== 'string') { + throw new ErrorInvalidArgType(name, 'string', value); + } +} +const platformIsWin32 = (_process_js__WEBPACK_IMPORTED_MODULE_0__.platform === 'win32'); +function isPathSeparator(code) { + return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; +} +function isPosixPathSeparator(code) { + return code === CHAR_FORWARD_SLASH; +} +function isWindowsDeviceRoot(code) { + return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) || + (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z); +} +// Resolves . and .. elements in a path with directory names +function normalizeString(path, allowAboveRoot, separator, isPathSeparator) { + let res = ''; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code = 0; + for (let i = 0; i <= path.length; ++i) { + if (i < path.length) { + code = path.charCodeAt(i); + } + else if (isPathSeparator(code)) { + break; + } + else { + code = CHAR_FORWARD_SLASH; + } + if (isPathSeparator(code)) { + if (lastSlash === i - 1 || dots === 1) { + // NOOP + } + else if (dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || + res.charCodeAt(res.length - 1) !== CHAR_DOT || + res.charCodeAt(res.length - 2) !== CHAR_DOT) { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf(separator); + if (lastSlashIndex === -1) { + res = ''; + lastSegmentLength = 0; + } + else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf(separator); + } + lastSlash = i; + dots = 0; + continue; + } + else if (res.length !== 0) { + res = ''; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + res += res.length > 0 ? `${separator}..` : '..'; + lastSegmentLength = 2; + } + } + else { + if (res.length > 0) { + res += `${separator}${path.slice(lastSlash + 1, i)}`; + } + else { + res = path.slice(lastSlash + 1, i); + } + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } + else if (code === CHAR_DOT && dots !== -1) { + ++dots; + } + else { + dots = -1; + } + } + return res; +} +function _format(sep, pathObject) { + validateObject(pathObject, 'pathObject'); + const dir = pathObject.dir || pathObject.root; + const base = pathObject.base || + `${pathObject.name || ''}${pathObject.ext || ''}`; + if (!dir) { + return base; + } + return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`; +} +const win32 = { + // path.resolve([from ...], to) + resolve(...pathSegments) { + let resolvedDevice = ''; + let resolvedTail = ''; + let resolvedAbsolute = false; + for (let i = pathSegments.length - 1; i >= -1; i--) { + let path; + if (i >= 0) { + path = pathSegments[i]; + validateString(path, 'path'); + // Skip empty entries + if (path.length === 0) { + continue; + } + } + else if (resolvedDevice.length === 0) { + path = _process_js__WEBPACK_IMPORTED_MODULE_0__.cwd(); + } + else { + // Windows has the concept of drive-specific current working + // directories. If we've resolved a drive letter but not yet an + // absolute path, get cwd for that drive, or the process cwd if + // the drive cwd is not available. We're sure the device is not + // a UNC path at this points, because UNC paths are always absolute. + path = _process_js__WEBPACK_IMPORTED_MODULE_0__.env[`=${resolvedDevice}`] || _process_js__WEBPACK_IMPORTED_MODULE_0__.cwd(); + // Verify that a cwd was found and that it actually points + // to our drive. If not, default to the drive's root. + if (path === undefined || + (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && + path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) { + path = `${resolvedDevice}\\`; + } + } + const len = path.length; + let rootEnd = 0; + let device = ''; + let isAbsolute = false; + const code = path.charCodeAt(0); + // Try to match a root + if (len === 1) { + if (isPathSeparator(code)) { + // `path` contains just a path separator + rootEnd = 1; + isAbsolute = true; + } + } + else if (isPathSeparator(code)) { + // Possible UNC root + // If we started with a separator, we know we at least have an + // absolute path of some kind (UNC or otherwise) + isAbsolute = true; + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + // Matched! + last = j; + // Match 1 or more path separators + while (j < len && isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j === len || j !== last) { + // We matched a UNC root + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } + else { + rootEnd = 1; + } + } + else if (isWindowsDeviceRoot(code) && + path.charCodeAt(1) === CHAR_COLON) { + // Possible device root + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2 && isPathSeparator(path.charCodeAt(2))) { + // Treat separator following drive name as an absolute path + // indicator + isAbsolute = true; + rootEnd = 3; + } + } + if (device.length > 0) { + if (resolvedDevice.length > 0) { + if (device.toLowerCase() !== resolvedDevice.toLowerCase()) { + // This path points to another device so it is not applicable + continue; + } + } + else { + resolvedDevice = device; + } + } + if (resolvedAbsolute) { + if (resolvedDevice.length > 0) { + break; + } + } + else { + resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; + resolvedAbsolute = isAbsolute; + if (isAbsolute && resolvedDevice.length > 0) { + break; + } + } + } + // At this point the path should be resolved to a full absolute path, + // but handle relative paths to be safe (might happen when process.cwd() + // fails) + // Normalize the tail path + resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isPathSeparator); + return resolvedAbsolute ? + `${resolvedDevice}\\${resolvedTail}` : + `${resolvedDevice}${resolvedTail}` || '.'; + }, + normalize(path) { + validateString(path, 'path'); + const len = path.length; + if (len === 0) { + return '.'; + } + let rootEnd = 0; + let device; + let isAbsolute = false; + const code = path.charCodeAt(0); + // Try to match a root + if (len === 1) { + // `path` contains just a single char, exit early to avoid + // unnecessary work + return isPosixPathSeparator(code) ? '\\' : path; + } + if (isPathSeparator(code)) { + // Possible UNC root + // If we started with a separator, we know we at least have an absolute + // path of some kind (UNC or otherwise) + isAbsolute = true; + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + // Matched! + last = j; + // Match 1 or more path separators + while (j < len && isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j === len) { + // We matched a UNC root only + // Return the normalized version of the UNC root since there + // is nothing left to process + return `\\\\${firstPart}\\${path.slice(last)}\\`; + } + if (j !== last) { + // We matched a UNC root with leftovers + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } + else { + rootEnd = 1; + } + } + else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { + // Possible device root + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2 && isPathSeparator(path.charCodeAt(2))) { + // Treat separator following drive name as an absolute path + // indicator + isAbsolute = true; + rootEnd = 3; + } + } + let tail = rootEnd < len ? + normalizeString(path.slice(rootEnd), !isAbsolute, '\\', isPathSeparator) : + ''; + if (tail.length === 0 && !isAbsolute) { + tail = '.'; + } + if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) { + tail += '\\'; + } + if (device === undefined) { + return isAbsolute ? `\\${tail}` : tail; + } + return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`; + }, + isAbsolute(path) { + validateString(path, 'path'); + const len = path.length; + if (len === 0) { + return false; + } + const code = path.charCodeAt(0); + return isPathSeparator(code) || + // Possible device root + (len > 2 && + isWindowsDeviceRoot(code) && + path.charCodeAt(1) === CHAR_COLON && + isPathSeparator(path.charCodeAt(2))); + }, + join(...paths) { + if (paths.length === 0) { + return '.'; + } + let joined; + let firstPart; + for (let i = 0; i < paths.length; ++i) { + const arg = paths[i]; + validateString(arg, 'path'); + if (arg.length > 0) { + if (joined === undefined) { + joined = firstPart = arg; + } + else { + joined += `\\${arg}`; + } + } + } + if (joined === undefined) { + return '.'; + } + // Make sure that the joined path doesn't start with two slashes, because + // normalize() will mistake it for a UNC path then. + // + // This step is skipped when it is very clear that the user actually + // intended to point at a UNC path. This is assumed when the first + // non-empty string arguments starts with exactly two slashes followed by + // at least one more non-slash character. + // + // Note that for normalize() to treat a path as a UNC path it needs to + // have at least 2 components, so we don't filter for that here. + // This means that the user can use join to construct UNC paths from + // a server name and a share name; for example: + // path.join('//server', 'share') -> '\\\\server\\share\\') + let needsReplace = true; + let slashCount = 0; + if (typeof firstPart === 'string' && isPathSeparator(firstPart.charCodeAt(0))) { + ++slashCount; + const firstLen = firstPart.length; + if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) { + ++slashCount; + if (firstLen > 2) { + if (isPathSeparator(firstPart.charCodeAt(2))) { + ++slashCount; + } + else { + // We matched a UNC path in the first part + needsReplace = false; + } + } + } + } + if (needsReplace) { + // Find any more consecutive slashes we need to replace + while (slashCount < joined.length && + isPathSeparator(joined.charCodeAt(slashCount))) { + slashCount++; + } + // Replace the slashes if needed + if (slashCount >= 2) { + joined = `\\${joined.slice(slashCount)}`; + } + } + return win32.normalize(joined); + }, + // It will solve the relative path from `from` to `to`, for instance: + // from = 'C:\\orandea\\test\\aaa' + // to = 'C:\\orandea\\impl\\bbb' + // The output of the function should be: '..\\..\\impl\\bbb' + relative(from, to) { + validateString(from, 'from'); + validateString(to, 'to'); + if (from === to) { + return ''; + } + const fromOrig = win32.resolve(from); + const toOrig = win32.resolve(to); + if (fromOrig === toOrig) { + return ''; + } + from = fromOrig.toLowerCase(); + to = toOrig.toLowerCase(); + if (from === to) { + return ''; + } + // Trim any leading backslashes + let fromStart = 0; + while (fromStart < from.length && + from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) { + fromStart++; + } + // Trim trailing backslashes (applicable to UNC paths only) + let fromEnd = from.length; + while (fromEnd - 1 > fromStart && + from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) { + fromEnd--; + } + const fromLen = fromEnd - fromStart; + // Trim any leading backslashes + let toStart = 0; + while (toStart < to.length && + to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { + toStart++; + } + // Trim trailing backslashes (applicable to UNC paths only) + let toEnd = to.length; + while (toEnd - 1 > toStart && + to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) { + toEnd--; + } + const toLen = toEnd - toStart; + // Compare paths to find the longest common path from root + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for (; i < length; i++) { + const fromCode = from.charCodeAt(fromStart + i); + if (fromCode !== to.charCodeAt(toStart + i)) { + break; + } + else if (fromCode === CHAR_BACKWARD_SLASH) { + lastCommonSep = i; + } + } + // We found a mismatch before the first common path separator was seen, so + // return the original `to`. + if (i !== length) { + if (lastCommonSep === -1) { + return toOrig; + } + } + else { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz' + return toOrig.slice(toStart + i + 1); + } + if (i === 2) { + // We get here if `from` is the device root. + // For example: from='C:\\'; to='C:\\foo' + return toOrig.slice(toStart + i); + } + } + if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='C:\\foo\\bar'; to='C:\\foo' + lastCommonSep = i; + } + else if (i === 2) { + // We get here if `to` is the device root. + // For example: from='C:\\foo\\bar'; to='C:\\' + lastCommonSep = 3; + } + } + if (lastCommonSep === -1) { + lastCommonSep = 0; + } + } + let out = ''; + // Generate the relative path based on the path difference between `to` and + // `from` + for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { + if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { + out += out.length === 0 ? '..' : '\\..'; + } + } + toStart += lastCommonSep; + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) { + return `${out}${toOrig.slice(toStart, toEnd)}`; + } + if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { + ++toStart; + } + return toOrig.slice(toStart, toEnd); + }, + toNamespacedPath(path) { + // Note: this will *probably* throw somewhere. + if (typeof path !== 'string' || path.length === 0) { + return path; + } + const resolvedPath = win32.resolve(path); + if (resolvedPath.length <= 2) { + return path; + } + if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { + // Possible UNC root + if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { + const code = resolvedPath.charCodeAt(2); + if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { + // Matched non-long UNC root, convert the path to a long UNC path + return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; + } + } + } + else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && + resolvedPath.charCodeAt(1) === CHAR_COLON && + resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) { + // Matched device root, convert the path to a long UNC path + return `\\\\?\\${resolvedPath}`; + } + return path; + }, + dirname(path) { + validateString(path, 'path'); + const len = path.length; + if (len === 0) { + return '.'; + } + let rootEnd = -1; + let offset = 0; + const code = path.charCodeAt(0); + if (len === 1) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work or a dot. + return isPathSeparator(code) ? path : '.'; + } + // Try to match a root + if (isPathSeparator(code)) { + // Possible UNC root + rootEnd = offset = 1; + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more path separators + while (j < len && isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j === len) { + // We matched a UNC root only + return path; + } + if (j !== last) { + // We matched a UNC root with leftovers + // Offset by 1 to include the separator after the UNC root to + // treat it as a "normal root" on top of a (UNC) root + rootEnd = offset = j + 1; + } + } + } + } + // Possible device root + } + else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { + rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2; + offset = rootEnd; + } + let end = -1; + let matchedSlash = true; + for (let i = len - 1; i >= offset; --i) { + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + end = i; + break; + } + } + else { + // We saw the first non-path separator + matchedSlash = false; + } + } + if (end === -1) { + if (rootEnd === -1) { + return '.'; + } + end = rootEnd; + } + return path.slice(0, end); + }, + basename(path, ext) { + if (ext !== undefined) { + validateString(ext, 'ext'); + } + validateString(path, 'path'); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + if (path.length >= 2 && + isWindowsDeviceRoot(path.charCodeAt(0)) && + path.charCodeAt(1) === CHAR_COLON) { + start = 2; + } + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext === path) { + return ''; + } + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for (i = path.length - 1; i >= start; --i) { + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } + else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } + else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) { + end = firstNonSlashEnd; + } + else if (end === -1) { + end = path.length; + } + return path.slice(start, end); + } + for (i = path.length - 1; i >= start; --i) { + if (isPathSeparator(path.charCodeAt(i))) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } + else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) { + return ''; + } + return path.slice(start, end); + }, + extname(path) { + validateString(path, 'path'); + let start = 0; + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + if (path.length >= 2 && + path.charCodeAt(1) === CHAR_COLON && + isWindowsDeviceRoot(path.charCodeAt(0))) { + start = startPart = 2; + } + for (let i = path.length - 1; i >= start; --i) { + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) { + startDot = i; + } + else if (preDotState !== 1) { + preDotState = 1; + } + } + else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && + startDot === end - 1 && + startDot === startPart + 1)) { + return ''; + } + return path.slice(startDot, end); + }, + format: _format.bind(null, '\\'), + parse(path) { + validateString(path, 'path'); + const ret = { root: '', dir: '', base: '', ext: '', name: '' }; + if (path.length === 0) { + return ret; + } + const len = path.length; + let rootEnd = 0; + let code = path.charCodeAt(0); + if (len === 1) { + if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + ret.base = ret.name = path; + return ret; + } + // Try to match a root + if (isPathSeparator(code)) { + // Possible UNC root + rootEnd = 1; + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more path separators + while (j < len && isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + while (j < len && !isPathSeparator(path.charCodeAt(j))) { + j++; + } + if (j === len) { + // We matched a UNC root only + rootEnd = j; + } + else if (j !== last) { + // We matched a UNC root with leftovers + rootEnd = j + 1; + } + } + } + } + } + else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { + // Possible device root + if (len <= 2) { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + rootEnd = 2; + if (isPathSeparator(path.charCodeAt(2))) { + if (len === 3) { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + rootEnd = 3; + } + } + if (rootEnd > 0) { + ret.root = path.slice(0, rootEnd); + } + let startDot = -1; + let startPart = rootEnd; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Get non-dir info + for (; i >= rootEnd; --i) { + code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) { + startDot = i; + } + else if (preDotState !== 1) { + preDotState = 1; + } + } + else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (end !== -1) { + if (startDot === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && + startDot === end - 1 && + startDot === startPart + 1)) { + ret.base = ret.name = path.slice(startPart, end); + } + else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + ret.ext = path.slice(startDot, end); + } + } + // If the directory is the root, use the entire root as the `dir` including + // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the + // trailing slash (`C:\abc\def` -> `C:\abc`). + if (startPart > 0 && startPart !== rootEnd) { + ret.dir = path.slice(0, startPart - 1); + } + else { + ret.dir = ret.root; + } + return ret; + }, + sep: '\\', + delimiter: ';', + win32: null, + posix: null +}; +const posixCwd = (() => { + if (platformIsWin32) { + // Converts Windows' backslash path separators to POSIX forward slashes + // and truncates any drive indicator + const regexp = /\\/g; + return () => { + const cwd = _process_js__WEBPACK_IMPORTED_MODULE_0__.cwd().replace(regexp, '/'); + return cwd.slice(cwd.indexOf('/')); + }; + } + // We're already on POSIX, no need for any transformations + return () => _process_js__WEBPACK_IMPORTED_MODULE_0__.cwd(); +})(); +const posix = { + // path.resolve([from ...], to) + resolve(...pathSegments) { + let resolvedPath = ''; + let resolvedAbsolute = false; + for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + const path = i >= 0 ? pathSegments[i] : posixCwd(); + validateString(path, 'path'); + // Skip empty entries + if (path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + // Normalize the path + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator); + if (resolvedAbsolute) { + return `/${resolvedPath}`; + } + return resolvedPath.length > 0 ? resolvedPath : '.'; + }, + normalize(path) { + validateString(path, 'path'); + if (path.length === 0) { + return '.'; + } + const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH; + // Normalize the path + path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator); + if (path.length === 0) { + if (isAbsolute) { + return '/'; + } + return trailingSeparator ? './' : '.'; + } + if (trailingSeparator) { + path += '/'; + } + return isAbsolute ? `/${path}` : path; + }, + isAbsolute(path) { + validateString(path, 'path'); + return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH; + }, + join(...paths) { + if (paths.length === 0) { + return '.'; + } + let joined; + for (let i = 0; i < paths.length; ++i) { + const arg = paths[i]; + validateString(arg, 'path'); + if (arg.length > 0) { + if (joined === undefined) { + joined = arg; + } + else { + joined += `/${arg}`; + } + } + } + if (joined === undefined) { + return '.'; + } + return posix.normalize(joined); + }, + relative(from, to) { + validateString(from, 'from'); + validateString(to, 'to'); + if (from === to) { + return ''; + } + // Trim leading forward slashes. + from = posix.resolve(from); + to = posix.resolve(to); + if (from === to) { + return ''; + } + const fromStart = 1; + const fromEnd = from.length; + const fromLen = fromEnd - fromStart; + const toStart = 1; + const toLen = to.length - toStart; + // Compare paths to find the longest common path from root + const length = (fromLen < toLen ? fromLen : toLen); + let lastCommonSep = -1; + let i = 0; + for (; i < length; i++) { + const fromCode = from.charCodeAt(fromStart + i); + if (fromCode !== to.charCodeAt(toStart + i)) { + break; + } + else if (fromCode === CHAR_FORWARD_SLASH) { + lastCommonSep = i; + } + } + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='/foo/bar'; to='/foo/bar/baz' + return to.slice(toStart + i + 1); + } + if (i === 0) { + // We get here if `from` is the root + // For example: from='/'; to='/foo' + return to.slice(toStart + i); + } + } + else if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='/foo/bar/baz'; to='/foo/bar' + lastCommonSep = i; + } + else if (i === 0) { + // We get here if `to` is the root. + // For example: from='/foo/bar'; to='/' + lastCommonSep = 0; + } + } + } + let out = ''; + // Generate the relative path based on the path difference between `to` + // and `from`. + for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { + if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { + out += out.length === 0 ? '..' : '/..'; + } + } + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts. + return `${out}${to.slice(toStart + lastCommonSep)}`; + }, + toNamespacedPath(path) { + // Non-op on posix systems + return path; + }, + dirname(path) { + validateString(path, 'path'); + if (path.length === 0) { + return '.'; + } + const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let end = -1; + let matchedSlash = true; + for (let i = path.length - 1; i >= 1; --i) { + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + if (!matchedSlash) { + end = i; + break; + } + } + else { + // We saw the first non-path separator + matchedSlash = false; + } + } + if (end === -1) { + return hasRoot ? '/' : '.'; + } + if (hasRoot && end === 1) { + return '//'; + } + return path.slice(0, end); + }, + basename(path, ext) { + if (ext !== undefined) { + validateString(ext, 'ext'); + } + validateString(path, 'path'); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext === path) { + return ''; + } + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for (i = path.length - 1; i >= 0; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } + else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } + else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) { + end = firstNonSlashEnd; + } + else if (end === -1) { + end = path.length; + } + return path.slice(start, end); + } + for (i = path.length - 1; i >= 0; --i) { + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } + else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) { + return ''; + } + return path.slice(start, end); + }, + extname(path) { + validateString(path, 'path'); + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + for (let i = path.length - 1; i >= 0; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) { + startDot = i; + } + else if (preDotState !== 1) { + preDotState = 1; + } + } + else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && + startDot === end - 1 && + startDot === startPart + 1)) { + return ''; + } + return path.slice(startDot, end); + }, + format: _format.bind(null, '/'), + parse(path) { + validateString(path, 'path'); + const ret = { root: '', dir: '', base: '', ext: '', name: '' }; + if (path.length === 0) { + return ret; + } + const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let start; + if (isAbsolute) { + ret.root = '/'; + start = 1; + } + else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Get non-dir info + for (; i >= start; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) { + startDot = i; + } + else if (preDotState !== 1) { + preDotState = 1; + } + } + else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (end !== -1) { + const start = startPart === 0 && isAbsolute ? 1 : startPart; + if (startDot === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && + startDot === end - 1 && + startDot === startPart + 1)) { + ret.base = ret.name = path.slice(start, end); + } + else { + ret.name = path.slice(start, startDot); + ret.base = path.slice(start, end); + ret.ext = path.slice(startDot, end); + } + } + if (startPart > 0) { + ret.dir = path.slice(0, startPart - 1); + } + else if (isAbsolute) { + ret.dir = '/'; + } + return ret; + }, + sep: '/', + delimiter: ':', + win32: null, + posix: null +}; +posix.win32 = win32.win32 = win32; +posix.posix = win32.posix = posix; +const normalize = (platformIsWin32 ? win32.normalize : posix.normalize); +const resolve = (platformIsWin32 ? win32.resolve : posix.resolve); +const relative = (platformIsWin32 ? win32.relative : posix.relative); +const dirname = (platformIsWin32 ? win32.dirname : posix.dirname); +const basename = (platformIsWin32 ? win32.basename : posix.basename); +const extname = (platformIsWin32 ? win32.extname : posix.extname); +const sep = (platformIsWin32 ? win32.sep : posix.sep); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/platform.js": +/*!*******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/platform.js ***! + \*******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LANGUAGE_DEFAULT: () => (/* binding */ LANGUAGE_DEFAULT), +/* harmony export */ OS: () => (/* binding */ OS), +/* harmony export */ isAndroid: () => (/* binding */ isAndroid), +/* harmony export */ isChrome: () => (/* binding */ isChrome), +/* harmony export */ isEdge: () => (/* binding */ isEdge), +/* harmony export */ isFirefox: () => (/* binding */ isFirefox), +/* harmony export */ isIOS: () => (/* binding */ isIOS), +/* harmony export */ isLinux: () => (/* binding */ isLinux), +/* harmony export */ isLittleEndian: () => (/* binding */ isLittleEndian), +/* harmony export */ isMacintosh: () => (/* binding */ isMacintosh), +/* harmony export */ isMobile: () => (/* binding */ isMobile), +/* harmony export */ isNative: () => (/* binding */ isNative), +/* harmony export */ isSafari: () => (/* binding */ isSafari), +/* harmony export */ isWeb: () => (/* binding */ isWeb), +/* harmony export */ isWebWorker: () => (/* binding */ isWebWorker), +/* harmony export */ isWindows: () => (/* binding */ isWindows), +/* harmony export */ language: () => (/* binding */ language), +/* harmony export */ setTimeout0: () => (/* binding */ setTimeout0), +/* harmony export */ setTimeout0IsFaster: () => (/* binding */ setTimeout0IsFaster), +/* harmony export */ userAgent: () => (/* binding */ userAgent), +/* harmony export */ webWorkerOrigin: () => (/* binding */ webWorkerOrigin) +/* harmony export */ }); +/* harmony import */ var _nls_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../nls.js */ "./node_modules/monaco-editor/esm/vs/nls.js"); +var _a; +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +const LANGUAGE_DEFAULT = 'en'; +let _isWindows = false; +let _isMacintosh = false; +let _isLinux = false; +let _isLinuxSnap = false; +let _isNative = false; +let _isWeb = false; +let _isElectron = false; +let _isIOS = false; +let _isCI = false; +let _isMobile = false; +let _locale = undefined; +let _language = LANGUAGE_DEFAULT; +let _platformLocale = LANGUAGE_DEFAULT; +let _translationsConfigFile = undefined; +let _userAgent = undefined; +const $globalThis = globalThis; +let nodeProcess = undefined; +if (typeof $globalThis.vscode !== 'undefined' && typeof $globalThis.vscode.process !== 'undefined') { + // Native environment (sandboxed) + nodeProcess = $globalThis.vscode.process; +} +else if (typeof process !== 'undefined') { + // Native environment (non-sandboxed) + nodeProcess = process; +} +const isElectronProcess = typeof ((_a = nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.versions) === null || _a === void 0 ? void 0 : _a.electron) === 'string'; +const isElectronRenderer = isElectronProcess && (nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.type) === 'renderer'; +// Web environment +if (typeof navigator === 'object' && !isElectronRenderer) { + _userAgent = navigator.userAgent; + _isWindows = _userAgent.indexOf('Windows') >= 0; + _isMacintosh = _userAgent.indexOf('Macintosh') >= 0; + _isIOS = (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0; + _isLinux = _userAgent.indexOf('Linux') >= 0; + _isMobile = (_userAgent === null || _userAgent === void 0 ? void 0 : _userAgent.indexOf('Mobi')) >= 0; + _isWeb = true; + const configuredLocale = _nls_js__WEBPACK_IMPORTED_MODULE_0__.getConfiguredDefaultLocale( + // This call _must_ be done in the file that calls `nls.getConfiguredDefaultLocale` + // to ensure that the NLS AMD Loader plugin has been loaded and configured. + // This is because the loader plugin decides what the default locale is based on + // how it's able to resolve the strings. + _nls_js__WEBPACK_IMPORTED_MODULE_0__.localize({ key: 'ensureLoaderPluginIsLoaded', comment: ['{Locked}'] }, '_')); + _locale = configuredLocale || LANGUAGE_DEFAULT; + _language = _locale; + _platformLocale = navigator.language; +} +// Native environment +else if (typeof nodeProcess === 'object') { + _isWindows = (nodeProcess.platform === 'win32'); + _isMacintosh = (nodeProcess.platform === 'darwin'); + _isLinux = (nodeProcess.platform === 'linux'); + _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION']; + _isElectron = isElectronProcess; + _isCI = !!nodeProcess.env['CI'] || !!nodeProcess.env['BUILD_ARTIFACTSTAGINGDIRECTORY']; + _locale = LANGUAGE_DEFAULT; + _language = LANGUAGE_DEFAULT; + const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG']; + if (rawNlsConfig) { + try { + const nlsConfig = JSON.parse(rawNlsConfig); + const resolved = nlsConfig.availableLanguages['*']; + _locale = nlsConfig.locale; + _platformLocale = nlsConfig.osLocale; + // VSCode's default language is 'en' + _language = resolved ? resolved : LANGUAGE_DEFAULT; + _translationsConfigFile = nlsConfig._translationsConfigFile; + } + catch (e) { + } + } + _isNative = true; +} +// Unknown environment +else { + console.error('Unable to resolve platform.'); +} +let _platform = 0 /* Platform.Web */; +if (_isMacintosh) { + _platform = 1 /* Platform.Mac */; +} +else if (_isWindows) { + _platform = 3 /* Platform.Windows */; +} +else if (_isLinux) { + _platform = 2 /* Platform.Linux */; +} +const isWindows = _isWindows; +const isMacintosh = _isMacintosh; +const isLinux = _isLinux; +const isNative = _isNative; +const isWeb = _isWeb; +const isWebWorker = (_isWeb && typeof $globalThis.importScripts === 'function'); +const webWorkerOrigin = isWebWorker ? $globalThis.origin : undefined; +const isIOS = _isIOS; +const isMobile = _isMobile; +const userAgent = _userAgent; +/** + * The language used for the user interface. The format of + * the string is all lower case (e.g. zh-tw for Traditional + * Chinese) + */ +const language = _language; +const setTimeout0IsFaster = (typeof $globalThis.postMessage === 'function' && !$globalThis.importScripts); +/** + * See https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#:~:text=than%204%2C%20then-,set%20timeout%20to%204,-. + * + * Works similarly to `setTimeout(0)` but doesn't suffer from the 4ms artificial delay + * that browsers set when the nesting level is > 5. + */ +const setTimeout0 = (() => { + if (setTimeout0IsFaster) { + const pending = []; + $globalThis.addEventListener('message', (e) => { + if (e.data && e.data.vscodeScheduleAsyncWork) { + for (let i = 0, len = pending.length; i < len; i++) { + const candidate = pending[i]; + if (candidate.id === e.data.vscodeScheduleAsyncWork) { + pending.splice(i, 1); + candidate.callback(); + return; + } + } + } + }); + let lastId = 0; + return (callback) => { + const myId = ++lastId; + pending.push({ + id: myId, + callback: callback + }); + $globalThis.postMessage({ vscodeScheduleAsyncWork: myId }, '*'); + }; + } + return (callback) => setTimeout(callback); +})(); +const OS = (_isMacintosh || _isIOS ? 2 /* OperatingSystem.Macintosh */ : (_isWindows ? 1 /* OperatingSystem.Windows */ : 3 /* OperatingSystem.Linux */)); +let _isLittleEndian = true; +let _isLittleEndianComputed = false; +function isLittleEndian() { + if (!_isLittleEndianComputed) { + _isLittleEndianComputed = true; + const test = new Uint8Array(2); + test[0] = 1; + test[1] = 2; + const view = new Uint16Array(test.buffer); + _isLittleEndian = (view[0] === (2 << 8) + 1); + } + return _isLittleEndian; +} +const isChrome = !!(userAgent && userAgent.indexOf('Chrome') >= 0); +const isFirefox = !!(userAgent && userAgent.indexOf('Firefox') >= 0); +const isSafari = !!(!isChrome && (userAgent && userAgent.indexOf('Safari') >= 0)); +const isEdge = !!(userAgent && userAgent.indexOf('Edg/') >= 0); +const isAndroid = !!(userAgent && userAgent.indexOf('Android') >= 0); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/process.js": +/*!******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/process.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ cwd: () => (/* binding */ cwd), +/* harmony export */ env: () => (/* binding */ env), +/* harmony export */ platform: () => (/* binding */ platform) +/* harmony export */ }); +/* harmony import */ var _platform_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./platform.js */ "./node_modules/monaco-editor/esm/vs/base/common/platform.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +let safeProcess; +// Native sandbox environment +const vscodeGlobal = globalThis.vscode; +if (typeof vscodeGlobal !== 'undefined' && typeof vscodeGlobal.process !== 'undefined') { + const sandboxProcess = vscodeGlobal.process; + safeProcess = { + get platform() { return sandboxProcess.platform; }, + get arch() { return sandboxProcess.arch; }, + get env() { return sandboxProcess.env; }, + cwd() { return sandboxProcess.cwd(); } + }; +} +// Native node.js environment +else if (typeof process !== 'undefined') { + safeProcess = { + get platform() { return process.platform; }, + get arch() { return process.arch; }, + get env() { return process.env; }, + cwd() { return process.env['VSCODE_CWD'] || process.cwd(); } + }; +} +// Web environment +else { + safeProcess = { + // Supported + get platform() { return _platform_js__WEBPACK_IMPORTED_MODULE_0__.isWindows ? 'win32' : _platform_js__WEBPACK_IMPORTED_MODULE_0__.isMacintosh ? 'darwin' : 'linux'; }, + get arch() { return undefined; /* arch is undefined in web */ }, + // Unsupported + get env() { return {}; }, + cwd() { return '/'; } + }; +} +/** + * Provides safe access to the `cwd` property in node.js, sandboxed or web + * environments. + * + * Note: in web, this property is hardcoded to be `/`. + * + * @skipMangle + */ +const cwd = safeProcess.cwd; +/** + * Provides safe access to the `env` property in node.js, sandboxed or web + * environments. + * + * Note: in web, this property is hardcoded to be `{}`. + */ +const env = safeProcess.env; +/** + * Provides safe access to the `platform` property in node.js, sandboxed or web + * environments. + */ +const platform = safeProcess.platform; + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/stopwatch.js": +/*!********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/stopwatch.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ StopWatch: () => (/* binding */ StopWatch) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +const hasPerformanceNow = (globalThis.performance && typeof globalThis.performance.now === 'function'); +class StopWatch { + static create(highResolution) { + return new StopWatch(highResolution); + } + constructor(highResolution) { + this._now = hasPerformanceNow && highResolution === false ? Date.now : globalThis.performance.now.bind(globalThis.performance); + this._startTime = this._now(); + this._stopTime = -1; + } + stop() { + this._stopTime = this._now(); + } + elapsed() { + if (this._stopTime !== -1) { + return this._stopTime - this._startTime; + } + return this._now() - this._startTime; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/strings.js": +/*!******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/strings.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ AmbiguousCharacters: () => (/* binding */ AmbiguousCharacters), +/* harmony export */ CodePointIterator: () => (/* binding */ CodePointIterator), +/* harmony export */ GraphemeIterator: () => (/* binding */ GraphemeIterator), +/* harmony export */ InvisibleCharacters: () => (/* binding */ InvisibleCharacters), +/* harmony export */ UNUSUAL_LINE_TERMINATORS: () => (/* binding */ UNUSUAL_LINE_TERMINATORS), +/* harmony export */ UTF8_BOM_CHARACTER: () => (/* binding */ UTF8_BOM_CHARACTER), +/* harmony export */ commonPrefixLength: () => (/* binding */ commonPrefixLength), +/* harmony export */ commonSuffixLength: () => (/* binding */ commonSuffixLength), +/* harmony export */ compare: () => (/* binding */ compare), +/* harmony export */ compareIgnoreCase: () => (/* binding */ compareIgnoreCase), +/* harmony export */ compareSubstring: () => (/* binding */ compareSubstring), +/* harmony export */ compareSubstringIgnoreCase: () => (/* binding */ compareSubstringIgnoreCase), +/* harmony export */ computeCodePoint: () => (/* binding */ computeCodePoint), +/* harmony export */ containsRTL: () => (/* binding */ containsRTL), +/* harmony export */ containsUnusualLineTerminators: () => (/* binding */ containsUnusualLineTerminators), +/* harmony export */ containsUppercaseCharacter: () => (/* binding */ containsUppercaseCharacter), +/* harmony export */ convertSimple2RegExpPattern: () => (/* binding */ convertSimple2RegExpPattern), +/* harmony export */ createRegExp: () => (/* binding */ createRegExp), +/* harmony export */ equalsIgnoreCase: () => (/* binding */ equalsIgnoreCase), +/* harmony export */ escape: () => (/* binding */ escape), +/* harmony export */ escapeRegExpCharacters: () => (/* binding */ escapeRegExpCharacters), +/* harmony export */ firstNonWhitespaceIndex: () => (/* binding */ firstNonWhitespaceIndex), +/* harmony export */ format: () => (/* binding */ format), +/* harmony export */ getCharContainingOffset: () => (/* binding */ getCharContainingOffset), +/* harmony export */ getLeadingWhitespace: () => (/* binding */ getLeadingWhitespace), +/* harmony export */ getLeftDeleteOffset: () => (/* binding */ getLeftDeleteOffset), +/* harmony export */ getNextCodePoint: () => (/* binding */ getNextCodePoint), +/* harmony export */ isAsciiDigit: () => (/* binding */ isAsciiDigit), +/* harmony export */ isBasicASCII: () => (/* binding */ isBasicASCII), +/* harmony export */ isEmojiImprecise: () => (/* binding */ isEmojiImprecise), +/* harmony export */ isFalsyOrWhitespace: () => (/* binding */ isFalsyOrWhitespace), +/* harmony export */ isFullWidthCharacter: () => (/* binding */ isFullWidthCharacter), +/* harmony export */ isHighSurrogate: () => (/* binding */ isHighSurrogate), +/* harmony export */ isLowSurrogate: () => (/* binding */ isLowSurrogate), +/* harmony export */ isLowerAsciiLetter: () => (/* binding */ isLowerAsciiLetter), +/* harmony export */ isUpperAsciiLetter: () => (/* binding */ isUpperAsciiLetter), +/* harmony export */ lastNonWhitespaceIndex: () => (/* binding */ lastNonWhitespaceIndex), +/* harmony export */ ltrim: () => (/* binding */ ltrim), +/* harmony export */ nextCharLength: () => (/* binding */ nextCharLength), +/* harmony export */ noBreakWhitespace: () => (/* binding */ noBreakWhitespace), +/* harmony export */ prevCharLength: () => (/* binding */ prevCharLength), +/* harmony export */ regExpLeadsToEndlessLoop: () => (/* binding */ regExpLeadsToEndlessLoop), +/* harmony export */ rtrim: () => (/* binding */ rtrim), +/* harmony export */ singleLetterHash: () => (/* binding */ singleLetterHash), +/* harmony export */ splitLines: () => (/* binding */ splitLines), +/* harmony export */ startsWithIgnoreCase: () => (/* binding */ startsWithIgnoreCase), +/* harmony export */ startsWithUTF8BOM: () => (/* binding */ startsWithUTF8BOM), +/* harmony export */ stripWildcards: () => (/* binding */ stripWildcards), +/* harmony export */ trim: () => (/* binding */ trim) +/* harmony export */ }); +/* harmony import */ var _cache_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./cache.js */ "./node_modules/monaco-editor/esm/vs/base/common/cache.js"); +/* harmony import */ var _lazy_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./lazy.js */ "./node_modules/monaco-editor/esm/vs/base/common/lazy.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +var _a; + + +function isFalsyOrWhitespace(str) { + if (!str || typeof str !== 'string') { + return true; + } + return str.trim().length === 0; +} +const _formatRegexp = /{(\d+)}/g; +/** + * Helper to produce a string with a variable number of arguments. Insert variable segments + * into the string using the {n} notation where N is the index of the argument following the string. + * @param value string to which formatting is applied + * @param args replacements for {n}-entries + */ +function format(value, ...args) { + if (args.length === 0) { + return value; + } + return value.replace(_formatRegexp, function (match, group) { + const idx = parseInt(group, 10); + return isNaN(idx) || idx < 0 || idx >= args.length ? + match : + args[idx]; + }); +} +/** + * Converts HTML characters inside the string to use entities instead. Makes the string safe from + * being used e.g. in HTMLElement.innerHTML. + */ +function escape(html) { + return html.replace(/[<>&]/g, function (match) { + switch (match) { + case '<': return '<'; + case '>': return '>'; + case '&': return '&'; + default: return match; + } + }); +} +/** + * Escapes regular expression characters in a given string + */ +function escapeRegExpCharacters(value) { + return value.replace(/[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g, '\\$&'); +} +/** + * Removes all occurrences of needle from the beginning and end of haystack. + * @param haystack string to trim + * @param needle the thing to trim (default is a blank) + */ +function trim(haystack, needle = ' ') { + const trimmed = ltrim(haystack, needle); + return rtrim(trimmed, needle); +} +/** + * Removes all occurrences of needle from the beginning of haystack. + * @param haystack string to trim + * @param needle the thing to trim + */ +function ltrim(haystack, needle) { + if (!haystack || !needle) { + return haystack; + } + const needleLen = needle.length; + if (needleLen === 0 || haystack.length === 0) { + return haystack; + } + let offset = 0; + while (haystack.indexOf(needle, offset) === offset) { + offset = offset + needleLen; + } + return haystack.substring(offset); +} +/** + * Removes all occurrences of needle from the end of haystack. + * @param haystack string to trim + * @param needle the thing to trim + */ +function rtrim(haystack, needle) { + if (!haystack || !needle) { + return haystack; + } + const needleLen = needle.length, haystackLen = haystack.length; + if (needleLen === 0 || haystackLen === 0) { + return haystack; + } + let offset = haystackLen, idx = -1; + while (true) { + idx = haystack.lastIndexOf(needle, offset - 1); + if (idx === -1 || idx + needleLen !== offset) { + break; + } + if (idx === 0) { + return ''; + } + offset = idx; + } + return haystack.substring(0, offset); +} +function convertSimple2RegExpPattern(pattern) { + return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*'); +} +function stripWildcards(pattern) { + return pattern.replace(/\*/g, ''); +} +function createRegExp(searchString, isRegex, options = {}) { + if (!searchString) { + throw new Error('Cannot create regex from empty string'); + } + if (!isRegex) { + searchString = escapeRegExpCharacters(searchString); + } + if (options.wholeWord) { + if (!/\B/.test(searchString.charAt(0))) { + searchString = '\\b' + searchString; + } + if (!/\B/.test(searchString.charAt(searchString.length - 1))) { + searchString = searchString + '\\b'; + } + } + let modifiers = ''; + if (options.global) { + modifiers += 'g'; + } + if (!options.matchCase) { + modifiers += 'i'; + } + if (options.multiline) { + modifiers += 'm'; + } + if (options.unicode) { + modifiers += 'u'; + } + return new RegExp(searchString, modifiers); +} +function regExpLeadsToEndlessLoop(regexp) { + // Exit early if it's one of these special cases which are meant to match + // against an empty string + if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\s*$') { + return false; + } + // We check against an empty string. If the regular expression doesn't advance + // (e.g. ends in an endless loop) it will match an empty string. + const match = regexp.exec(''); + return !!(match && regexp.lastIndex === 0); +} +function splitLines(str) { + return str.split(/\r\n|\r|\n/); +} +/** + * Returns first index of the string that is not whitespace. + * If string is empty or contains only whitespaces, returns -1 + */ +function firstNonWhitespaceIndex(str) { + for (let i = 0, len = str.length; i < len; i++) { + const chCode = str.charCodeAt(i); + if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) { + return i; + } + } + return -1; +} +/** + * Returns the leading whitespace of the string. + * If the string contains only whitespaces, returns entire string + */ +function getLeadingWhitespace(str, start = 0, end = str.length) { + for (let i = start; i < end; i++) { + const chCode = str.charCodeAt(i); + if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) { + return str.substring(start, i); + } + } + return str.substring(start, end); +} +/** + * Returns last index of the string that is not whitespace. + * If string is empty or contains only whitespaces, returns -1 + */ +function lastNonWhitespaceIndex(str, startIndex = str.length - 1) { + for (let i = startIndex; i >= 0; i--) { + const chCode = str.charCodeAt(i); + if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) { + return i; + } + } + return -1; +} +function compare(a, b) { + if (a < b) { + return -1; + } + else if (a > b) { + return 1; + } + else { + return 0; + } +} +function compareSubstring(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) { + for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) { + const codeA = a.charCodeAt(aStart); + const codeB = b.charCodeAt(bStart); + if (codeA < codeB) { + return -1; + } + else if (codeA > codeB) { + return 1; + } + } + const aLen = aEnd - aStart; + const bLen = bEnd - bStart; + if (aLen < bLen) { + return -1; + } + else if (aLen > bLen) { + return 1; + } + return 0; +} +function compareIgnoreCase(a, b) { + return compareSubstringIgnoreCase(a, b, 0, a.length, 0, b.length); +} +function compareSubstringIgnoreCase(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) { + for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) { + let codeA = a.charCodeAt(aStart); + let codeB = b.charCodeAt(bStart); + if (codeA === codeB) { + // equal + continue; + } + if (codeA >= 128 || codeB >= 128) { + // not ASCII letters -> fallback to lower-casing strings + return compareSubstring(a.toLowerCase(), b.toLowerCase(), aStart, aEnd, bStart, bEnd); + } + // mapper lower-case ascii letter onto upper-case varinats + // [97-122] (lower ascii) --> [65-90] (upper ascii) + if (isLowerAsciiLetter(codeA)) { + codeA -= 32; + } + if (isLowerAsciiLetter(codeB)) { + codeB -= 32; + } + // compare both code points + const diff = codeA - codeB; + if (diff === 0) { + continue; + } + return diff; + } + const aLen = aEnd - aStart; + const bLen = bEnd - bStart; + if (aLen < bLen) { + return -1; + } + else if (aLen > bLen) { + return 1; + } + return 0; +} +function isAsciiDigit(code) { + return code >= 48 /* CharCode.Digit0 */ && code <= 57 /* CharCode.Digit9 */; +} +function isLowerAsciiLetter(code) { + return code >= 97 /* CharCode.a */ && code <= 122 /* CharCode.z */; +} +function isUpperAsciiLetter(code) { + return code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */; +} +function equalsIgnoreCase(a, b) { + return a.length === b.length && compareSubstringIgnoreCase(a, b) === 0; +} +function startsWithIgnoreCase(str, candidate) { + const candidateLength = candidate.length; + if (candidate.length > str.length) { + return false; + } + return compareSubstringIgnoreCase(str, candidate, 0, candidateLength) === 0; +} +/** + * @returns the length of the common prefix of the two strings. + */ +function commonPrefixLength(a, b) { + const len = Math.min(a.length, b.length); + let i; + for (i = 0; i < len; i++) { + if (a.charCodeAt(i) !== b.charCodeAt(i)) { + return i; + } + } + return len; +} +/** + * @returns the length of the common suffix of the two strings. + */ +function commonSuffixLength(a, b) { + const len = Math.min(a.length, b.length); + let i; + const aLastIndex = a.length - 1; + const bLastIndex = b.length - 1; + for (i = 0; i < len; i++) { + if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) { + return i; + } + } + return len; +} +/** + * See http://en.wikipedia.org/wiki/Surrogate_pair + */ +function isHighSurrogate(charCode) { + return (0xD800 <= charCode && charCode <= 0xDBFF); +} +/** + * See http://en.wikipedia.org/wiki/Surrogate_pair + */ +function isLowSurrogate(charCode) { + return (0xDC00 <= charCode && charCode <= 0xDFFF); +} +/** + * See http://en.wikipedia.org/wiki/Surrogate_pair + */ +function computeCodePoint(highSurrogate, lowSurrogate) { + return ((highSurrogate - 0xD800) << 10) + (lowSurrogate - 0xDC00) + 0x10000; +} +/** + * get the code point that begins at offset `offset` + */ +function getNextCodePoint(str, len, offset) { + const charCode = str.charCodeAt(offset); + if (isHighSurrogate(charCode) && offset + 1 < len) { + const nextCharCode = str.charCodeAt(offset + 1); + if (isLowSurrogate(nextCharCode)) { + return computeCodePoint(charCode, nextCharCode); + } + } + return charCode; +} +/** + * get the code point that ends right before offset `offset` + */ +function getPrevCodePoint(str, offset) { + const charCode = str.charCodeAt(offset - 1); + if (isLowSurrogate(charCode) && offset > 1) { + const prevCharCode = str.charCodeAt(offset - 2); + if (isHighSurrogate(prevCharCode)) { + return computeCodePoint(prevCharCode, charCode); + } + } + return charCode; +} +class CodePointIterator { + get offset() { + return this._offset; + } + constructor(str, offset = 0) { + this._str = str; + this._len = str.length; + this._offset = offset; + } + setOffset(offset) { + this._offset = offset; + } + prevCodePoint() { + const codePoint = getPrevCodePoint(this._str, this._offset); + this._offset -= (codePoint >= 65536 /* Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1); + return codePoint; + } + nextCodePoint() { + const codePoint = getNextCodePoint(this._str, this._len, this._offset); + this._offset += (codePoint >= 65536 /* Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1); + return codePoint; + } + eol() { + return (this._offset >= this._len); + } +} +class GraphemeIterator { + get offset() { + return this._iterator.offset; + } + constructor(str, offset = 0) { + this._iterator = new CodePointIterator(str, offset); + } + nextGraphemeLength() { + const graphemeBreakTree = GraphemeBreakTree.getInstance(); + const iterator = this._iterator; + const initialOffset = iterator.offset; + let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.nextCodePoint()); + while (!iterator.eol()) { + const offset = iterator.offset; + const nextGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.nextCodePoint()); + if (breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) { + // move iterator back + iterator.setOffset(offset); + break; + } + graphemeBreakType = nextGraphemeBreakType; + } + return (iterator.offset - initialOffset); + } + prevGraphemeLength() { + const graphemeBreakTree = GraphemeBreakTree.getInstance(); + const iterator = this._iterator; + const initialOffset = iterator.offset; + let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.prevCodePoint()); + while (iterator.offset > 0) { + const offset = iterator.offset; + const prevGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.prevCodePoint()); + if (breakBetweenGraphemeBreakType(prevGraphemeBreakType, graphemeBreakType)) { + // move iterator back + iterator.setOffset(offset); + break; + } + graphemeBreakType = prevGraphemeBreakType; + } + return (initialOffset - iterator.offset); + } + eol() { + return this._iterator.eol(); + } +} +function nextCharLength(str, initialOffset) { + const iterator = new GraphemeIterator(str, initialOffset); + return iterator.nextGraphemeLength(); +} +function prevCharLength(str, initialOffset) { + const iterator = new GraphemeIterator(str, initialOffset); + return iterator.prevGraphemeLength(); +} +function getCharContainingOffset(str, offset) { + if (offset > 0 && isLowSurrogate(str.charCodeAt(offset))) { + offset--; + } + const endOffset = offset + nextCharLength(str, offset); + const startOffset = endOffset - prevCharLength(str, endOffset); + return [startOffset, endOffset]; +} +let CONTAINS_RTL = undefined; +function makeContainsRtl() { + // Generated using https://github.com/alexdima/unicode-utils/blob/main/rtl-test.js + return /(?:[\u05BE\u05C0\u05C3\u05C6\u05D0-\u05F4\u0608\u060B\u060D\u061B-\u064A\u066D-\u066F\u0671-\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u0710\u0712-\u072F\u074D-\u07A5\u07B1-\u07EA\u07F4\u07F5\u07FA\u07FE-\u0815\u081A\u0824\u0828\u0830-\u0858\u085E-\u088E\u08A0-\u08C9\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFD3D\uFD50-\uFDC7\uFDF0-\uFDFC\uFE70-\uFEFC]|\uD802[\uDC00-\uDD1B\uDD20-\uDE00\uDE10-\uDE35\uDE40-\uDEE4\uDEEB-\uDF35\uDF40-\uDFFF]|\uD803[\uDC00-\uDD23\uDE80-\uDEA9\uDEAD-\uDF45\uDF51-\uDF81\uDF86-\uDFF6]|\uD83A[\uDC00-\uDCCF\uDD00-\uDD43\uDD4B-\uDFFF]|\uD83B[\uDC00-\uDEBB])/; +} +/** + * Returns true if `str` contains any Unicode character that is classified as "R" or "AL". + */ +function containsRTL(str) { + if (!CONTAINS_RTL) { + CONTAINS_RTL = makeContainsRtl(); + } + return CONTAINS_RTL.test(str); +} +const IS_BASIC_ASCII = /^[\t\n\r\x20-\x7E]*$/; +/** + * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \n, \r, \t + */ +function isBasicASCII(str) { + return IS_BASIC_ASCII.test(str); +} +const UNUSUAL_LINE_TERMINATORS = /[\u2028\u2029]/; // LINE SEPARATOR (LS) or PARAGRAPH SEPARATOR (PS) +/** + * Returns true if `str` contains unusual line terminators, like LS or PS + */ +function containsUnusualLineTerminators(str) { + return UNUSUAL_LINE_TERMINATORS.test(str); +} +function isFullWidthCharacter(charCode) { + // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns + // http://jrgraphix.net/research/unicode_blocks.php + // 2E80 - 2EFF CJK Radicals Supplement + // 2F00 - 2FDF Kangxi Radicals + // 2FF0 - 2FFF Ideographic Description Characters + // 3000 - 303F CJK Symbols and Punctuation + // 3040 - 309F Hiragana + // 30A0 - 30FF Katakana + // 3100 - 312F Bopomofo + // 3130 - 318F Hangul Compatibility Jamo + // 3190 - 319F Kanbun + // 31A0 - 31BF Bopomofo Extended + // 31F0 - 31FF Katakana Phonetic Extensions + // 3200 - 32FF Enclosed CJK Letters and Months + // 3300 - 33FF CJK Compatibility + // 3400 - 4DBF CJK Unified Ideographs Extension A + // 4DC0 - 4DFF Yijing Hexagram Symbols + // 4E00 - 9FFF CJK Unified Ideographs + // A000 - A48F Yi Syllables + // A490 - A4CF Yi Radicals + // AC00 - D7AF Hangul Syllables + // [IGNORE] D800 - DB7F High Surrogates + // [IGNORE] DB80 - DBFF High Private Use Surrogates + // [IGNORE] DC00 - DFFF Low Surrogates + // [IGNORE] E000 - F8FF Private Use Area + // F900 - FAFF CJK Compatibility Ideographs + // [IGNORE] FB00 - FB4F Alphabetic Presentation Forms + // [IGNORE] FB50 - FDFF Arabic Presentation Forms-A + // [IGNORE] FE00 - FE0F Variation Selectors + // [IGNORE] FE20 - FE2F Combining Half Marks + // [IGNORE] FE30 - FE4F CJK Compatibility Forms + // [IGNORE] FE50 - FE6F Small Form Variants + // [IGNORE] FE70 - FEFF Arabic Presentation Forms-B + // FF00 - FFEF Halfwidth and Fullwidth Forms + // [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms] + // of which FF01 - FF5E fullwidth ASCII of 21 to 7E + // [IGNORE] and FF65 - FFDC halfwidth of Katakana and Hangul + // [IGNORE] FFF0 - FFFF Specials + return ((charCode >= 0x2E80 && charCode <= 0xD7AF) + || (charCode >= 0xF900 && charCode <= 0xFAFF) + || (charCode >= 0xFF01 && charCode <= 0xFF5E)); +} +/** + * A fast function (therefore imprecise) to check if code points are emojis. + * Generated using https://github.com/alexdima/unicode-utils/blob/main/emoji-test.js + */ +function isEmojiImprecise(x) { + return ((x >= 0x1F1E6 && x <= 0x1F1FF) || (x === 8986) || (x === 8987) || (x === 9200) + || (x === 9203) || (x >= 9728 && x <= 10175) || (x === 11088) || (x === 11093) + || (x >= 127744 && x <= 128591) || (x >= 128640 && x <= 128764) + || (x >= 128992 && x <= 129008) || (x >= 129280 && x <= 129535) + || (x >= 129648 && x <= 129782)); +} +// -- UTF-8 BOM +const UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* CharCode.UTF8_BOM */); +function startsWithUTF8BOM(str) { + return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* CharCode.UTF8_BOM */); +} +function containsUppercaseCharacter(target, ignoreEscapedChars = false) { + if (!target) { + return false; + } + if (ignoreEscapedChars) { + target = target.replace(/\\./g, ''); + } + return target.toLowerCase() !== target; +} +/** + * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc. + */ +function singleLetterHash(n) { + const LETTERS_CNT = (90 /* CharCode.Z */ - 65 /* CharCode.A */ + 1); + n = n % (2 * LETTERS_CNT); + if (n < LETTERS_CNT) { + return String.fromCharCode(97 /* CharCode.a */ + n); + } + return String.fromCharCode(65 /* CharCode.A */ + n - LETTERS_CNT); +} +function breakBetweenGraphemeBreakType(breakTypeA, breakTypeB) { + // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules + // !!! Let's make the common case a bit faster + if (breakTypeA === 0 /* GraphemeBreakType.Other */) { + // see https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakTest-13.0.0d10.html#table + return (breakTypeB !== 5 /* GraphemeBreakType.Extend */ && breakTypeB !== 7 /* GraphemeBreakType.SpacingMark */); + } + // Do not break between a CR and LF. Otherwise, break before and after controls. + // GB3 CR × LF + // GB4 (Control | CR | LF) ÷ + // GB5 ÷ (Control | CR | LF) + if (breakTypeA === 2 /* GraphemeBreakType.CR */) { + if (breakTypeB === 3 /* GraphemeBreakType.LF */) { + return false; // GB3 + } + } + if (breakTypeA === 4 /* GraphemeBreakType.Control */ || breakTypeA === 2 /* GraphemeBreakType.CR */ || breakTypeA === 3 /* GraphemeBreakType.LF */) { + return true; // GB4 + } + if (breakTypeB === 4 /* GraphemeBreakType.Control */ || breakTypeB === 2 /* GraphemeBreakType.CR */ || breakTypeB === 3 /* GraphemeBreakType.LF */) { + return true; // GB5 + } + // Do not break Hangul syllable sequences. + // GB6 L × (L | V | LV | LVT) + // GB7 (LV | V) × (V | T) + // GB8 (LVT | T) × T + if (breakTypeA === 8 /* GraphemeBreakType.L */) { + if (breakTypeB === 8 /* GraphemeBreakType.L */ || breakTypeB === 9 /* GraphemeBreakType.V */ || breakTypeB === 11 /* GraphemeBreakType.LV */ || breakTypeB === 12 /* GraphemeBreakType.LVT */) { + return false; // GB6 + } + } + if (breakTypeA === 11 /* GraphemeBreakType.LV */ || breakTypeA === 9 /* GraphemeBreakType.V */) { + if (breakTypeB === 9 /* GraphemeBreakType.V */ || breakTypeB === 10 /* GraphemeBreakType.T */) { + return false; // GB7 + } + } + if (breakTypeA === 12 /* GraphemeBreakType.LVT */ || breakTypeA === 10 /* GraphemeBreakType.T */) { + if (breakTypeB === 10 /* GraphemeBreakType.T */) { + return false; // GB8 + } + } + // Do not break before extending characters or ZWJ. + // GB9 × (Extend | ZWJ) + if (breakTypeB === 5 /* GraphemeBreakType.Extend */ || breakTypeB === 13 /* GraphemeBreakType.ZWJ */) { + return false; // GB9 + } + // The GB9a and GB9b rules only apply to extended grapheme clusters: + // Do not break before SpacingMarks, or after Prepend characters. + // GB9a × SpacingMark + // GB9b Prepend × + if (breakTypeB === 7 /* GraphemeBreakType.SpacingMark */) { + return false; // GB9a + } + if (breakTypeA === 1 /* GraphemeBreakType.Prepend */) { + return false; // GB9b + } + // Do not break within emoji modifier sequences or emoji zwj sequences. + // GB11 \p{Extended_Pictographic} Extend* ZWJ × \p{Extended_Pictographic} + if (breakTypeA === 13 /* GraphemeBreakType.ZWJ */ && breakTypeB === 14 /* GraphemeBreakType.Extended_Pictographic */) { + // Note: we are not implementing the rule entirely here to avoid introducing states + return false; // GB11 + } + // GB12 sot (RI RI)* RI × RI + // GB13 [^RI] (RI RI)* RI × RI + if (breakTypeA === 6 /* GraphemeBreakType.Regional_Indicator */ && breakTypeB === 6 /* GraphemeBreakType.Regional_Indicator */) { + // Note: we are not implementing the rule entirely here to avoid introducing states + return false; // GB12 & GB13 + } + // GB999 Any ÷ Any + return true; +} +class GraphemeBreakTree { + static getInstance() { + if (!GraphemeBreakTree._INSTANCE) { + GraphemeBreakTree._INSTANCE = new GraphemeBreakTree(); + } + return GraphemeBreakTree._INSTANCE; + } + constructor() { + this._data = getGraphemeBreakRawData(); + } + getGraphemeBreakType(codePoint) { + // !!! Let's make 7bit ASCII a bit faster: 0..31 + if (codePoint < 32) { + if (codePoint === 10 /* CharCode.LineFeed */) { + return 3 /* GraphemeBreakType.LF */; + } + if (codePoint === 13 /* CharCode.CarriageReturn */) { + return 2 /* GraphemeBreakType.CR */; + } + return 4 /* GraphemeBreakType.Control */; + } + // !!! Let's make 7bit ASCII a bit faster: 32..126 + if (codePoint < 127) { + return 0 /* GraphemeBreakType.Other */; + } + const data = this._data; + const nodeCount = data.length / 3; + let nodeIndex = 1; + while (nodeIndex <= nodeCount) { + if (codePoint < data[3 * nodeIndex]) { + // go left + nodeIndex = 2 * nodeIndex; + } + else if (codePoint > data[3 * nodeIndex + 1]) { + // go right + nodeIndex = 2 * nodeIndex + 1; + } + else { + // hit + return data[3 * nodeIndex + 2]; + } + } + return 0 /* GraphemeBreakType.Other */; + } +} +GraphemeBreakTree._INSTANCE = null; +function getGraphemeBreakRawData() { + // generated using https://github.com/alexdima/unicode-utils/blob/main/grapheme-break.js + return JSON.parse('[0,0,0,51229,51255,12,44061,44087,12,127462,127487,6,7083,7085,5,47645,47671,12,54813,54839,12,128678,128678,14,3270,3270,5,9919,9923,14,45853,45879,12,49437,49463,12,53021,53047,12,71216,71218,7,128398,128399,14,129360,129374,14,2519,2519,5,4448,4519,9,9742,9742,14,12336,12336,14,44957,44983,12,46749,46775,12,48541,48567,12,50333,50359,12,52125,52151,12,53917,53943,12,69888,69890,5,73018,73018,5,127990,127990,14,128558,128559,14,128759,128760,14,129653,129655,14,2027,2035,5,2891,2892,7,3761,3761,5,6683,6683,5,8293,8293,4,9825,9826,14,9999,9999,14,43452,43453,5,44509,44535,12,45405,45431,12,46301,46327,12,47197,47223,12,48093,48119,12,48989,49015,12,49885,49911,12,50781,50807,12,51677,51703,12,52573,52599,12,53469,53495,12,54365,54391,12,65279,65279,4,70471,70472,7,72145,72147,7,119173,119179,5,127799,127818,14,128240,128244,14,128512,128512,14,128652,128652,14,128721,128722,14,129292,129292,14,129445,129450,14,129734,129743,14,1476,1477,5,2366,2368,7,2750,2752,7,3076,3076,5,3415,3415,5,4141,4144,5,6109,6109,5,6964,6964,5,7394,7400,5,9197,9198,14,9770,9770,14,9877,9877,14,9968,9969,14,10084,10084,14,43052,43052,5,43713,43713,5,44285,44311,12,44733,44759,12,45181,45207,12,45629,45655,12,46077,46103,12,46525,46551,12,46973,46999,12,47421,47447,12,47869,47895,12,48317,48343,12,48765,48791,12,49213,49239,12,49661,49687,12,50109,50135,12,50557,50583,12,51005,51031,12,51453,51479,12,51901,51927,12,52349,52375,12,52797,52823,12,53245,53271,12,53693,53719,12,54141,54167,12,54589,54615,12,55037,55063,12,69506,69509,5,70191,70193,5,70841,70841,7,71463,71467,5,72330,72342,5,94031,94031,5,123628,123631,5,127763,127765,14,127941,127941,14,128043,128062,14,128302,128317,14,128465,128467,14,128539,128539,14,128640,128640,14,128662,128662,14,128703,128703,14,128745,128745,14,129004,129007,14,129329,129330,14,129402,129402,14,129483,129483,14,129686,129704,14,130048,131069,14,173,173,4,1757,1757,1,2200,2207,5,2434,2435,7,2631,2632,5,2817,2817,5,3008,3008,5,3201,3201,5,3387,3388,5,3542,3542,5,3902,3903,7,4190,4192,5,6002,6003,5,6439,6440,5,6765,6770,7,7019,7027,5,7154,7155,7,8205,8205,13,8505,8505,14,9654,9654,14,9757,9757,14,9792,9792,14,9852,9853,14,9890,9894,14,9937,9937,14,9981,9981,14,10035,10036,14,11035,11036,14,42654,42655,5,43346,43347,7,43587,43587,5,44006,44007,7,44173,44199,12,44397,44423,12,44621,44647,12,44845,44871,12,45069,45095,12,45293,45319,12,45517,45543,12,45741,45767,12,45965,45991,12,46189,46215,12,46413,46439,12,46637,46663,12,46861,46887,12,47085,47111,12,47309,47335,12,47533,47559,12,47757,47783,12,47981,48007,12,48205,48231,12,48429,48455,12,48653,48679,12,48877,48903,12,49101,49127,12,49325,49351,12,49549,49575,12,49773,49799,12,49997,50023,12,50221,50247,12,50445,50471,12,50669,50695,12,50893,50919,12,51117,51143,12,51341,51367,12,51565,51591,12,51789,51815,12,52013,52039,12,52237,52263,12,52461,52487,12,52685,52711,12,52909,52935,12,53133,53159,12,53357,53383,12,53581,53607,12,53805,53831,12,54029,54055,12,54253,54279,12,54477,54503,12,54701,54727,12,54925,54951,12,55149,55175,12,68101,68102,5,69762,69762,7,70067,70069,7,70371,70378,5,70720,70721,7,71087,71087,5,71341,71341,5,71995,71996,5,72249,72249,7,72850,72871,5,73109,73109,5,118576,118598,5,121505,121519,5,127245,127247,14,127568,127569,14,127777,127777,14,127872,127891,14,127956,127967,14,128015,128016,14,128110,128172,14,128259,128259,14,128367,128368,14,128424,128424,14,128488,128488,14,128530,128532,14,128550,128551,14,128566,128566,14,128647,128647,14,128656,128656,14,128667,128673,14,128691,128693,14,128715,128715,14,128728,128732,14,128752,128752,14,128765,128767,14,129096,129103,14,129311,129311,14,129344,129349,14,129394,129394,14,129413,129425,14,129466,129471,14,129511,129535,14,129664,129666,14,129719,129722,14,129760,129767,14,917536,917631,5,13,13,2,1160,1161,5,1564,1564,4,1807,1807,1,2085,2087,5,2307,2307,7,2382,2383,7,2497,2500,5,2563,2563,7,2677,2677,5,2763,2764,7,2879,2879,5,2914,2915,5,3021,3021,5,3142,3144,5,3263,3263,5,3285,3286,5,3398,3400,7,3530,3530,5,3633,3633,5,3864,3865,5,3974,3975,5,4155,4156,7,4229,4230,5,5909,5909,7,6078,6085,7,6277,6278,5,6451,6456,7,6744,6750,5,6846,6846,5,6972,6972,5,7074,7077,5,7146,7148,7,7222,7223,5,7416,7417,5,8234,8238,4,8417,8417,5,9000,9000,14,9203,9203,14,9730,9731,14,9748,9749,14,9762,9763,14,9776,9783,14,9800,9811,14,9831,9831,14,9872,9873,14,9882,9882,14,9900,9903,14,9929,9933,14,9941,9960,14,9974,9974,14,9989,9989,14,10006,10006,14,10062,10062,14,10160,10160,14,11647,11647,5,12953,12953,14,43019,43019,5,43232,43249,5,43443,43443,5,43567,43568,7,43696,43696,5,43765,43765,7,44013,44013,5,44117,44143,12,44229,44255,12,44341,44367,12,44453,44479,12,44565,44591,12,44677,44703,12,44789,44815,12,44901,44927,12,45013,45039,12,45125,45151,12,45237,45263,12,45349,45375,12,45461,45487,12,45573,45599,12,45685,45711,12,45797,45823,12,45909,45935,12,46021,46047,12,46133,46159,12,46245,46271,12,46357,46383,12,46469,46495,12,46581,46607,12,46693,46719,12,46805,46831,12,46917,46943,12,47029,47055,12,47141,47167,12,47253,47279,12,47365,47391,12,47477,47503,12,47589,47615,12,47701,47727,12,47813,47839,12,47925,47951,12,48037,48063,12,48149,48175,12,48261,48287,12,48373,48399,12,48485,48511,12,48597,48623,12,48709,48735,12,48821,48847,12,48933,48959,12,49045,49071,12,49157,49183,12,49269,49295,12,49381,49407,12,49493,49519,12,49605,49631,12,49717,49743,12,49829,49855,12,49941,49967,12,50053,50079,12,50165,50191,12,50277,50303,12,50389,50415,12,50501,50527,12,50613,50639,12,50725,50751,12,50837,50863,12,50949,50975,12,51061,51087,12,51173,51199,12,51285,51311,12,51397,51423,12,51509,51535,12,51621,51647,12,51733,51759,12,51845,51871,12,51957,51983,12,52069,52095,12,52181,52207,12,52293,52319,12,52405,52431,12,52517,52543,12,52629,52655,12,52741,52767,12,52853,52879,12,52965,52991,12,53077,53103,12,53189,53215,12,53301,53327,12,53413,53439,12,53525,53551,12,53637,53663,12,53749,53775,12,53861,53887,12,53973,53999,12,54085,54111,12,54197,54223,12,54309,54335,12,54421,54447,12,54533,54559,12,54645,54671,12,54757,54783,12,54869,54895,12,54981,55007,12,55093,55119,12,55243,55291,10,66045,66045,5,68325,68326,5,69688,69702,5,69817,69818,5,69957,69958,7,70089,70092,5,70198,70199,5,70462,70462,5,70502,70508,5,70750,70750,5,70846,70846,7,71100,71101,5,71230,71230,7,71351,71351,5,71737,71738,5,72000,72000,7,72160,72160,5,72273,72278,5,72752,72758,5,72882,72883,5,73031,73031,5,73461,73462,7,94192,94193,7,119149,119149,7,121403,121452,5,122915,122916,5,126980,126980,14,127358,127359,14,127535,127535,14,127759,127759,14,127771,127771,14,127792,127793,14,127825,127867,14,127897,127899,14,127945,127945,14,127985,127986,14,128000,128007,14,128021,128021,14,128066,128100,14,128184,128235,14,128249,128252,14,128266,128276,14,128335,128335,14,128379,128390,14,128407,128419,14,128444,128444,14,128481,128481,14,128499,128499,14,128526,128526,14,128536,128536,14,128543,128543,14,128556,128556,14,128564,128564,14,128577,128580,14,128643,128645,14,128649,128649,14,128654,128654,14,128660,128660,14,128664,128664,14,128675,128675,14,128686,128689,14,128695,128696,14,128705,128709,14,128717,128719,14,128725,128725,14,128736,128741,14,128747,128748,14,128755,128755,14,128762,128762,14,128981,128991,14,129009,129023,14,129160,129167,14,129296,129304,14,129320,129327,14,129340,129342,14,129356,129356,14,129388,129392,14,129399,129400,14,129404,129407,14,129432,129442,14,129454,129455,14,129473,129474,14,129485,129487,14,129648,129651,14,129659,129660,14,129671,129679,14,129709,129711,14,129728,129730,14,129751,129753,14,129776,129782,14,917505,917505,4,917760,917999,5,10,10,3,127,159,4,768,879,5,1471,1471,5,1536,1541,1,1648,1648,5,1767,1768,5,1840,1866,5,2070,2073,5,2137,2139,5,2274,2274,1,2363,2363,7,2377,2380,7,2402,2403,5,2494,2494,5,2507,2508,7,2558,2558,5,2622,2624,7,2641,2641,5,2691,2691,7,2759,2760,5,2786,2787,5,2876,2876,5,2881,2884,5,2901,2902,5,3006,3006,5,3014,3016,7,3072,3072,5,3134,3136,5,3157,3158,5,3260,3260,5,3266,3266,5,3274,3275,7,3328,3329,5,3391,3392,7,3405,3405,5,3457,3457,5,3536,3537,7,3551,3551,5,3636,3642,5,3764,3772,5,3895,3895,5,3967,3967,7,3993,4028,5,4146,4151,5,4182,4183,7,4226,4226,5,4253,4253,5,4957,4959,5,5940,5940,7,6070,6070,7,6087,6088,7,6158,6158,4,6432,6434,5,6448,6449,7,6679,6680,5,6742,6742,5,6754,6754,5,6783,6783,5,6912,6915,5,6966,6970,5,6978,6978,5,7042,7042,7,7080,7081,5,7143,7143,7,7150,7150,7,7212,7219,5,7380,7392,5,7412,7412,5,8203,8203,4,8232,8232,4,8265,8265,14,8400,8412,5,8421,8432,5,8617,8618,14,9167,9167,14,9200,9200,14,9410,9410,14,9723,9726,14,9733,9733,14,9745,9745,14,9752,9752,14,9760,9760,14,9766,9766,14,9774,9774,14,9786,9786,14,9794,9794,14,9823,9823,14,9828,9828,14,9833,9850,14,9855,9855,14,9875,9875,14,9880,9880,14,9885,9887,14,9896,9897,14,9906,9916,14,9926,9927,14,9935,9935,14,9939,9939,14,9962,9962,14,9972,9972,14,9978,9978,14,9986,9986,14,9997,9997,14,10002,10002,14,10017,10017,14,10055,10055,14,10071,10071,14,10133,10135,14,10548,10549,14,11093,11093,14,12330,12333,5,12441,12442,5,42608,42610,5,43010,43010,5,43045,43046,5,43188,43203,7,43302,43309,5,43392,43394,5,43446,43449,5,43493,43493,5,43571,43572,7,43597,43597,7,43703,43704,5,43756,43757,5,44003,44004,7,44009,44010,7,44033,44059,12,44089,44115,12,44145,44171,12,44201,44227,12,44257,44283,12,44313,44339,12,44369,44395,12,44425,44451,12,44481,44507,12,44537,44563,12,44593,44619,12,44649,44675,12,44705,44731,12,44761,44787,12,44817,44843,12,44873,44899,12,44929,44955,12,44985,45011,12,45041,45067,12,45097,45123,12,45153,45179,12,45209,45235,12,45265,45291,12,45321,45347,12,45377,45403,12,45433,45459,12,45489,45515,12,45545,45571,12,45601,45627,12,45657,45683,12,45713,45739,12,45769,45795,12,45825,45851,12,45881,45907,12,45937,45963,12,45993,46019,12,46049,46075,12,46105,46131,12,46161,46187,12,46217,46243,12,46273,46299,12,46329,46355,12,46385,46411,12,46441,46467,12,46497,46523,12,46553,46579,12,46609,46635,12,46665,46691,12,46721,46747,12,46777,46803,12,46833,46859,12,46889,46915,12,46945,46971,12,47001,47027,12,47057,47083,12,47113,47139,12,47169,47195,12,47225,47251,12,47281,47307,12,47337,47363,12,47393,47419,12,47449,47475,12,47505,47531,12,47561,47587,12,47617,47643,12,47673,47699,12,47729,47755,12,47785,47811,12,47841,47867,12,47897,47923,12,47953,47979,12,48009,48035,12,48065,48091,12,48121,48147,12,48177,48203,12,48233,48259,12,48289,48315,12,48345,48371,12,48401,48427,12,48457,48483,12,48513,48539,12,48569,48595,12,48625,48651,12,48681,48707,12,48737,48763,12,48793,48819,12,48849,48875,12,48905,48931,12,48961,48987,12,49017,49043,12,49073,49099,12,49129,49155,12,49185,49211,12,49241,49267,12,49297,49323,12,49353,49379,12,49409,49435,12,49465,49491,12,49521,49547,12,49577,49603,12,49633,49659,12,49689,49715,12,49745,49771,12,49801,49827,12,49857,49883,12,49913,49939,12,49969,49995,12,50025,50051,12,50081,50107,12,50137,50163,12,50193,50219,12,50249,50275,12,50305,50331,12,50361,50387,12,50417,50443,12,50473,50499,12,50529,50555,12,50585,50611,12,50641,50667,12,50697,50723,12,50753,50779,12,50809,50835,12,50865,50891,12,50921,50947,12,50977,51003,12,51033,51059,12,51089,51115,12,51145,51171,12,51201,51227,12,51257,51283,12,51313,51339,12,51369,51395,12,51425,51451,12,51481,51507,12,51537,51563,12,51593,51619,12,51649,51675,12,51705,51731,12,51761,51787,12,51817,51843,12,51873,51899,12,51929,51955,12,51985,52011,12,52041,52067,12,52097,52123,12,52153,52179,12,52209,52235,12,52265,52291,12,52321,52347,12,52377,52403,12,52433,52459,12,52489,52515,12,52545,52571,12,52601,52627,12,52657,52683,12,52713,52739,12,52769,52795,12,52825,52851,12,52881,52907,12,52937,52963,12,52993,53019,12,53049,53075,12,53105,53131,12,53161,53187,12,53217,53243,12,53273,53299,12,53329,53355,12,53385,53411,12,53441,53467,12,53497,53523,12,53553,53579,12,53609,53635,12,53665,53691,12,53721,53747,12,53777,53803,12,53833,53859,12,53889,53915,12,53945,53971,12,54001,54027,12,54057,54083,12,54113,54139,12,54169,54195,12,54225,54251,12,54281,54307,12,54337,54363,12,54393,54419,12,54449,54475,12,54505,54531,12,54561,54587,12,54617,54643,12,54673,54699,12,54729,54755,12,54785,54811,12,54841,54867,12,54897,54923,12,54953,54979,12,55009,55035,12,55065,55091,12,55121,55147,12,55177,55203,12,65024,65039,5,65520,65528,4,66422,66426,5,68152,68154,5,69291,69292,5,69633,69633,5,69747,69748,5,69811,69814,5,69826,69826,5,69932,69932,7,70016,70017,5,70079,70080,7,70095,70095,5,70196,70196,5,70367,70367,5,70402,70403,7,70464,70464,5,70487,70487,5,70709,70711,7,70725,70725,7,70833,70834,7,70843,70844,7,70849,70849,7,71090,71093,5,71103,71104,5,71227,71228,7,71339,71339,5,71344,71349,5,71458,71461,5,71727,71735,5,71985,71989,7,71998,71998,5,72002,72002,7,72154,72155,5,72193,72202,5,72251,72254,5,72281,72283,5,72344,72345,5,72766,72766,7,72874,72880,5,72885,72886,5,73023,73029,5,73104,73105,5,73111,73111,5,92912,92916,5,94095,94098,5,113824,113827,4,119142,119142,7,119155,119162,4,119362,119364,5,121476,121476,5,122888,122904,5,123184,123190,5,125252,125258,5,127183,127183,14,127340,127343,14,127377,127386,14,127491,127503,14,127548,127551,14,127744,127756,14,127761,127761,14,127769,127769,14,127773,127774,14,127780,127788,14,127796,127797,14,127820,127823,14,127869,127869,14,127894,127895,14,127902,127903,14,127943,127943,14,127947,127950,14,127972,127972,14,127988,127988,14,127992,127994,14,128009,128011,14,128019,128019,14,128023,128041,14,128064,128064,14,128102,128107,14,128174,128181,14,128238,128238,14,128246,128247,14,128254,128254,14,128264,128264,14,128278,128299,14,128329,128330,14,128348,128359,14,128371,128377,14,128392,128393,14,128401,128404,14,128421,128421,14,128433,128434,14,128450,128452,14,128476,128478,14,128483,128483,14,128495,128495,14,128506,128506,14,128519,128520,14,128528,128528,14,128534,128534,14,128538,128538,14,128540,128542,14,128544,128549,14,128552,128555,14,128557,128557,14,128560,128563,14,128565,128565,14,128567,128576,14,128581,128591,14,128641,128642,14,128646,128646,14,128648,128648,14,128650,128651,14,128653,128653,14,128655,128655,14,128657,128659,14,128661,128661,14,128663,128663,14,128665,128666,14,128674,128674,14,128676,128677,14,128679,128685,14,128690,128690,14,128694,128694,14,128697,128702,14,128704,128704,14,128710,128714,14,128716,128716,14,128720,128720,14,128723,128724,14,128726,128727,14,128733,128735,14,128742,128744,14,128746,128746,14,128749,128751,14,128753,128754,14,128756,128758,14,128761,128761,14,128763,128764,14,128884,128895,14,128992,129003,14,129008,129008,14,129036,129039,14,129114,129119,14,129198,129279,14,129293,129295,14,129305,129310,14,129312,129319,14,129328,129328,14,129331,129338,14,129343,129343,14,129351,129355,14,129357,129359,14,129375,129387,14,129393,129393,14,129395,129398,14,129401,129401,14,129403,129403,14,129408,129412,14,129426,129431,14,129443,129444,14,129451,129453,14,129456,129465,14,129472,129472,14,129475,129482,14,129484,129484,14,129488,129510,14,129536,129647,14,129652,129652,14,129656,129658,14,129661,129663,14,129667,129670,14,129680,129685,14,129705,129708,14,129712,129718,14,129723,129727,14,129731,129733,14,129744,129750,14,129754,129759,14,129768,129775,14,129783,129791,14,917504,917504,4,917506,917535,4,917632,917759,4,918000,921599,4,0,9,4,11,12,4,14,31,4,169,169,14,174,174,14,1155,1159,5,1425,1469,5,1473,1474,5,1479,1479,5,1552,1562,5,1611,1631,5,1750,1756,5,1759,1764,5,1770,1773,5,1809,1809,5,1958,1968,5,2045,2045,5,2075,2083,5,2089,2093,5,2192,2193,1,2250,2273,5,2275,2306,5,2362,2362,5,2364,2364,5,2369,2376,5,2381,2381,5,2385,2391,5,2433,2433,5,2492,2492,5,2495,2496,7,2503,2504,7,2509,2509,5,2530,2531,5,2561,2562,5,2620,2620,5,2625,2626,5,2635,2637,5,2672,2673,5,2689,2690,5,2748,2748,5,2753,2757,5,2761,2761,7,2765,2765,5,2810,2815,5,2818,2819,7,2878,2878,5,2880,2880,7,2887,2888,7,2893,2893,5,2903,2903,5,2946,2946,5,3007,3007,7,3009,3010,7,3018,3020,7,3031,3031,5,3073,3075,7,3132,3132,5,3137,3140,7,3146,3149,5,3170,3171,5,3202,3203,7,3262,3262,7,3264,3265,7,3267,3268,7,3271,3272,7,3276,3277,5,3298,3299,5,3330,3331,7,3390,3390,5,3393,3396,5,3402,3404,7,3406,3406,1,3426,3427,5,3458,3459,7,3535,3535,5,3538,3540,5,3544,3550,7,3570,3571,7,3635,3635,7,3655,3662,5,3763,3763,7,3784,3789,5,3893,3893,5,3897,3897,5,3953,3966,5,3968,3972,5,3981,3991,5,4038,4038,5,4145,4145,7,4153,4154,5,4157,4158,5,4184,4185,5,4209,4212,5,4228,4228,7,4237,4237,5,4352,4447,8,4520,4607,10,5906,5908,5,5938,5939,5,5970,5971,5,6068,6069,5,6071,6077,5,6086,6086,5,6089,6099,5,6155,6157,5,6159,6159,5,6313,6313,5,6435,6438,7,6441,6443,7,6450,6450,5,6457,6459,5,6681,6682,7,6741,6741,7,6743,6743,7,6752,6752,5,6757,6764,5,6771,6780,5,6832,6845,5,6847,6862,5,6916,6916,7,6965,6965,5,6971,6971,7,6973,6977,7,6979,6980,7,7040,7041,5,7073,7073,7,7078,7079,7,7082,7082,7,7142,7142,5,7144,7145,5,7149,7149,5,7151,7153,5,7204,7211,7,7220,7221,7,7376,7378,5,7393,7393,7,7405,7405,5,7415,7415,7,7616,7679,5,8204,8204,5,8206,8207,4,8233,8233,4,8252,8252,14,8288,8292,4,8294,8303,4,8413,8416,5,8418,8420,5,8482,8482,14,8596,8601,14,8986,8987,14,9096,9096,14,9193,9196,14,9199,9199,14,9201,9202,14,9208,9210,14,9642,9643,14,9664,9664,14,9728,9729,14,9732,9732,14,9735,9741,14,9743,9744,14,9746,9746,14,9750,9751,14,9753,9756,14,9758,9759,14,9761,9761,14,9764,9765,14,9767,9769,14,9771,9773,14,9775,9775,14,9784,9785,14,9787,9791,14,9793,9793,14,9795,9799,14,9812,9822,14,9824,9824,14,9827,9827,14,9829,9830,14,9832,9832,14,9851,9851,14,9854,9854,14,9856,9861,14,9874,9874,14,9876,9876,14,9878,9879,14,9881,9881,14,9883,9884,14,9888,9889,14,9895,9895,14,9898,9899,14,9904,9905,14,9917,9918,14,9924,9925,14,9928,9928,14,9934,9934,14,9936,9936,14,9938,9938,14,9940,9940,14,9961,9961,14,9963,9967,14,9970,9971,14,9973,9973,14,9975,9977,14,9979,9980,14,9982,9985,14,9987,9988,14,9992,9996,14,9998,9998,14,10000,10001,14,10004,10004,14,10013,10013,14,10024,10024,14,10052,10052,14,10060,10060,14,10067,10069,14,10083,10083,14,10085,10087,14,10145,10145,14,10175,10175,14,11013,11015,14,11088,11088,14,11503,11505,5,11744,11775,5,12334,12335,5,12349,12349,14,12951,12951,14,42607,42607,5,42612,42621,5,42736,42737,5,43014,43014,5,43043,43044,7,43047,43047,7,43136,43137,7,43204,43205,5,43263,43263,5,43335,43345,5,43360,43388,8,43395,43395,7,43444,43445,7,43450,43451,7,43454,43456,7,43561,43566,5,43569,43570,5,43573,43574,5,43596,43596,5,43644,43644,5,43698,43700,5,43710,43711,5,43755,43755,7,43758,43759,7,43766,43766,5,44005,44005,5,44008,44008,5,44012,44012,7,44032,44032,11,44060,44060,11,44088,44088,11,44116,44116,11,44144,44144,11,44172,44172,11,44200,44200,11,44228,44228,11,44256,44256,11,44284,44284,11,44312,44312,11,44340,44340,11,44368,44368,11,44396,44396,11,44424,44424,11,44452,44452,11,44480,44480,11,44508,44508,11,44536,44536,11,44564,44564,11,44592,44592,11,44620,44620,11,44648,44648,11,44676,44676,11,44704,44704,11,44732,44732,11,44760,44760,11,44788,44788,11,44816,44816,11,44844,44844,11,44872,44872,11,44900,44900,11,44928,44928,11,44956,44956,11,44984,44984,11,45012,45012,11,45040,45040,11,45068,45068,11,45096,45096,11,45124,45124,11,45152,45152,11,45180,45180,11,45208,45208,11,45236,45236,11,45264,45264,11,45292,45292,11,45320,45320,11,45348,45348,11,45376,45376,11,45404,45404,11,45432,45432,11,45460,45460,11,45488,45488,11,45516,45516,11,45544,45544,11,45572,45572,11,45600,45600,11,45628,45628,11,45656,45656,11,45684,45684,11,45712,45712,11,45740,45740,11,45768,45768,11,45796,45796,11,45824,45824,11,45852,45852,11,45880,45880,11,45908,45908,11,45936,45936,11,45964,45964,11,45992,45992,11,46020,46020,11,46048,46048,11,46076,46076,11,46104,46104,11,46132,46132,11,46160,46160,11,46188,46188,11,46216,46216,11,46244,46244,11,46272,46272,11,46300,46300,11,46328,46328,11,46356,46356,11,46384,46384,11,46412,46412,11,46440,46440,11,46468,46468,11,46496,46496,11,46524,46524,11,46552,46552,11,46580,46580,11,46608,46608,11,46636,46636,11,46664,46664,11,46692,46692,11,46720,46720,11,46748,46748,11,46776,46776,11,46804,46804,11,46832,46832,11,46860,46860,11,46888,46888,11,46916,46916,11,46944,46944,11,46972,46972,11,47000,47000,11,47028,47028,11,47056,47056,11,47084,47084,11,47112,47112,11,47140,47140,11,47168,47168,11,47196,47196,11,47224,47224,11,47252,47252,11,47280,47280,11,47308,47308,11,47336,47336,11,47364,47364,11,47392,47392,11,47420,47420,11,47448,47448,11,47476,47476,11,47504,47504,11,47532,47532,11,47560,47560,11,47588,47588,11,47616,47616,11,47644,47644,11,47672,47672,11,47700,47700,11,47728,47728,11,47756,47756,11,47784,47784,11,47812,47812,11,47840,47840,11,47868,47868,11,47896,47896,11,47924,47924,11,47952,47952,11,47980,47980,11,48008,48008,11,48036,48036,11,48064,48064,11,48092,48092,11,48120,48120,11,48148,48148,11,48176,48176,11,48204,48204,11,48232,48232,11,48260,48260,11,48288,48288,11,48316,48316,11,48344,48344,11,48372,48372,11,48400,48400,11,48428,48428,11,48456,48456,11,48484,48484,11,48512,48512,11,48540,48540,11,48568,48568,11,48596,48596,11,48624,48624,11,48652,48652,11,48680,48680,11,48708,48708,11,48736,48736,11,48764,48764,11,48792,48792,11,48820,48820,11,48848,48848,11,48876,48876,11,48904,48904,11,48932,48932,11,48960,48960,11,48988,48988,11,49016,49016,11,49044,49044,11,49072,49072,11,49100,49100,11,49128,49128,11,49156,49156,11,49184,49184,11,49212,49212,11,49240,49240,11,49268,49268,11,49296,49296,11,49324,49324,11,49352,49352,11,49380,49380,11,49408,49408,11,49436,49436,11,49464,49464,11,49492,49492,11,49520,49520,11,49548,49548,11,49576,49576,11,49604,49604,11,49632,49632,11,49660,49660,11,49688,49688,11,49716,49716,11,49744,49744,11,49772,49772,11,49800,49800,11,49828,49828,11,49856,49856,11,49884,49884,11,49912,49912,11,49940,49940,11,49968,49968,11,49996,49996,11,50024,50024,11,50052,50052,11,50080,50080,11,50108,50108,11,50136,50136,11,50164,50164,11,50192,50192,11,50220,50220,11,50248,50248,11,50276,50276,11,50304,50304,11,50332,50332,11,50360,50360,11,50388,50388,11,50416,50416,11,50444,50444,11,50472,50472,11,50500,50500,11,50528,50528,11,50556,50556,11,50584,50584,11,50612,50612,11,50640,50640,11,50668,50668,11,50696,50696,11,50724,50724,11,50752,50752,11,50780,50780,11,50808,50808,11,50836,50836,11,50864,50864,11,50892,50892,11,50920,50920,11,50948,50948,11,50976,50976,11,51004,51004,11,51032,51032,11,51060,51060,11,51088,51088,11,51116,51116,11,51144,51144,11,51172,51172,11,51200,51200,11,51228,51228,11,51256,51256,11,51284,51284,11,51312,51312,11,51340,51340,11,51368,51368,11,51396,51396,11,51424,51424,11,51452,51452,11,51480,51480,11,51508,51508,11,51536,51536,11,51564,51564,11,51592,51592,11,51620,51620,11,51648,51648,11,51676,51676,11,51704,51704,11,51732,51732,11,51760,51760,11,51788,51788,11,51816,51816,11,51844,51844,11,51872,51872,11,51900,51900,11,51928,51928,11,51956,51956,11,51984,51984,11,52012,52012,11,52040,52040,11,52068,52068,11,52096,52096,11,52124,52124,11,52152,52152,11,52180,52180,11,52208,52208,11,52236,52236,11,52264,52264,11,52292,52292,11,52320,52320,11,52348,52348,11,52376,52376,11,52404,52404,11,52432,52432,11,52460,52460,11,52488,52488,11,52516,52516,11,52544,52544,11,52572,52572,11,52600,52600,11,52628,52628,11,52656,52656,11,52684,52684,11,52712,52712,11,52740,52740,11,52768,52768,11,52796,52796,11,52824,52824,11,52852,52852,11,52880,52880,11,52908,52908,11,52936,52936,11,52964,52964,11,52992,52992,11,53020,53020,11,53048,53048,11,53076,53076,11,53104,53104,11,53132,53132,11,53160,53160,11,53188,53188,11,53216,53216,11,53244,53244,11,53272,53272,11,53300,53300,11,53328,53328,11,53356,53356,11,53384,53384,11,53412,53412,11,53440,53440,11,53468,53468,11,53496,53496,11,53524,53524,11,53552,53552,11,53580,53580,11,53608,53608,11,53636,53636,11,53664,53664,11,53692,53692,11,53720,53720,11,53748,53748,11,53776,53776,11,53804,53804,11,53832,53832,11,53860,53860,11,53888,53888,11,53916,53916,11,53944,53944,11,53972,53972,11,54000,54000,11,54028,54028,11,54056,54056,11,54084,54084,11,54112,54112,11,54140,54140,11,54168,54168,11,54196,54196,11,54224,54224,11,54252,54252,11,54280,54280,11,54308,54308,11,54336,54336,11,54364,54364,11,54392,54392,11,54420,54420,11,54448,54448,11,54476,54476,11,54504,54504,11,54532,54532,11,54560,54560,11,54588,54588,11,54616,54616,11,54644,54644,11,54672,54672,11,54700,54700,11,54728,54728,11,54756,54756,11,54784,54784,11,54812,54812,11,54840,54840,11,54868,54868,11,54896,54896,11,54924,54924,11,54952,54952,11,54980,54980,11,55008,55008,11,55036,55036,11,55064,55064,11,55092,55092,11,55120,55120,11,55148,55148,11,55176,55176,11,55216,55238,9,64286,64286,5,65056,65071,5,65438,65439,5,65529,65531,4,66272,66272,5,68097,68099,5,68108,68111,5,68159,68159,5,68900,68903,5,69446,69456,5,69632,69632,7,69634,69634,7,69744,69744,5,69759,69761,5,69808,69810,7,69815,69816,7,69821,69821,1,69837,69837,1,69927,69931,5,69933,69940,5,70003,70003,5,70018,70018,7,70070,70078,5,70082,70083,1,70094,70094,7,70188,70190,7,70194,70195,7,70197,70197,7,70206,70206,5,70368,70370,7,70400,70401,5,70459,70460,5,70463,70463,7,70465,70468,7,70475,70477,7,70498,70499,7,70512,70516,5,70712,70719,5,70722,70724,5,70726,70726,5,70832,70832,5,70835,70840,5,70842,70842,5,70845,70845,5,70847,70848,5,70850,70851,5,71088,71089,7,71096,71099,7,71102,71102,7,71132,71133,5,71219,71226,5,71229,71229,5,71231,71232,5,71340,71340,7,71342,71343,7,71350,71350,7,71453,71455,5,71462,71462,7,71724,71726,7,71736,71736,7,71984,71984,5,71991,71992,7,71997,71997,7,71999,71999,1,72001,72001,1,72003,72003,5,72148,72151,5,72156,72159,7,72164,72164,7,72243,72248,5,72250,72250,1,72263,72263,5,72279,72280,7,72324,72329,1,72343,72343,7,72751,72751,7,72760,72765,5,72767,72767,5,72873,72873,7,72881,72881,7,72884,72884,7,73009,73014,5,73020,73021,5,73030,73030,1,73098,73102,7,73107,73108,7,73110,73110,7,73459,73460,5,78896,78904,4,92976,92982,5,94033,94087,7,94180,94180,5,113821,113822,5,118528,118573,5,119141,119141,5,119143,119145,5,119150,119154,5,119163,119170,5,119210,119213,5,121344,121398,5,121461,121461,5,121499,121503,5,122880,122886,5,122907,122913,5,122918,122922,5,123566,123566,5,125136,125142,5,126976,126979,14,126981,127182,14,127184,127231,14,127279,127279,14,127344,127345,14,127374,127374,14,127405,127461,14,127489,127490,14,127514,127514,14,127538,127546,14,127561,127567,14,127570,127743,14,127757,127758,14,127760,127760,14,127762,127762,14,127766,127768,14,127770,127770,14,127772,127772,14,127775,127776,14,127778,127779,14,127789,127791,14,127794,127795,14,127798,127798,14,127819,127819,14,127824,127824,14,127868,127868,14,127870,127871,14,127892,127893,14,127896,127896,14,127900,127901,14,127904,127940,14,127942,127942,14,127944,127944,14,127946,127946,14,127951,127955,14,127968,127971,14,127973,127984,14,127987,127987,14,127989,127989,14,127991,127991,14,127995,127999,5,128008,128008,14,128012,128014,14,128017,128018,14,128020,128020,14,128022,128022,14,128042,128042,14,128063,128063,14,128065,128065,14,128101,128101,14,128108,128109,14,128173,128173,14,128182,128183,14,128236,128237,14,128239,128239,14,128245,128245,14,128248,128248,14,128253,128253,14,128255,128258,14,128260,128263,14,128265,128265,14,128277,128277,14,128300,128301,14,128326,128328,14,128331,128334,14,128336,128347,14,128360,128366,14,128369,128370,14,128378,128378,14,128391,128391,14,128394,128397,14,128400,128400,14,128405,128406,14,128420,128420,14,128422,128423,14,128425,128432,14,128435,128443,14,128445,128449,14,128453,128464,14,128468,128475,14,128479,128480,14,128482,128482,14,128484,128487,14,128489,128494,14,128496,128498,14,128500,128505,14,128507,128511,14,128513,128518,14,128521,128525,14,128527,128527,14,128529,128529,14,128533,128533,14,128535,128535,14,128537,128537,14]'); +} +//#endregion +/** + * Computes the offset after performing a left delete on the given string, + * while considering unicode grapheme/emoji rules. +*/ +function getLeftDeleteOffset(offset, str) { + if (offset === 0) { + return 0; + } + // Try to delete emoji part. + const emojiOffset = getOffsetBeforeLastEmojiComponent(offset, str); + if (emojiOffset !== undefined) { + return emojiOffset; + } + // Otherwise, just skip a single code point. + const iterator = new CodePointIterator(str, offset); + iterator.prevCodePoint(); + return iterator.offset; +} +function getOffsetBeforeLastEmojiComponent(initialOffset, str) { + // See https://www.unicode.org/reports/tr51/tr51-14.html#EBNF_and_Regex for the + // structure of emojis. + const iterator = new CodePointIterator(str, initialOffset); + let codePoint = iterator.prevCodePoint(); + // Skip modifiers + while ((isEmojiModifier(codePoint) || codePoint === 65039 /* CodePoint.emojiVariantSelector */ || codePoint === 8419 /* CodePoint.enclosingKeyCap */)) { + if (iterator.offset === 0) { + // Cannot skip modifier, no preceding emoji base. + return undefined; + } + codePoint = iterator.prevCodePoint(); + } + // Expect base emoji + if (!isEmojiImprecise(codePoint)) { + // Unexpected code point, not a valid emoji. + return undefined; + } + let resultOffset = iterator.offset; + if (resultOffset > 0) { + // Skip optional ZWJ code points that combine multiple emojis. + // In theory, we should check if that ZWJ actually combines multiple emojis + // to prevent deleting ZWJs in situations we didn't account for. + const optionalZwjCodePoint = iterator.prevCodePoint(); + if (optionalZwjCodePoint === 8205 /* CodePoint.zwj */) { + resultOffset = iterator.offset; + } + } + return resultOffset; +} +function isEmojiModifier(codePoint) { + return 0x1F3FB <= codePoint && codePoint <= 0x1F3FF; +} +const noBreakWhitespace = '\xa0'; +class AmbiguousCharacters { + static getInstance(locales) { + return _a.cache.get(Array.from(locales)); + } + static getLocales() { + return _a._locales.value; + } + constructor(confusableDictionary) { + this.confusableDictionary = confusableDictionary; + } + isAmbiguous(codePoint) { + return this.confusableDictionary.has(codePoint); + } + /** + * Returns the non basic ASCII code point that the given code point can be confused, + * or undefined if such code point does note exist. + */ + getPrimaryConfusable(codePoint) { + return this.confusableDictionary.get(codePoint); + } + getConfusableCodePoints() { + return new Set(this.confusableDictionary.keys()); + } +} +_a = AmbiguousCharacters; +AmbiguousCharacters.ambiguousCharacterData = new _lazy_js__WEBPACK_IMPORTED_MODULE_1__.Lazy(() => { + // Generated using https://github.com/hediet/vscode-unicode-data + // Stored as key1, value1, key2, value2, ... + return JSON.parse('{\"_common\":[8232,32,8233,32,5760,32,8192,32,8193,32,8194,32,8195,32,8196,32,8197,32,8198,32,8200,32,8201,32,8202,32,8287,32,8199,32,8239,32,2042,95,65101,95,65102,95,65103,95,8208,45,8209,45,8210,45,65112,45,1748,45,8259,45,727,45,8722,45,10134,45,11450,45,1549,44,1643,44,8218,44,184,44,42233,44,894,59,2307,58,2691,58,1417,58,1795,58,1796,58,5868,58,65072,58,6147,58,6153,58,8282,58,1475,58,760,58,42889,58,8758,58,720,58,42237,58,451,33,11601,33,660,63,577,63,2429,63,5038,63,42731,63,119149,46,8228,46,1793,46,1794,46,42510,46,68176,46,1632,46,1776,46,42232,46,1373,96,65287,96,8219,96,8242,96,1370,96,1523,96,8175,96,65344,96,900,96,8189,96,8125,96,8127,96,8190,96,697,96,884,96,712,96,714,96,715,96,756,96,699,96,701,96,700,96,702,96,42892,96,1497,96,2036,96,2037,96,5194,96,5836,96,94033,96,94034,96,65339,91,10088,40,10098,40,12308,40,64830,40,65341,93,10089,41,10099,41,12309,41,64831,41,10100,123,119060,123,10101,125,65342,94,8270,42,1645,42,8727,42,66335,42,5941,47,8257,47,8725,47,8260,47,9585,47,10187,47,10744,47,119354,47,12755,47,12339,47,11462,47,20031,47,12035,47,65340,92,65128,92,8726,92,10189,92,10741,92,10745,92,119311,92,119355,92,12756,92,20022,92,12034,92,42872,38,708,94,710,94,5869,43,10133,43,66203,43,8249,60,10094,60,706,60,119350,60,5176,60,5810,60,5120,61,11840,61,12448,61,42239,61,8250,62,10095,62,707,62,119351,62,5171,62,94015,62,8275,126,732,126,8128,126,8764,126,65372,124,65293,45,120784,50,120794,50,120804,50,120814,50,120824,50,130034,50,42842,50,423,50,1000,50,42564,50,5311,50,42735,50,119302,51,120785,51,120795,51,120805,51,120815,51,120825,51,130035,51,42923,51,540,51,439,51,42858,51,11468,51,1248,51,94011,51,71882,51,120786,52,120796,52,120806,52,120816,52,120826,52,130036,52,5070,52,71855,52,120787,53,120797,53,120807,53,120817,53,120827,53,130037,53,444,53,71867,53,120788,54,120798,54,120808,54,120818,54,120828,54,130038,54,11474,54,5102,54,71893,54,119314,55,120789,55,120799,55,120809,55,120819,55,120829,55,130039,55,66770,55,71878,55,2819,56,2538,56,2666,56,125131,56,120790,56,120800,56,120810,56,120820,56,120830,56,130040,56,547,56,546,56,66330,56,2663,57,2920,57,2541,57,3437,57,120791,57,120801,57,120811,57,120821,57,120831,57,130041,57,42862,57,11466,57,71884,57,71852,57,71894,57,9082,97,65345,97,119834,97,119886,97,119938,97,119990,97,120042,97,120094,97,120146,97,120198,97,120250,97,120302,97,120354,97,120406,97,120458,97,593,97,945,97,120514,97,120572,97,120630,97,120688,97,120746,97,65313,65,119808,65,119860,65,119912,65,119964,65,120016,65,120068,65,120120,65,120172,65,120224,65,120276,65,120328,65,120380,65,120432,65,913,65,120488,65,120546,65,120604,65,120662,65,120720,65,5034,65,5573,65,42222,65,94016,65,66208,65,119835,98,119887,98,119939,98,119991,98,120043,98,120095,98,120147,98,120199,98,120251,98,120303,98,120355,98,120407,98,120459,98,388,98,5071,98,5234,98,5551,98,65314,66,8492,66,119809,66,119861,66,119913,66,120017,66,120069,66,120121,66,120173,66,120225,66,120277,66,120329,66,120381,66,120433,66,42932,66,914,66,120489,66,120547,66,120605,66,120663,66,120721,66,5108,66,5623,66,42192,66,66178,66,66209,66,66305,66,65347,99,8573,99,119836,99,119888,99,119940,99,119992,99,120044,99,120096,99,120148,99,120200,99,120252,99,120304,99,120356,99,120408,99,120460,99,7428,99,1010,99,11429,99,43951,99,66621,99,128844,67,71922,67,71913,67,65315,67,8557,67,8450,67,8493,67,119810,67,119862,67,119914,67,119966,67,120018,67,120174,67,120226,67,120278,67,120330,67,120382,67,120434,67,1017,67,11428,67,5087,67,42202,67,66210,67,66306,67,66581,67,66844,67,8574,100,8518,100,119837,100,119889,100,119941,100,119993,100,120045,100,120097,100,120149,100,120201,100,120253,100,120305,100,120357,100,120409,100,120461,100,1281,100,5095,100,5231,100,42194,100,8558,68,8517,68,119811,68,119863,68,119915,68,119967,68,120019,68,120071,68,120123,68,120175,68,120227,68,120279,68,120331,68,120383,68,120435,68,5024,68,5598,68,5610,68,42195,68,8494,101,65349,101,8495,101,8519,101,119838,101,119890,101,119942,101,120046,101,120098,101,120150,101,120202,101,120254,101,120306,101,120358,101,120410,101,120462,101,43826,101,1213,101,8959,69,65317,69,8496,69,119812,69,119864,69,119916,69,120020,69,120072,69,120124,69,120176,69,120228,69,120280,69,120332,69,120384,69,120436,69,917,69,120492,69,120550,69,120608,69,120666,69,120724,69,11577,69,5036,69,42224,69,71846,69,71854,69,66182,69,119839,102,119891,102,119943,102,119995,102,120047,102,120099,102,120151,102,120203,102,120255,102,120307,102,120359,102,120411,102,120463,102,43829,102,42905,102,383,102,7837,102,1412,102,119315,70,8497,70,119813,70,119865,70,119917,70,120021,70,120073,70,120125,70,120177,70,120229,70,120281,70,120333,70,120385,70,120437,70,42904,70,988,70,120778,70,5556,70,42205,70,71874,70,71842,70,66183,70,66213,70,66853,70,65351,103,8458,103,119840,103,119892,103,119944,103,120048,103,120100,103,120152,103,120204,103,120256,103,120308,103,120360,103,120412,103,120464,103,609,103,7555,103,397,103,1409,103,119814,71,119866,71,119918,71,119970,71,120022,71,120074,71,120126,71,120178,71,120230,71,120282,71,120334,71,120386,71,120438,71,1292,71,5056,71,5107,71,42198,71,65352,104,8462,104,119841,104,119945,104,119997,104,120049,104,120101,104,120153,104,120205,104,120257,104,120309,104,120361,104,120413,104,120465,104,1211,104,1392,104,5058,104,65320,72,8459,72,8460,72,8461,72,119815,72,119867,72,119919,72,120023,72,120179,72,120231,72,120283,72,120335,72,120387,72,120439,72,919,72,120494,72,120552,72,120610,72,120668,72,120726,72,11406,72,5051,72,5500,72,42215,72,66255,72,731,105,9075,105,65353,105,8560,105,8505,105,8520,105,119842,105,119894,105,119946,105,119998,105,120050,105,120102,105,120154,105,120206,105,120258,105,120310,105,120362,105,120414,105,120466,105,120484,105,618,105,617,105,953,105,8126,105,890,105,120522,105,120580,105,120638,105,120696,105,120754,105,1110,105,42567,105,1231,105,43893,105,5029,105,71875,105,65354,106,8521,106,119843,106,119895,106,119947,106,119999,106,120051,106,120103,106,120155,106,120207,106,120259,106,120311,106,120363,106,120415,106,120467,106,1011,106,1112,106,65322,74,119817,74,119869,74,119921,74,119973,74,120025,74,120077,74,120129,74,120181,74,120233,74,120285,74,120337,74,120389,74,120441,74,42930,74,895,74,1032,74,5035,74,5261,74,42201,74,119844,107,119896,107,119948,107,120000,107,120052,107,120104,107,120156,107,120208,107,120260,107,120312,107,120364,107,120416,107,120468,107,8490,75,65323,75,119818,75,119870,75,119922,75,119974,75,120026,75,120078,75,120130,75,120182,75,120234,75,120286,75,120338,75,120390,75,120442,75,922,75,120497,75,120555,75,120613,75,120671,75,120729,75,11412,75,5094,75,5845,75,42199,75,66840,75,1472,108,8739,73,9213,73,65512,73,1633,108,1777,73,66336,108,125127,108,120783,73,120793,73,120803,73,120813,73,120823,73,130033,73,65321,73,8544,73,8464,73,8465,73,119816,73,119868,73,119920,73,120024,73,120128,73,120180,73,120232,73,120284,73,120336,73,120388,73,120440,73,65356,108,8572,73,8467,108,119845,108,119897,108,119949,108,120001,108,120053,108,120105,73,120157,73,120209,73,120261,73,120313,73,120365,73,120417,73,120469,73,448,73,120496,73,120554,73,120612,73,120670,73,120728,73,11410,73,1030,73,1216,73,1493,108,1503,108,1575,108,126464,108,126592,108,65166,108,65165,108,1994,108,11599,73,5825,73,42226,73,93992,73,66186,124,66313,124,119338,76,8556,76,8466,76,119819,76,119871,76,119923,76,120027,76,120079,76,120131,76,120183,76,120235,76,120287,76,120339,76,120391,76,120443,76,11472,76,5086,76,5290,76,42209,76,93974,76,71843,76,71858,76,66587,76,66854,76,65325,77,8559,77,8499,77,119820,77,119872,77,119924,77,120028,77,120080,77,120132,77,120184,77,120236,77,120288,77,120340,77,120392,77,120444,77,924,77,120499,77,120557,77,120615,77,120673,77,120731,77,1018,77,11416,77,5047,77,5616,77,5846,77,42207,77,66224,77,66321,77,119847,110,119899,110,119951,110,120003,110,120055,110,120107,110,120159,110,120211,110,120263,110,120315,110,120367,110,120419,110,120471,110,1400,110,1404,110,65326,78,8469,78,119821,78,119873,78,119925,78,119977,78,120029,78,120081,78,120185,78,120237,78,120289,78,120341,78,120393,78,120445,78,925,78,120500,78,120558,78,120616,78,120674,78,120732,78,11418,78,42208,78,66835,78,3074,111,3202,111,3330,111,3458,111,2406,111,2662,111,2790,111,3046,111,3174,111,3302,111,3430,111,3664,111,3792,111,4160,111,1637,111,1781,111,65359,111,8500,111,119848,111,119900,111,119952,111,120056,111,120108,111,120160,111,120212,111,120264,111,120316,111,120368,111,120420,111,120472,111,7439,111,7441,111,43837,111,959,111,120528,111,120586,111,120644,111,120702,111,120760,111,963,111,120532,111,120590,111,120648,111,120706,111,120764,111,11423,111,4351,111,1413,111,1505,111,1607,111,126500,111,126564,111,126596,111,65259,111,65260,111,65258,111,65257,111,1726,111,64428,111,64429,111,64427,111,64426,111,1729,111,64424,111,64425,111,64423,111,64422,111,1749,111,3360,111,4125,111,66794,111,71880,111,71895,111,66604,111,1984,79,2534,79,2918,79,12295,79,70864,79,71904,79,120782,79,120792,79,120802,79,120812,79,120822,79,130032,79,65327,79,119822,79,119874,79,119926,79,119978,79,120030,79,120082,79,120134,79,120186,79,120238,79,120290,79,120342,79,120394,79,120446,79,927,79,120502,79,120560,79,120618,79,120676,79,120734,79,11422,79,1365,79,11604,79,4816,79,2848,79,66754,79,42227,79,71861,79,66194,79,66219,79,66564,79,66838,79,9076,112,65360,112,119849,112,119901,112,119953,112,120005,112,120057,112,120109,112,120161,112,120213,112,120265,112,120317,112,120369,112,120421,112,120473,112,961,112,120530,112,120544,112,120588,112,120602,112,120646,112,120660,112,120704,112,120718,112,120762,112,120776,112,11427,112,65328,80,8473,80,119823,80,119875,80,119927,80,119979,80,120031,80,120083,80,120187,80,120239,80,120291,80,120343,80,120395,80,120447,80,929,80,120504,80,120562,80,120620,80,120678,80,120736,80,11426,80,5090,80,5229,80,42193,80,66197,80,119850,113,119902,113,119954,113,120006,113,120058,113,120110,113,120162,113,120214,113,120266,113,120318,113,120370,113,120422,113,120474,113,1307,113,1379,113,1382,113,8474,81,119824,81,119876,81,119928,81,119980,81,120032,81,120084,81,120188,81,120240,81,120292,81,120344,81,120396,81,120448,81,11605,81,119851,114,119903,114,119955,114,120007,114,120059,114,120111,114,120163,114,120215,114,120267,114,120319,114,120371,114,120423,114,120475,114,43847,114,43848,114,7462,114,11397,114,43905,114,119318,82,8475,82,8476,82,8477,82,119825,82,119877,82,119929,82,120033,82,120189,82,120241,82,120293,82,120345,82,120397,82,120449,82,422,82,5025,82,5074,82,66740,82,5511,82,42211,82,94005,82,65363,115,119852,115,119904,115,119956,115,120008,115,120060,115,120112,115,120164,115,120216,115,120268,115,120320,115,120372,115,120424,115,120476,115,42801,115,445,115,1109,115,43946,115,71873,115,66632,115,65331,83,119826,83,119878,83,119930,83,119982,83,120034,83,120086,83,120138,83,120190,83,120242,83,120294,83,120346,83,120398,83,120450,83,1029,83,1359,83,5077,83,5082,83,42210,83,94010,83,66198,83,66592,83,119853,116,119905,116,119957,116,120009,116,120061,116,120113,116,120165,116,120217,116,120269,116,120321,116,120373,116,120425,116,120477,116,8868,84,10201,84,128872,84,65332,84,119827,84,119879,84,119931,84,119983,84,120035,84,120087,84,120139,84,120191,84,120243,84,120295,84,120347,84,120399,84,120451,84,932,84,120507,84,120565,84,120623,84,120681,84,120739,84,11430,84,5026,84,42196,84,93962,84,71868,84,66199,84,66225,84,66325,84,119854,117,119906,117,119958,117,120010,117,120062,117,120114,117,120166,117,120218,117,120270,117,120322,117,120374,117,120426,117,120478,117,42911,117,7452,117,43854,117,43858,117,651,117,965,117,120534,117,120592,117,120650,117,120708,117,120766,117,1405,117,66806,117,71896,117,8746,85,8899,85,119828,85,119880,85,119932,85,119984,85,120036,85,120088,85,120140,85,120192,85,120244,85,120296,85,120348,85,120400,85,120452,85,1357,85,4608,85,66766,85,5196,85,42228,85,94018,85,71864,85,8744,118,8897,118,65366,118,8564,118,119855,118,119907,118,119959,118,120011,118,120063,118,120115,118,120167,118,120219,118,120271,118,120323,118,120375,118,120427,118,120479,118,7456,118,957,118,120526,118,120584,118,120642,118,120700,118,120758,118,1141,118,1496,118,71430,118,43945,118,71872,118,119309,86,1639,86,1783,86,8548,86,119829,86,119881,86,119933,86,119985,86,120037,86,120089,86,120141,86,120193,86,120245,86,120297,86,120349,86,120401,86,120453,86,1140,86,11576,86,5081,86,5167,86,42719,86,42214,86,93960,86,71840,86,66845,86,623,119,119856,119,119908,119,119960,119,120012,119,120064,119,120116,119,120168,119,120220,119,120272,119,120324,119,120376,119,120428,119,120480,119,7457,119,1121,119,1309,119,1377,119,71434,119,71438,119,71439,119,43907,119,71919,87,71910,87,119830,87,119882,87,119934,87,119986,87,120038,87,120090,87,120142,87,120194,87,120246,87,120298,87,120350,87,120402,87,120454,87,1308,87,5043,87,5076,87,42218,87,5742,120,10539,120,10540,120,10799,120,65368,120,8569,120,119857,120,119909,120,119961,120,120013,120,120065,120,120117,120,120169,120,120221,120,120273,120,120325,120,120377,120,120429,120,120481,120,5441,120,5501,120,5741,88,9587,88,66338,88,71916,88,65336,88,8553,88,119831,88,119883,88,119935,88,119987,88,120039,88,120091,88,120143,88,120195,88,120247,88,120299,88,120351,88,120403,88,120455,88,42931,88,935,88,120510,88,120568,88,120626,88,120684,88,120742,88,11436,88,11613,88,5815,88,42219,88,66192,88,66228,88,66327,88,66855,88,611,121,7564,121,65369,121,119858,121,119910,121,119962,121,120014,121,120066,121,120118,121,120170,121,120222,121,120274,121,120326,121,120378,121,120430,121,120482,121,655,121,7935,121,43866,121,947,121,8509,121,120516,121,120574,121,120632,121,120690,121,120748,121,1199,121,4327,121,71900,121,65337,89,119832,89,119884,89,119936,89,119988,89,120040,89,120092,89,120144,89,120196,89,120248,89,120300,89,120352,89,120404,89,120456,89,933,89,978,89,120508,89,120566,89,120624,89,120682,89,120740,89,11432,89,1198,89,5033,89,5053,89,42220,89,94019,89,71844,89,66226,89,119859,122,119911,122,119963,122,120015,122,120067,122,120119,122,120171,122,120223,122,120275,122,120327,122,120379,122,120431,122,120483,122,7458,122,43923,122,71876,122,66293,90,71909,90,65338,90,8484,90,8488,90,119833,90,119885,90,119937,90,119989,90,120041,90,120197,90,120249,90,120301,90,120353,90,120405,90,120457,90,918,90,120493,90,120551,90,120609,90,120667,90,120725,90,5059,90,42204,90,71849,90,65282,34,65284,36,65285,37,65286,38,65290,42,65291,43,65294,46,65295,47,65296,48,65297,49,65298,50,65299,51,65300,52,65301,53,65302,54,65303,55,65304,56,65305,57,65308,60,65309,61,65310,62,65312,64,65316,68,65318,70,65319,71,65324,76,65329,81,65330,82,65333,85,65334,86,65335,87,65343,95,65346,98,65348,100,65350,102,65355,107,65357,109,65358,110,65361,113,65362,114,65364,116,65365,117,65367,119,65370,122,65371,123,65373,125,119846,109],\"_default\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"cs\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"de\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"es\":[8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"fr\":[65374,126,65306,58,65281,33,8216,96,8245,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"it\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"ja\":[8211,45,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65292,44,65307,59],\"ko\":[8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"pl\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"pt-BR\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"qps-ploc\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"ru\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,305,105,921,73,1009,112,215,120,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"tr\":[160,32,8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"zh-hans\":[65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41],\"zh-hant\":[8211,45,65374,126,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65307,59]}'); +}); +AmbiguousCharacters.cache = new _cache_js__WEBPACK_IMPORTED_MODULE_0__.LRUCachedFunction((locales) => { + function arrayToMap(arr) { + const result = new Map(); + for (let i = 0; i < arr.length; i += 2) { + result.set(arr[i], arr[i + 1]); + } + return result; + } + function mergeMaps(map1, map2) { + const result = new Map(map1); + for (const [key, value] of map2) { + result.set(key, value); + } + return result; + } + function intersectMaps(map1, map2) { + if (!map1) { + return map2; + } + const result = new Map(); + for (const [key, value] of map1) { + if (map2.has(key)) { + result.set(key, value); + } + } + return result; + } + const data = _a.ambiguousCharacterData.value; + let filteredLocales = locales.filter((l) => !l.startsWith('_') && l in data); + if (filteredLocales.length === 0) { + filteredLocales = ['_default']; + } + let languageSpecificMap = undefined; + for (const locale of filteredLocales) { + const map = arrayToMap(data[locale]); + languageSpecificMap = intersectMaps(languageSpecificMap, map); + } + const commonMap = arrayToMap(data['_common']); + const map = mergeMaps(commonMap, languageSpecificMap); + return new _a(map); +}); +AmbiguousCharacters._locales = new _lazy_js__WEBPACK_IMPORTED_MODULE_1__.Lazy(() => Object.keys(_a.ambiguousCharacterData.value).filter((k) => !k.startsWith('_'))); +class InvisibleCharacters { + static getRawData() { + // Generated using https://github.com/hediet/vscode-unicode-data + return JSON.parse('[9,10,11,12,13,32,127,160,173,847,1564,4447,4448,6068,6069,6155,6156,6157,6158,7355,7356,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8203,8204,8205,8206,8207,8234,8235,8236,8237,8238,8239,8287,8288,8289,8290,8291,8292,8293,8294,8295,8296,8297,8298,8299,8300,8301,8302,8303,10240,12288,12644,65024,65025,65026,65027,65028,65029,65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65279,65440,65520,65521,65522,65523,65524,65525,65526,65527,65528,65532,78844,119155,119156,119157,119158,119159,119160,119161,119162,917504,917505,917506,917507,917508,917509,917510,917511,917512,917513,917514,917515,917516,917517,917518,917519,917520,917521,917522,917523,917524,917525,917526,917527,917528,917529,917530,917531,917532,917533,917534,917535,917536,917537,917538,917539,917540,917541,917542,917543,917544,917545,917546,917547,917548,917549,917550,917551,917552,917553,917554,917555,917556,917557,917558,917559,917560,917561,917562,917563,917564,917565,917566,917567,917568,917569,917570,917571,917572,917573,917574,917575,917576,917577,917578,917579,917580,917581,917582,917583,917584,917585,917586,917587,917588,917589,917590,917591,917592,917593,917594,917595,917596,917597,917598,917599,917600,917601,917602,917603,917604,917605,917606,917607,917608,917609,917610,917611,917612,917613,917614,917615,917616,917617,917618,917619,917620,917621,917622,917623,917624,917625,917626,917627,917628,917629,917630,917631,917760,917761,917762,917763,917764,917765,917766,917767,917768,917769,917770,917771,917772,917773,917774,917775,917776,917777,917778,917779,917780,917781,917782,917783,917784,917785,917786,917787,917788,917789,917790,917791,917792,917793,917794,917795,917796,917797,917798,917799,917800,917801,917802,917803,917804,917805,917806,917807,917808,917809,917810,917811,917812,917813,917814,917815,917816,917817,917818,917819,917820,917821,917822,917823,917824,917825,917826,917827,917828,917829,917830,917831,917832,917833,917834,917835,917836,917837,917838,917839,917840,917841,917842,917843,917844,917845,917846,917847,917848,917849,917850,917851,917852,917853,917854,917855,917856,917857,917858,917859,917860,917861,917862,917863,917864,917865,917866,917867,917868,917869,917870,917871,917872,917873,917874,917875,917876,917877,917878,917879,917880,917881,917882,917883,917884,917885,917886,917887,917888,917889,917890,917891,917892,917893,917894,917895,917896,917897,917898,917899,917900,917901,917902,917903,917904,917905,917906,917907,917908,917909,917910,917911,917912,917913,917914,917915,917916,917917,917918,917919,917920,917921,917922,917923,917924,917925,917926,917927,917928,917929,917930,917931,917932,917933,917934,917935,917936,917937,917938,917939,917940,917941,917942,917943,917944,917945,917946,917947,917948,917949,917950,917951,917952,917953,917954,917955,917956,917957,917958,917959,917960,917961,917962,917963,917964,917965,917966,917967,917968,917969,917970,917971,917972,917973,917974,917975,917976,917977,917978,917979,917980,917981,917982,917983,917984,917985,917986,917987,917988,917989,917990,917991,917992,917993,917994,917995,917996,917997,917998,917999]'); + } + static getData() { + if (!this._data) { + this._data = new Set(InvisibleCharacters.getRawData()); + } + return this._data; + } + static isInvisibleCharacter(codePoint) { + return InvisibleCharacters.getData().has(codePoint); + } + static get codePoints() { + return InvisibleCharacters.getData(); + } +} +InvisibleCharacters._data = undefined; + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/types.js": +/*!****************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/types.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ assertIsDefined: () => (/* binding */ assertIsDefined), +/* harmony export */ assertType: () => (/* binding */ assertType), +/* harmony export */ isBoolean: () => (/* binding */ isBoolean), +/* harmony export */ isDefined: () => (/* binding */ isDefined), +/* harmony export */ isFunction: () => (/* binding */ isFunction), +/* harmony export */ isIterable: () => (/* binding */ isIterable), +/* harmony export */ isNumber: () => (/* binding */ isNumber), +/* harmony export */ isObject: () => (/* binding */ isObject), +/* harmony export */ isString: () => (/* binding */ isString), +/* harmony export */ isTypedArray: () => (/* binding */ isTypedArray), +/* harmony export */ isUndefined: () => (/* binding */ isUndefined), +/* harmony export */ isUndefinedOrNull: () => (/* binding */ isUndefinedOrNull), +/* harmony export */ validateConstraint: () => (/* binding */ validateConstraint), +/* harmony export */ validateConstraints: () => (/* binding */ validateConstraints) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/** + * @returns whether the provided parameter is a JavaScript String or not. + */ +function isString(str) { + return (typeof str === 'string'); +} +/** + * @returns whether the provided parameter is of type `object` but **not** + * `null`, an `array`, a `regexp`, nor a `date`. + */ +function isObject(obj) { + // The method can't do a type cast since there are type (like strings) which + // are subclasses of any put not positvely matched by the function. Hence type + // narrowing results in wrong results. + return typeof obj === 'object' + && obj !== null + && !Array.isArray(obj) + && !(obj instanceof RegExp) + && !(obj instanceof Date); +} +/** + * @returns whether the provided parameter is of type `Buffer` or Uint8Array dervived type + */ +function isTypedArray(obj) { + const TypedArray = Object.getPrototypeOf(Uint8Array); + return typeof obj === 'object' + && obj instanceof TypedArray; +} +/** + * In **contrast** to just checking `typeof` this will return `false` for `NaN`. + * @returns whether the provided parameter is a JavaScript Number or not. + */ +function isNumber(obj) { + return (typeof obj === 'number' && !isNaN(obj)); +} +/** + * @returns whether the provided parameter is an Iterable, casting to the given generic + */ +function isIterable(obj) { + return !!obj && typeof obj[Symbol.iterator] === 'function'; +} +/** + * @returns whether the provided parameter is a JavaScript Boolean or not. + */ +function isBoolean(obj) { + return (obj === true || obj === false); +} +/** + * @returns whether the provided parameter is undefined. + */ +function isUndefined(obj) { + return (typeof obj === 'undefined'); +} +/** + * @returns whether the provided parameter is defined. + */ +function isDefined(arg) { + return !isUndefinedOrNull(arg); +} +/** + * @returns whether the provided parameter is undefined or null. + */ +function isUndefinedOrNull(obj) { + return (isUndefined(obj) || obj === null); +} +function assertType(condition, type) { + if (!condition) { + throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type'); + } +} +/** + * Asserts that the argument passed in is neither undefined nor null. + */ +function assertIsDefined(arg) { + if (isUndefinedOrNull(arg)) { + throw new Error('Assertion Failed: argument is undefined or null'); + } + return arg; +} +/** + * @returns whether the provided parameter is a JavaScript Function or not. + */ +function isFunction(obj) { + return (typeof obj === 'function'); +} +function validateConstraints(args, constraints) { + const len = Math.min(args.length, constraints.length); + for (let i = 0; i < len; i++) { + validateConstraint(args[i], constraints[i]); + } +} +function validateConstraint(arg, constraint) { + if (isString(constraint)) { + if (typeof arg !== constraint) { + throw new Error(`argument does not match constraint: typeof ${constraint}`); + } + } + else if (isFunction(constraint)) { + try { + if (arg instanceof constraint) { + return; + } + } + catch (_a) { + // ignore + } + if (!isUndefinedOrNull(arg) && arg.constructor === constraint) { + return; + } + if (constraint.length === 1 && constraint.call(undefined, arg) === true) { + return; + } + throw new Error(`argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true`); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/uint.js": +/*!***************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/uint.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ toUint32: () => (/* binding */ toUint32), +/* harmony export */ toUint8: () => (/* binding */ toUint8) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +function toUint8(v) { + if (v < 0) { + return 0; + } + if (v > 255 /* Constants.MAX_UINT_8 */) { + return 255 /* Constants.MAX_UINT_8 */; + } + return v | 0; +} +function toUint32(v) { + if (v < 0) { + return 0; + } + if (v > 4294967295 /* Constants.MAX_UINT_32 */) { + return 4294967295 /* Constants.MAX_UINT_32 */; + } + return v | 0; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/uri.js": +/*!**************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/uri.js ***! + \**************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ URI: () => (/* binding */ URI), +/* harmony export */ uriToFsPath: () => (/* binding */ uriToFsPath) +/* harmony export */ }); +/* harmony import */ var _path_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./path.js */ "./node_modules/monaco-editor/esm/vs/base/common/path.js"); +/* harmony import */ var _platform_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./platform.js */ "./node_modules/monaco-editor/esm/vs/base/common/platform.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +const _schemePattern = /^\w[\w\d+.-]*$/; +const _singleSlashStart = /^\//; +const _doubleSlashStart = /^\/\//; +function _validateUri(ret, _strict) { + // scheme, must be set + if (!ret.scheme && _strict) { + throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${ret.authority}", path: "${ret.path}", query: "${ret.query}", fragment: "${ret.fragment}"}`); + } + // scheme, https://tools.ietf.org/html/rfc3986#section-3.1 + // ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) + if (ret.scheme && !_schemePattern.test(ret.scheme)) { + throw new Error('[UriError]: Scheme contains illegal characters.'); + } + // path, http://tools.ietf.org/html/rfc3986#section-3.3 + // If a URI contains an authority component, then the path component + // must either be empty or begin with a slash ("/") character. If a URI + // does not contain an authority component, then the path cannot begin + // with two slash characters ("//"). + if (ret.path) { + if (ret.authority) { + if (!_singleSlashStart.test(ret.path)) { + throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character'); + } + } + else { + if (_doubleSlashStart.test(ret.path)) { + throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")'); + } + } + } +} +// for a while we allowed uris *without* schemes and this is the migration +// for them, e.g. an uri without scheme and without strict-mode warns and falls +// back to the file-scheme. that should cause the least carnage and still be a +// clear warning +function _schemeFix(scheme, _strict) { + if (!scheme && !_strict) { + return 'file'; + } + return scheme; +} +// implements a bit of https://tools.ietf.org/html/rfc3986#section-5 +function _referenceResolution(scheme, path) { + // the slash-character is our 'default base' as we don't + // support constructing URIs relative to other URIs. This + // also means that we alter and potentially break paths. + // see https://tools.ietf.org/html/rfc3986#section-5.1.4 + switch (scheme) { + case 'https': + case 'http': + case 'file': + if (!path) { + path = _slash; + } + else if (path[0] !== _slash) { + path = _slash + path; + } + break; + } + return path; +} +const _empty = ''; +const _slash = '/'; +const _regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/; +/** + * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986. + * This class is a simple parser which creates the basic component parts + * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation + * and encoding. + * + * ```txt + * foo://example.com:8042/over/there?name=ferret#nose + * \_/ \______________/\_________/ \_________/ \__/ + * | | | | | + * scheme authority path query fragment + * | _____________________|__ + * / \ / \ + * urn:example:animal:ferret:nose + * ``` + */ +class URI { + static isUri(thing) { + if (thing instanceof URI) { + return true; + } + if (!thing) { + return false; + } + return typeof thing.authority === 'string' + && typeof thing.fragment === 'string' + && typeof thing.path === 'string' + && typeof thing.query === 'string' + && typeof thing.scheme === 'string' + && typeof thing.fsPath === 'string' + && typeof thing.with === 'function' + && typeof thing.toString === 'function'; + } + /** + * @internal + */ + constructor(schemeOrData, authority, path, query, fragment, _strict = false) { + if (typeof schemeOrData === 'object') { + this.scheme = schemeOrData.scheme || _empty; + this.authority = schemeOrData.authority || _empty; + this.path = schemeOrData.path || _empty; + this.query = schemeOrData.query || _empty; + this.fragment = schemeOrData.fragment || _empty; + // no validation because it's this URI + // that creates uri components. + // _validateUri(this); + } + else { + this.scheme = _schemeFix(schemeOrData, _strict); + this.authority = authority || _empty; + this.path = _referenceResolution(this.scheme, path || _empty); + this.query = query || _empty; + this.fragment = fragment || _empty; + _validateUri(this, _strict); + } + } + // ---- filesystem path ----------------------- + /** + * Returns a string representing the corresponding file system path of this URI. + * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the + * platform specific path separator. + * + * * Will *not* validate the path for invalid characters and semantics. + * * Will *not* look at the scheme of this URI. + * * The result shall *not* be used for display purposes but for accessing a file on disk. + * + * + * The *difference* to `URI#path` is the use of the platform specific separator and the handling + * of UNC paths. See the below sample of a file-uri with an authority (UNC path). + * + * ```ts + const u = URI.parse('file://server/c$/folder/file.txt') + u.authority === 'server' + u.path === '/shares/c$/file.txt' + u.fsPath === '\\server\c$\folder\file.txt' + ``` + * + * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path, + * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working + * with URIs that represent files on disk (`file` scheme). + */ + get fsPath() { + // if (this.scheme !== 'file') { + // console.warn(`[UriError] calling fsPath with scheme ${this.scheme}`); + // } + return uriToFsPath(this, false); + } + // ---- modify to new ------------------------- + with(change) { + if (!change) { + return this; + } + let { scheme, authority, path, query, fragment } = change; + if (scheme === undefined) { + scheme = this.scheme; + } + else if (scheme === null) { + scheme = _empty; + } + if (authority === undefined) { + authority = this.authority; + } + else if (authority === null) { + authority = _empty; + } + if (path === undefined) { + path = this.path; + } + else if (path === null) { + path = _empty; + } + if (query === undefined) { + query = this.query; + } + else if (query === null) { + query = _empty; + } + if (fragment === undefined) { + fragment = this.fragment; + } + else if (fragment === null) { + fragment = _empty; + } + if (scheme === this.scheme + && authority === this.authority + && path === this.path + && query === this.query + && fragment === this.fragment) { + return this; + } + return new Uri(scheme, authority, path, query, fragment); + } + // ---- parse & validate ------------------------ + /** + * Creates a new URI from a string, e.g. `http://www.example.com/some/path`, + * `file:///usr/home`, or `scheme:with/path`. + * + * @param value A string which represents an URI (see `URI#toString`). + */ + static parse(value, _strict = false) { + const match = _regexp.exec(value); + if (!match) { + return new Uri(_empty, _empty, _empty, _empty, _empty); + } + return new Uri(match[2] || _empty, percentDecode(match[4] || _empty), percentDecode(match[5] || _empty), percentDecode(match[7] || _empty), percentDecode(match[9] || _empty), _strict); + } + /** + * Creates a new URI from a file system path, e.g. `c:\my\files`, + * `/usr/home`, or `\\server\share\some\path`. + * + * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument + * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as** + * `URI.parse('file://' + path)` because the path might contain characters that are + * interpreted (# and ?). See the following sample: + * ```ts + const good = URI.file('/coding/c#/project1'); + good.scheme === 'file'; + good.path === '/coding/c#/project1'; + good.fragment === ''; + const bad = URI.parse('file://' + '/coding/c#/project1'); + bad.scheme === 'file'; + bad.path === '/coding/c'; // path is now broken + bad.fragment === '/project1'; + ``` + * + * @param path A file system path (see `URI#fsPath`) + */ + static file(path) { + let authority = _empty; + // normalize to fwd-slashes on windows, + // on other systems bwd-slashes are valid + // filename character, eg /f\oo/ba\r.txt + if (_platform_js__WEBPACK_IMPORTED_MODULE_1__.isWindows) { + path = path.replace(/\\/g, _slash); + } + // check for authority as used in UNC shares + // or use the path as given + if (path[0] === _slash && path[1] === _slash) { + const idx = path.indexOf(_slash, 2); + if (idx === -1) { + authority = path.substring(2); + path = _slash; + } + else { + authority = path.substring(2, idx); + path = path.substring(idx) || _slash; + } + } + return new Uri('file', authority, path, _empty, _empty); + } + /** + * Creates new URI from uri components. + * + * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs + * validation and should be used for untrusted uri components retrieved from storage, + * user input, command arguments etc + */ + static from(components, strict) { + const result = new Uri(components.scheme, components.authority, components.path, components.query, components.fragment, strict); + return result; + } + /** + * Join a URI path with path fragments and normalizes the resulting path. + * + * @param uri The input URI. + * @param pathFragment The path fragment to add to the URI path. + * @returns The resulting URI. + */ + static joinPath(uri, ...pathFragment) { + if (!uri.path) { + throw new Error(`[UriError]: cannot call joinPath on URI without path`); + } + let newPath; + if (_platform_js__WEBPACK_IMPORTED_MODULE_1__.isWindows && uri.scheme === 'file') { + newPath = URI.file(_path_js__WEBPACK_IMPORTED_MODULE_0__.win32.join(uriToFsPath(uri, true), ...pathFragment)).path; + } + else { + newPath = _path_js__WEBPACK_IMPORTED_MODULE_0__.posix.join(uri.path, ...pathFragment); + } + return uri.with({ path: newPath }); + } + // ---- printing/externalize --------------------------- + /** + * Creates a string representation for this URI. It's guaranteed that calling + * `URI.parse` with the result of this function creates an URI which is equal + * to this URI. + * + * * The result shall *not* be used for display purposes but for externalization or transport. + * * The result will be encoded using the percentage encoding and encoding happens mostly + * ignore the scheme-specific encoding rules. + * + * @param skipEncoding Do not encode the result, default is `false` + */ + toString(skipEncoding = false) { + return _asFormatted(this, skipEncoding); + } + toJSON() { + return this; + } + static revive(data) { + var _a, _b; + if (!data) { + return data; + } + else if (data instanceof URI) { + return data; + } + else { + const result = new Uri(data); + result._formatted = (_a = data.external) !== null && _a !== void 0 ? _a : null; + result._fsPath = data._sep === _pathSepMarker ? (_b = data.fsPath) !== null && _b !== void 0 ? _b : null : null; + return result; + } + } +} +const _pathSepMarker = _platform_js__WEBPACK_IMPORTED_MODULE_1__.isWindows ? 1 : undefined; +// This class exists so that URI is compatible with vscode.Uri (API). +class Uri extends URI { + constructor() { + super(...arguments); + this._formatted = null; + this._fsPath = null; + } + get fsPath() { + if (!this._fsPath) { + this._fsPath = uriToFsPath(this, false); + } + return this._fsPath; + } + toString(skipEncoding = false) { + if (!skipEncoding) { + if (!this._formatted) { + this._formatted = _asFormatted(this, false); + } + return this._formatted; + } + else { + // we don't cache that + return _asFormatted(this, true); + } + } + toJSON() { + const res = { + $mid: 1 /* MarshalledId.Uri */ + }; + // cached state + if (this._fsPath) { + res.fsPath = this._fsPath; + res._sep = _pathSepMarker; + } + if (this._formatted) { + res.external = this._formatted; + } + //--- uri components + if (this.path) { + res.path = this.path; + } + // TODO + // this isn't correct and can violate the UriComponents contract but + // this is part of the vscode.Uri API and we shouldn't change how that + // works anymore + if (this.scheme) { + res.scheme = this.scheme; + } + if (this.authority) { + res.authority = this.authority; + } + if (this.query) { + res.query = this.query; + } + if (this.fragment) { + res.fragment = this.fragment; + } + return res; + } +} +// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2 +const encodeTable = { + [58 /* CharCode.Colon */]: '%3A', // gen-delims + [47 /* CharCode.Slash */]: '%2F', + [63 /* CharCode.QuestionMark */]: '%3F', + [35 /* CharCode.Hash */]: '%23', + [91 /* CharCode.OpenSquareBracket */]: '%5B', + [93 /* CharCode.CloseSquareBracket */]: '%5D', + [64 /* CharCode.AtSign */]: '%40', + [33 /* CharCode.ExclamationMark */]: '%21', // sub-delims + [36 /* CharCode.DollarSign */]: '%24', + [38 /* CharCode.Ampersand */]: '%26', + [39 /* CharCode.SingleQuote */]: '%27', + [40 /* CharCode.OpenParen */]: '%28', + [41 /* CharCode.CloseParen */]: '%29', + [42 /* CharCode.Asterisk */]: '%2A', + [43 /* CharCode.Plus */]: '%2B', + [44 /* CharCode.Comma */]: '%2C', + [59 /* CharCode.Semicolon */]: '%3B', + [61 /* CharCode.Equals */]: '%3D', + [32 /* CharCode.Space */]: '%20', +}; +function encodeURIComponentFast(uriComponent, isPath, isAuthority) { + let res = undefined; + let nativeEncodePos = -1; + for (let pos = 0; pos < uriComponent.length; pos++) { + const code = uriComponent.charCodeAt(pos); + // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3 + if ((code >= 97 /* CharCode.a */ && code <= 122 /* CharCode.z */) + || (code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */) + || (code >= 48 /* CharCode.Digit0 */ && code <= 57 /* CharCode.Digit9 */) + || code === 45 /* CharCode.Dash */ + || code === 46 /* CharCode.Period */ + || code === 95 /* CharCode.Underline */ + || code === 126 /* CharCode.Tilde */ + || (isPath && code === 47 /* CharCode.Slash */) + || (isAuthority && code === 91 /* CharCode.OpenSquareBracket */) + || (isAuthority && code === 93 /* CharCode.CloseSquareBracket */) + || (isAuthority && code === 58 /* CharCode.Colon */)) { + // check if we are delaying native encode + if (nativeEncodePos !== -1) { + res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos)); + nativeEncodePos = -1; + } + // check if we write into a new string (by default we try to return the param) + if (res !== undefined) { + res += uriComponent.charAt(pos); + } + } + else { + // encoding needed, we need to allocate a new string + if (res === undefined) { + res = uriComponent.substr(0, pos); + } + // check with default table first + const escaped = encodeTable[code]; + if (escaped !== undefined) { + // check if we are delaying native encode + if (nativeEncodePos !== -1) { + res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos)); + nativeEncodePos = -1; + } + // append escaped variant to result + res += escaped; + } + else if (nativeEncodePos === -1) { + // use native encode only when needed + nativeEncodePos = pos; + } + } + } + if (nativeEncodePos !== -1) { + res += encodeURIComponent(uriComponent.substring(nativeEncodePos)); + } + return res !== undefined ? res : uriComponent; +} +function encodeURIComponentMinimal(path) { + let res = undefined; + for (let pos = 0; pos < path.length; pos++) { + const code = path.charCodeAt(pos); + if (code === 35 /* CharCode.Hash */ || code === 63 /* CharCode.QuestionMark */) { + if (res === undefined) { + res = path.substr(0, pos); + } + res += encodeTable[code]; + } + else { + if (res !== undefined) { + res += path[pos]; + } + } + } + return res !== undefined ? res : path; +} +/** + * Compute `fsPath` for the given uri + */ +function uriToFsPath(uri, keepDriveLetterCasing) { + let value; + if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') { + // unc path: file://shares/c$/far/boo + value = `//${uri.authority}${uri.path}`; + } + else if (uri.path.charCodeAt(0) === 47 /* CharCode.Slash */ + && (uri.path.charCodeAt(1) >= 65 /* CharCode.A */ && uri.path.charCodeAt(1) <= 90 /* CharCode.Z */ || uri.path.charCodeAt(1) >= 97 /* CharCode.a */ && uri.path.charCodeAt(1) <= 122 /* CharCode.z */) + && uri.path.charCodeAt(2) === 58 /* CharCode.Colon */) { + if (!keepDriveLetterCasing) { + // windows drive letter: file:///c:/far/boo + value = uri.path[1].toLowerCase() + uri.path.substr(2); + } + else { + value = uri.path.substr(1); + } + } + else { + // other path + value = uri.path; + } + if (_platform_js__WEBPACK_IMPORTED_MODULE_1__.isWindows) { + value = value.replace(/\//g, '\\'); + } + return value; +} +/** + * Create the external version of a uri + */ +function _asFormatted(uri, skipEncoding) { + const encoder = !skipEncoding + ? encodeURIComponentFast + : encodeURIComponentMinimal; + let res = ''; + let { scheme, authority, path, query, fragment } = uri; + if (scheme) { + res += scheme; + res += ':'; + } + if (authority || scheme === 'file') { + res += _slash; + res += _slash; + } + if (authority) { + let idx = authority.indexOf('@'); + if (idx !== -1) { + // @ + const userinfo = authority.substr(0, idx); + authority = authority.substr(idx + 1); + idx = userinfo.lastIndexOf(':'); + if (idx === -1) { + res += encoder(userinfo, false, false); + } + else { + // :@ + res += encoder(userinfo.substr(0, idx), false, false); + res += ':'; + res += encoder(userinfo.substr(idx + 1), false, true); + } + res += '@'; + } + authority = authority.toLowerCase(); + idx = authority.lastIndexOf(':'); + if (idx === -1) { + res += encoder(authority, false, true); + } + else { + // : + res += encoder(authority.substr(0, idx), false, true); + res += authority.substr(idx); + } + } + if (path) { + // lower-case windows drive letters in /C:/fff or C:/fff + if (path.length >= 3 && path.charCodeAt(0) === 47 /* CharCode.Slash */ && path.charCodeAt(2) === 58 /* CharCode.Colon */) { + const code = path.charCodeAt(1); + if (code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */) { + path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`; // "/c:".length === 3 + } + } + else if (path.length >= 2 && path.charCodeAt(1) === 58 /* CharCode.Colon */) { + const code = path.charCodeAt(0); + if (code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */) { + path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // "/c:".length === 3 + } + } + // encode the rest of the path + res += encoder(path, true, false); + } + if (query) { + res += '?'; + res += encoder(query, false, false); + } + if (fragment) { + res += '#'; + res += !skipEncoding ? encodeURIComponentFast(fragment, false, false) : fragment; + } + return res; +} +// --- decode +function decodeURIComponentGraceful(str) { + try { + return decodeURIComponent(str); + } + catch (_a) { + if (str.length > 3) { + return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3)); + } + else { + return str; + } + } +} +const _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g; +function percentDecode(str) { + if (!str.match(_rEncodedAsHex)) { + return str; + } + return str.replace(_rEncodedAsHex, (match) => decodeURIComponentGraceful(match)); +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.js": +/*!******************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.js ***! + \******************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ SimpleWorkerClient: () => (/* binding */ SimpleWorkerClient), +/* harmony export */ SimpleWorkerServer: () => (/* binding */ SimpleWorkerServer), +/* harmony export */ create: () => (/* binding */ create), +/* harmony export */ logOnceWebWorkerWarning: () => (/* binding */ logOnceWebWorkerWarning) +/* harmony export */ }); +/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../errors.js */ "./node_modules/monaco-editor/esm/vs/base/common/errors.js"); +/* harmony import */ var _event_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../event.js */ "./node_modules/monaco-editor/esm/vs/base/common/event.js"); +/* harmony import */ var _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../lifecycle.js */ "./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js"); +/* harmony import */ var _objects_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../objects.js */ "./node_modules/monaco-editor/esm/vs/base/common/objects.js"); +/* harmony import */ var _platform_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../platform.js */ "./node_modules/monaco-editor/esm/vs/base/common/platform.js"); +/* harmony import */ var _strings_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../strings.js */ "./node_modules/monaco-editor/esm/vs/base/common/strings.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + + +const INITIALIZE = '$initialize'; +let webWorkerWarningLogged = false; +function logOnceWebWorkerWarning(err) { + if (!_platform_js__WEBPACK_IMPORTED_MODULE_4__.isWeb) { + // running tests + return; + } + if (!webWorkerWarningLogged) { + webWorkerWarningLogged = true; + console.warn('Could not create web worker(s). Falling back to loading web worker code in main thread, which might cause UI freezes. Please see https://github.com/microsoft/monaco-editor#faq'); + } + console.warn(err.message); +} +class RequestMessage { + constructor(vsWorker, req, method, args) { + this.vsWorker = vsWorker; + this.req = req; + this.method = method; + this.args = args; + this.type = 0 /* MessageType.Request */; + } +} +class ReplyMessage { + constructor(vsWorker, seq, res, err) { + this.vsWorker = vsWorker; + this.seq = seq; + this.res = res; + this.err = err; + this.type = 1 /* MessageType.Reply */; + } +} +class SubscribeEventMessage { + constructor(vsWorker, req, eventName, arg) { + this.vsWorker = vsWorker; + this.req = req; + this.eventName = eventName; + this.arg = arg; + this.type = 2 /* MessageType.SubscribeEvent */; + } +} +class EventMessage { + constructor(vsWorker, req, event) { + this.vsWorker = vsWorker; + this.req = req; + this.event = event; + this.type = 3 /* MessageType.Event */; + } +} +class UnsubscribeEventMessage { + constructor(vsWorker, req) { + this.vsWorker = vsWorker; + this.req = req; + this.type = 4 /* MessageType.UnsubscribeEvent */; + } +} +class SimpleWorkerProtocol { + constructor(handler) { + this._workerId = -1; + this._handler = handler; + this._lastSentReq = 0; + this._pendingReplies = Object.create(null); + this._pendingEmitters = new Map(); + this._pendingEvents = new Map(); + } + setWorkerId(workerId) { + this._workerId = workerId; + } + sendMessage(method, args) { + const req = String(++this._lastSentReq); + return new Promise((resolve, reject) => { + this._pendingReplies[req] = { + resolve: resolve, + reject: reject + }; + this._send(new RequestMessage(this._workerId, req, method, args)); + }); + } + listen(eventName, arg) { + let req = null; + const emitter = new _event_js__WEBPACK_IMPORTED_MODULE_1__.Emitter({ + onWillAddFirstListener: () => { + req = String(++this._lastSentReq); + this._pendingEmitters.set(req, emitter); + this._send(new SubscribeEventMessage(this._workerId, req, eventName, arg)); + }, + onDidRemoveLastListener: () => { + this._pendingEmitters.delete(req); + this._send(new UnsubscribeEventMessage(this._workerId, req)); + req = null; + } + }); + return emitter.event; + } + handleMessage(message) { + if (!message || !message.vsWorker) { + return; + } + if (this._workerId !== -1 && message.vsWorker !== this._workerId) { + return; + } + this._handleMessage(message); + } + _handleMessage(msg) { + switch (msg.type) { + case 1 /* MessageType.Reply */: + return this._handleReplyMessage(msg); + case 0 /* MessageType.Request */: + return this._handleRequestMessage(msg); + case 2 /* MessageType.SubscribeEvent */: + return this._handleSubscribeEventMessage(msg); + case 3 /* MessageType.Event */: + return this._handleEventMessage(msg); + case 4 /* MessageType.UnsubscribeEvent */: + return this._handleUnsubscribeEventMessage(msg); + } + } + _handleReplyMessage(replyMessage) { + if (!this._pendingReplies[replyMessage.seq]) { + console.warn('Got reply to unknown seq'); + return; + } + const reply = this._pendingReplies[replyMessage.seq]; + delete this._pendingReplies[replyMessage.seq]; + if (replyMessage.err) { + let err = replyMessage.err; + if (replyMessage.err.$isError) { + err = new Error(); + err.name = replyMessage.err.name; + err.message = replyMessage.err.message; + err.stack = replyMessage.err.stack; + } + reply.reject(err); + return; + } + reply.resolve(replyMessage.res); + } + _handleRequestMessage(requestMessage) { + const req = requestMessage.req; + const result = this._handler.handleMessage(requestMessage.method, requestMessage.args); + result.then((r) => { + this._send(new ReplyMessage(this._workerId, req, r, undefined)); + }, (e) => { + if (e.detail instanceof Error) { + // Loading errors have a detail property that points to the actual error + e.detail = (0,_errors_js__WEBPACK_IMPORTED_MODULE_0__.transformErrorForSerialization)(e.detail); + } + this._send(new ReplyMessage(this._workerId, req, undefined, (0,_errors_js__WEBPACK_IMPORTED_MODULE_0__.transformErrorForSerialization)(e))); + }); + } + _handleSubscribeEventMessage(msg) { + const req = msg.req; + const disposable = this._handler.handleEvent(msg.eventName, msg.arg)((event) => { + this._send(new EventMessage(this._workerId, req, event)); + }); + this._pendingEvents.set(req, disposable); + } + _handleEventMessage(msg) { + if (!this._pendingEmitters.has(msg.req)) { + console.warn('Got event for unknown req'); + return; + } + this._pendingEmitters.get(msg.req).fire(msg.event); + } + _handleUnsubscribeEventMessage(msg) { + if (!this._pendingEvents.has(msg.req)) { + console.warn('Got unsubscribe for unknown req'); + return; + } + this._pendingEvents.get(msg.req).dispose(); + this._pendingEvents.delete(msg.req); + } + _send(msg) { + const transfer = []; + if (msg.type === 0 /* MessageType.Request */) { + for (let i = 0; i < msg.args.length; i++) { + if (msg.args[i] instanceof ArrayBuffer) { + transfer.push(msg.args[i]); + } + } + } + else if (msg.type === 1 /* MessageType.Reply */) { + if (msg.res instanceof ArrayBuffer) { + transfer.push(msg.res); + } + } + this._handler.sendMessage(msg, transfer); + } +} +/** + * Main thread side + */ +class SimpleWorkerClient extends _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.Disposable { + constructor(workerFactory, moduleId, host) { + super(); + let lazyProxyReject = null; + this._worker = this._register(workerFactory.create('vs/base/common/worker/simpleWorker', (msg) => { + this._protocol.handleMessage(msg); + }, (err) => { + // in Firefox, web workers fail lazily :( + // we will reject the proxy + lazyProxyReject === null || lazyProxyReject === void 0 ? void 0 : lazyProxyReject(err); + })); + this._protocol = new SimpleWorkerProtocol({ + sendMessage: (msg, transfer) => { + this._worker.postMessage(msg, transfer); + }, + handleMessage: (method, args) => { + if (typeof host[method] !== 'function') { + return Promise.reject(new Error('Missing method ' + method + ' on main thread host.')); + } + try { + return Promise.resolve(host[method].apply(host, args)); + } + catch (e) { + return Promise.reject(e); + } + }, + handleEvent: (eventName, arg) => { + if (propertyIsDynamicEvent(eventName)) { + const event = host[eventName].call(host, arg); + if (typeof event !== 'function') { + throw new Error(`Missing dynamic event ${eventName} on main thread host.`); + } + return event; + } + if (propertyIsEvent(eventName)) { + const event = host[eventName]; + if (typeof event !== 'function') { + throw new Error(`Missing event ${eventName} on main thread host.`); + } + return event; + } + throw new Error(`Malformed event name ${eventName}`); + } + }); + this._protocol.setWorkerId(this._worker.getId()); + // Gather loader configuration + let loaderConfiguration = null; + const globalRequire = globalThis.require; + if (typeof globalRequire !== 'undefined' && typeof globalRequire.getConfig === 'function') { + // Get the configuration from the Monaco AMD Loader + loaderConfiguration = globalRequire.getConfig(); + } + else if (typeof globalThis.requirejs !== 'undefined') { + // Get the configuration from requirejs + loaderConfiguration = globalThis.requirejs.s.contexts._.config; + } + const hostMethods = (0,_objects_js__WEBPACK_IMPORTED_MODULE_3__.getAllMethodNames)(host); + // Send initialize message + this._onModuleLoaded = this._protocol.sendMessage(INITIALIZE, [ + this._worker.getId(), + JSON.parse(JSON.stringify(loaderConfiguration)), + moduleId, + hostMethods, + ]); + // Create proxy to loaded code + const proxyMethodRequest = (method, args) => { + return this._request(method, args); + }; + const proxyListen = (eventName, arg) => { + return this._protocol.listen(eventName, arg); + }; + this._lazyProxy = new Promise((resolve, reject) => { + lazyProxyReject = reject; + this._onModuleLoaded.then((availableMethods) => { + resolve(createProxyObject(availableMethods, proxyMethodRequest, proxyListen)); + }, (e) => { + reject(e); + this._onError('Worker failed to load ' + moduleId, e); + }); + }); + } + getProxyObject() { + return this._lazyProxy; + } + _request(method, args) { + return new Promise((resolve, reject) => { + this._onModuleLoaded.then(() => { + this._protocol.sendMessage(method, args).then(resolve, reject); + }, reject); + }); + } + _onError(message, error) { + console.error(message); + console.info(error); + } +} +function propertyIsEvent(name) { + // Assume a property is an event if it has a form of "onSomething" + return name[0] === 'o' && name[1] === 'n' && _strings_js__WEBPACK_IMPORTED_MODULE_5__.isUpperAsciiLetter(name.charCodeAt(2)); +} +function propertyIsDynamicEvent(name) { + // Assume a property is a dynamic event (a method that returns an event) if it has a form of "onDynamicSomething" + return /^onDynamic/.test(name) && _strings_js__WEBPACK_IMPORTED_MODULE_5__.isUpperAsciiLetter(name.charCodeAt(9)); +} +function createProxyObject(methodNames, invoke, proxyListen) { + const createProxyMethod = (method) => { + return function () { + const args = Array.prototype.slice.call(arguments, 0); + return invoke(method, args); + }; + }; + const createProxyDynamicEvent = (eventName) => { + return function (arg) { + return proxyListen(eventName, arg); + }; + }; + const result = {}; + for (const methodName of methodNames) { + if (propertyIsDynamicEvent(methodName)) { + result[methodName] = createProxyDynamicEvent(methodName); + continue; + } + if (propertyIsEvent(methodName)) { + result[methodName] = proxyListen(methodName, undefined); + continue; + } + result[methodName] = createProxyMethod(methodName); + } + return result; +} +/** + * Worker side + */ +class SimpleWorkerServer { + constructor(postMessage, requestHandlerFactory) { + this._requestHandlerFactory = requestHandlerFactory; + this._requestHandler = null; + this._protocol = new SimpleWorkerProtocol({ + sendMessage: (msg, transfer) => { + postMessage(msg, transfer); + }, + handleMessage: (method, args) => this._handleMessage(method, args), + handleEvent: (eventName, arg) => this._handleEvent(eventName, arg) + }); + } + onmessage(msg) { + this._protocol.handleMessage(msg); + } + _handleMessage(method, args) { + if (method === INITIALIZE) { + return this.initialize(args[0], args[1], args[2], args[3]); + } + if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') { + return Promise.reject(new Error('Missing requestHandler or method: ' + method)); + } + try { + return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args)); + } + catch (e) { + return Promise.reject(e); + } + } + _handleEvent(eventName, arg) { + if (!this._requestHandler) { + throw new Error(`Missing requestHandler`); + } + if (propertyIsDynamicEvent(eventName)) { + const event = this._requestHandler[eventName].call(this._requestHandler, arg); + if (typeof event !== 'function') { + throw new Error(`Missing dynamic event ${eventName} on request handler.`); + } + return event; + } + if (propertyIsEvent(eventName)) { + const event = this._requestHandler[eventName]; + if (typeof event !== 'function') { + throw new Error(`Missing event ${eventName} on request handler.`); + } + return event; + } + throw new Error(`Malformed event name ${eventName}`); + } + initialize(workerId, loaderConfig, moduleId, hostMethods) { + this._protocol.setWorkerId(workerId); + const proxyMethodRequest = (method, args) => { + return this._protocol.sendMessage(method, args); + }; + const proxyListen = (eventName, arg) => { + return this._protocol.listen(eventName, arg); + }; + const hostProxy = createProxyObject(hostMethods, proxyMethodRequest, proxyListen); + if (this._requestHandlerFactory) { + // static request handler + this._requestHandler = this._requestHandlerFactory(hostProxy); + return Promise.resolve((0,_objects_js__WEBPACK_IMPORTED_MODULE_3__.getAllMethodNames)(this._requestHandler)); + } + if (loaderConfig) { + // Remove 'baseUrl', handling it is beyond scope for now + if (typeof loaderConfig.baseUrl !== 'undefined') { + delete loaderConfig['baseUrl']; + } + if (typeof loaderConfig.paths !== 'undefined') { + if (typeof loaderConfig.paths.vs !== 'undefined') { + delete loaderConfig.paths['vs']; + } + } + if (typeof loaderConfig.trustedTypesPolicy !== undefined) { + // don't use, it has been destroyed during serialize + delete loaderConfig['trustedTypesPolicy']; + } + // Since this is in a web worker, enable catching errors + loaderConfig.catchError = true; + globalThis.require.config(loaderConfig); + } + return new Promise((resolve, reject) => { + // Use the global require to be sure to get the global config + // ESM-comment-begin + // const req = (globalThis.require || require); + // ESM-comment-end + // ESM-uncomment-begin + const req = globalThis.require; + // ESM-uncomment-end + req([moduleId], (module) => { + this._requestHandler = module.create(hostProxy); + if (!this._requestHandler) { + reject(new Error(`No RequestHandler!`)); + return; + } + resolve((0,_objects_js__WEBPACK_IMPORTED_MODULE_3__.getAllMethodNames)(this._requestHandler)); + }, reject); + }); + } +} +/** + * Called on the worker side + * @skipMangle + */ +function create(postMessage) { + return new SimpleWorkerServer(postMessage, null); +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js": +/*!*************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js ***! + \*************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ CharacterClassifier: () => (/* binding */ CharacterClassifier), +/* harmony export */ CharacterSet: () => (/* binding */ CharacterSet) +/* harmony export */ }); +/* harmony import */ var _base_common_uint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/uint.js */ "./node_modules/monaco-editor/esm/vs/base/common/uint.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * A fast character classifier that uses a compact array for ASCII values. + */ +class CharacterClassifier { + constructor(_defaultValue) { + const defaultValue = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_0__.toUint8)(_defaultValue); + this._defaultValue = defaultValue; + this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue); + this._map = new Map(); + } + static _createAsciiMap(defaultValue) { + const asciiMap = new Uint8Array(256); + asciiMap.fill(defaultValue); + return asciiMap; + } + set(charCode, _value) { + const value = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_0__.toUint8)(_value); + if (charCode >= 0 && charCode < 256) { + this._asciiMap[charCode] = value; + } + else { + this._map.set(charCode, value); + } + } + get(charCode) { + if (charCode >= 0 && charCode < 256) { + return this._asciiMap[charCode]; + } + else { + return (this._map.get(charCode) || this._defaultValue); + } + } + clear() { + this._asciiMap.fill(this._defaultValue); + this._map.clear(); + } +} +class CharacterSet { + constructor() { + this._actual = new CharacterClassifier(0 /* Boolean.False */); + } + add(charCode) { + this._actual.set(charCode, 1 /* Boolean.True */); + } + has(charCode) { + return (this._actual.get(charCode) === 1 /* Boolean.True */); + } + clear() { + return this._actual.clear(); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js": +/*!***************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js ***! + \***************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LineRange: () => (/* binding */ LineRange), +/* harmony export */ LineRangeSet: () => (/* binding */ LineRangeSet) +/* harmony export */ }); +/* harmony import */ var _base_common_errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/errors.js */ "./node_modules/monaco-editor/esm/vs/base/common/errors.js"); +/* harmony import */ var _offsetRange_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/* harmony import */ var _range_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../base/common/arraysFind.js */ "./node_modules/monaco-editor/esm/vs/base/common/arraysFind.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + +/** + * A range of lines (1-based). + */ +class LineRange { + static fromRange(range) { + return new LineRange(range.startLineNumber, range.endLineNumber); + } + static fromRangeInclusive(range) { + return new LineRange(range.startLineNumber, range.endLineNumber + 1); + } + /** + * @param lineRanges An array of sorted line ranges. + */ + static joinMany(lineRanges) { + if (lineRanges.length === 0) { + return []; + } + let result = new LineRangeSet(lineRanges[0].slice()); + for (let i = 1; i < lineRanges.length; i++) { + result = result.getUnion(new LineRangeSet(lineRanges[i].slice())); + } + return result.ranges; + } + static ofLength(startLineNumber, length) { + return new LineRange(startLineNumber, startLineNumber + length); + } + /** + * @internal + */ + static deserialize(lineRange) { + return new LineRange(lineRange[0], lineRange[1]); + } + constructor(startLineNumber, endLineNumberExclusive) { + if (startLineNumber > endLineNumberExclusive) { + throw new _base_common_errors_js__WEBPACK_IMPORTED_MODULE_0__.BugIndicatingError(`startLineNumber ${startLineNumber} cannot be after endLineNumberExclusive ${endLineNumberExclusive}`); + } + this.startLineNumber = startLineNumber; + this.endLineNumberExclusive = endLineNumberExclusive; + } + /** + * Indicates if this line range contains the given line number. + */ + contains(lineNumber) { + return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive; + } + /** + * Indicates if this line range is empty. + */ + get isEmpty() { + return this.startLineNumber === this.endLineNumberExclusive; + } + /** + * Moves this line range by the given offset of line numbers. + */ + delta(offset) { + return new LineRange(this.startLineNumber + offset, this.endLineNumberExclusive + offset); + } + deltaLength(offset) { + return new LineRange(this.startLineNumber, this.endLineNumberExclusive + offset); + } + /** + * The number of lines this line range spans. + */ + get length() { + return this.endLineNumberExclusive - this.startLineNumber; + } + /** + * Creates a line range that combines this and the given line range. + */ + join(other) { + return new LineRange(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive)); + } + toString() { + return `[${this.startLineNumber},${this.endLineNumberExclusive})`; + } + /** + * The resulting range is empty if the ranges do not intersect, but touch. + * If the ranges don't even touch, the result is undefined. + */ + intersect(other) { + const startLineNumber = Math.max(this.startLineNumber, other.startLineNumber); + const endLineNumberExclusive = Math.min(this.endLineNumberExclusive, other.endLineNumberExclusive); + if (startLineNumber <= endLineNumberExclusive) { + return new LineRange(startLineNumber, endLineNumberExclusive); + } + return undefined; + } + intersectsStrict(other) { + return this.startLineNumber < other.endLineNumberExclusive && other.startLineNumber < this.endLineNumberExclusive; + } + overlapOrTouch(other) { + return this.startLineNumber <= other.endLineNumberExclusive && other.startLineNumber <= this.endLineNumberExclusive; + } + equals(b) { + return this.startLineNumber === b.startLineNumber && this.endLineNumberExclusive === b.endLineNumberExclusive; + } + toInclusiveRange() { + if (this.isEmpty) { + return null; + } + return new _range_js__WEBPACK_IMPORTED_MODULE_2__.Range(this.startLineNumber, 1, this.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER); + } + toExclusiveRange() { + return new _range_js__WEBPACK_IMPORTED_MODULE_2__.Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1); + } + mapToLineArray(f) { + const result = []; + for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) { + result.push(f(lineNumber)); + } + return result; + } + forEach(f) { + for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) { + f(lineNumber); + } + } + /** + * @internal + */ + serialize() { + return [this.startLineNumber, this.endLineNumberExclusive]; + } + includes(lineNumber) { + return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive; + } + /** + * Converts this 1-based line range to a 0-based offset range (subtracts 1!). + * @internal + */ + toOffsetRange() { + return new _offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(this.startLineNumber - 1, this.endLineNumberExclusive - 1); + } +} +class LineRangeSet { + constructor( + /** + * Sorted by start line number. + * No two line ranges are touching or intersecting. + */ + _normalizedRanges = []) { + this._normalizedRanges = _normalizedRanges; + } + get ranges() { + return this._normalizedRanges; + } + addRange(range) { + if (range.length === 0) { + return; + } + // Idea: Find joinRange such that: + // replaceRange = _normalizedRanges.replaceRange(joinRange, range.joinAll(joinRange.map(idx => this._normalizedRanges[idx]))) + // idx of first element that touches range or that is after range + const joinRangeStartIdx = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findFirstIdxMonotonousOrArrLen)(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber); + // idx of element after { last element that touches range or that is before range } + const joinRangeEndIdxExclusive = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findLastIdxMonotonous)(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1; + if (joinRangeStartIdx === joinRangeEndIdxExclusive) { + // If there is no element that touches range, then joinRangeStartIdx === joinRangeEndIdxExclusive and that value is the index of the element after range + this._normalizedRanges.splice(joinRangeStartIdx, 0, range); + } + else if (joinRangeStartIdx === joinRangeEndIdxExclusive - 1) { + // Else, there is an element that touches range and in this case it is both the first and last element. Thus we can replace it + const joinRange = this._normalizedRanges[joinRangeStartIdx]; + this._normalizedRanges[joinRangeStartIdx] = joinRange.join(range); + } + else { + // First and last element are different - we need to replace the entire range + const joinRange = this._normalizedRanges[joinRangeStartIdx].join(this._normalizedRanges[joinRangeEndIdxExclusive - 1]).join(range); + this._normalizedRanges.splice(joinRangeStartIdx, joinRangeEndIdxExclusive - joinRangeStartIdx, joinRange); + } + } + contains(lineNumber) { + const rangeThatStartsBeforeEnd = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findLastMonotonous)(this._normalizedRanges, r => r.startLineNumber <= lineNumber); + return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > lineNumber; + } + intersects(range) { + const rangeThatStartsBeforeEnd = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findLastMonotonous)(this._normalizedRanges, r => r.startLineNumber < range.endLineNumberExclusive); + return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > range.startLineNumber; + } + getUnion(other) { + if (this._normalizedRanges.length === 0) { + return other; + } + if (other._normalizedRanges.length === 0) { + return this; + } + const result = []; + let i1 = 0; + let i2 = 0; + let current = null; + while (i1 < this._normalizedRanges.length || i2 < other._normalizedRanges.length) { + let next = null; + if (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) { + const lineRange1 = this._normalizedRanges[i1]; + const lineRange2 = other._normalizedRanges[i2]; + if (lineRange1.startLineNumber < lineRange2.startLineNumber) { + next = lineRange1; + i1++; + } + else { + next = lineRange2; + i2++; + } + } + else if (i1 < this._normalizedRanges.length) { + next = this._normalizedRanges[i1]; + i1++; + } + else { + next = other._normalizedRanges[i2]; + i2++; + } + if (current === null) { + current = next; + } + else { + if (current.endLineNumberExclusive >= next.startLineNumber) { + // merge + current = new LineRange(current.startLineNumber, Math.max(current.endLineNumberExclusive, next.endLineNumberExclusive)); + } + else { + // push + result.push(current); + current = next; + } + } + } + if (current !== null) { + result.push(current); + } + return new LineRangeSet(result); + } + /** + * Subtracts all ranges in this set from `range` and returns the result. + */ + subtractFrom(range) { + // idx of first element that touches range or that is after range + const joinRangeStartIdx = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findFirstIdxMonotonousOrArrLen)(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber); + // idx of element after { last element that touches range or that is before range } + const joinRangeEndIdxExclusive = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findLastIdxMonotonous)(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1; + if (joinRangeStartIdx === joinRangeEndIdxExclusive) { + return new LineRangeSet([range]); + } + const result = []; + let startLineNumber = range.startLineNumber; + for (let i = joinRangeStartIdx; i < joinRangeEndIdxExclusive; i++) { + const r = this._normalizedRanges[i]; + if (r.startLineNumber > startLineNumber) { + result.push(new LineRange(startLineNumber, r.startLineNumber)); + } + startLineNumber = r.endLineNumberExclusive; + } + if (startLineNumber < range.endLineNumberExclusive) { + result.push(new LineRange(startLineNumber, range.endLineNumberExclusive)); + } + return new LineRangeSet(result); + } + toString() { + return this._normalizedRanges.map(r => r.toString()).join(', '); + } + getIntersection(other) { + const result = []; + let i1 = 0; + let i2 = 0; + while (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) { + const r1 = this._normalizedRanges[i1]; + const r2 = other._normalizedRanges[i2]; + const i = r1.intersect(r2); + if (i && !i.isEmpty) { + result.push(i); + } + if (r1.endLineNumberExclusive < r2.endLineNumberExclusive) { + i1++; + } + else { + i2++; + } + } + return new LineRangeSet(result); + } + getWithDelta(value) { + return new LineRangeSet(this._normalizedRanges.map(r => r.delta(value))); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js": +/*!*****************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js ***! + \*****************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ OffsetRange: () => (/* binding */ OffsetRange), +/* harmony export */ OffsetRangeSet: () => (/* binding */ OffsetRangeSet) +/* harmony export */ }); +/* harmony import */ var _base_common_errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/errors.js */ "./node_modules/monaco-editor/esm/vs/base/common/errors.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * A range of offsets (0-based). +*/ +class OffsetRange { + static addRange(range, sortedRanges) { + let i = 0; + while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) { + i++; + } + let j = i; + while (j < sortedRanges.length && sortedRanges[j].start <= range.endExclusive) { + j++; + } + if (i === j) { + sortedRanges.splice(i, 0, range); + } + else { + const start = Math.min(range.start, sortedRanges[i].start); + const end = Math.max(range.endExclusive, sortedRanges[j - 1].endExclusive); + sortedRanges.splice(i, j - i, new OffsetRange(start, end)); + } + } + static tryCreate(start, endExclusive) { + if (start > endExclusive) { + return undefined; + } + return new OffsetRange(start, endExclusive); + } + static ofLength(length) { + return new OffsetRange(0, length); + } + static ofStartAndLength(start, length) { + return new OffsetRange(start, start + length); + } + constructor(start, endExclusive) { + this.start = start; + this.endExclusive = endExclusive; + if (start > endExclusive) { + throw new _base_common_errors_js__WEBPACK_IMPORTED_MODULE_0__.BugIndicatingError(`Invalid range: ${this.toString()}`); + } + } + get isEmpty() { + return this.start === this.endExclusive; + } + delta(offset) { + return new OffsetRange(this.start + offset, this.endExclusive + offset); + } + deltaStart(offset) { + return new OffsetRange(this.start + offset, this.endExclusive); + } + deltaEnd(offset) { + return new OffsetRange(this.start, this.endExclusive + offset); + } + get length() { + return this.endExclusive - this.start; + } + toString() { + return `[${this.start}, ${this.endExclusive})`; + } + equals(other) { + return this.start === other.start && this.endExclusive === other.endExclusive; + } + containsRange(other) { + return this.start <= other.start && other.endExclusive <= this.endExclusive; + } + contains(offset) { + return this.start <= offset && offset < this.endExclusive; + } + /** + * for all numbers n: range1.contains(n) or range2.contains(n) => range1.join(range2).contains(n) + * The joined range is the smallest range that contains both ranges. + */ + join(other) { + return new OffsetRange(Math.min(this.start, other.start), Math.max(this.endExclusive, other.endExclusive)); + } + /** + * for all numbers n: range1.contains(n) and range2.contains(n) <=> range1.intersect(range2).contains(n) + * + * The resulting range is empty if the ranges do not intersect, but touch. + * If the ranges don't even touch, the result is undefined. + */ + intersect(other) { + const start = Math.max(this.start, other.start); + const end = Math.min(this.endExclusive, other.endExclusive); + if (start <= end) { + return new OffsetRange(start, end); + } + return undefined; + } + isBefore(other) { + return this.endExclusive <= other.start; + } + isAfter(other) { + return this.start >= other.endExclusive; + } + slice(arr) { + return arr.slice(this.start, this.endExclusive); + } + /** + * Returns the given value if it is contained in this instance, otherwise the closest value that is contained. + * The range must not be empty. + */ + clip(value) { + if (this.isEmpty) { + throw new _base_common_errors_js__WEBPACK_IMPORTED_MODULE_0__.BugIndicatingError(`Invalid clipping range: ${this.toString()}`); + } + return Math.max(this.start, Math.min(this.endExclusive - 1, value)); + } + /** + * Returns `r := value + k * length` such that `r` is contained in this range. + * The range must not be empty. + * + * E.g. `[5, 10).clipCyclic(10) === 5`, `[5, 10).clipCyclic(11) === 6` and `[5, 10).clipCyclic(4) === 9`. + */ + clipCyclic(value) { + if (this.isEmpty) { + throw new _base_common_errors_js__WEBPACK_IMPORTED_MODULE_0__.BugIndicatingError(`Invalid clipping range: ${this.toString()}`); + } + if (value < this.start) { + return this.endExclusive - ((this.start - value) % this.length); + } + if (value >= this.endExclusive) { + return this.start + ((value - this.start) % this.length); + } + return value; + } + forEach(f) { + for (let i = this.start; i < this.endExclusive; i++) { + f(i); + } + } +} +class OffsetRangeSet { + constructor() { + this._sortedRanges = []; + } + addRange(range) { + let i = 0; + while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive < range.start) { + i++; + } + let j = i; + while (j < this._sortedRanges.length && this._sortedRanges[j].start <= range.endExclusive) { + j++; + } + if (i === j) { + this._sortedRanges.splice(i, 0, range); + } + else { + const start = Math.min(range.start, this._sortedRanges[i].start); + const end = Math.max(range.endExclusive, this._sortedRanges[j - 1].endExclusive); + this._sortedRanges.splice(i, j - i, new OffsetRange(start, end)); + } + } + toString() { + return this._sortedRanges.map(r => r.toString()).join(', '); + } + /** + * Returns of there is a value that is contained in this instance and the given range. + */ + intersectsStrict(other) { + // TODO use binary search + let i = 0; + while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive <= other.start) { + i++; + } + return i < this._sortedRanges.length && this._sortedRanges[i].start < other.endExclusive; + } + intersectWithRange(other) { + // TODO use binary search + slice + const result = new OffsetRangeSet(); + for (const range of this._sortedRanges) { + const intersection = range.intersect(other); + if (intersection) { + result.addRange(intersection); + } + } + return result; + } + intersectWithRangeLength(other) { + return this.intersectWithRange(other).length; + } + get length() { + return this._sortedRanges.reduce((prev, cur) => prev + cur.length, 0); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js": +/*!**************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/position.js ***! + \**************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Position: () => (/* binding */ Position) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/** + * A position in the editor. + */ +class Position { + constructor(lineNumber, column) { + this.lineNumber = lineNumber; + this.column = column; + } + /** + * Create a new position from this position. + * + * @param newLineNumber new line number + * @param newColumn new column + */ + with(newLineNumber = this.lineNumber, newColumn = this.column) { + if (newLineNumber === this.lineNumber && newColumn === this.column) { + return this; + } + else { + return new Position(newLineNumber, newColumn); + } + } + /** + * Derive a new position from this position. + * + * @param deltaLineNumber line number delta + * @param deltaColumn column delta + */ + delta(deltaLineNumber = 0, deltaColumn = 0) { + return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn); + } + /** + * Test if this position equals other position + */ + equals(other) { + return Position.equals(this, other); + } + /** + * Test if position `a` equals position `b` + */ + static equals(a, b) { + if (!a && !b) { + return true; + } + return (!!a && + !!b && + a.lineNumber === b.lineNumber && + a.column === b.column); + } + /** + * Test if this position is before other position. + * If the two positions are equal, the result will be false. + */ + isBefore(other) { + return Position.isBefore(this, other); + } + /** + * Test if position `a` is before position `b`. + * If the two positions are equal, the result will be false. + */ + static isBefore(a, b) { + if (a.lineNumber < b.lineNumber) { + return true; + } + if (b.lineNumber < a.lineNumber) { + return false; + } + return a.column < b.column; + } + /** + * Test if this position is before other position. + * If the two positions are equal, the result will be true. + */ + isBeforeOrEqual(other) { + return Position.isBeforeOrEqual(this, other); + } + /** + * Test if position `a` is before position `b`. + * If the two positions are equal, the result will be true. + */ + static isBeforeOrEqual(a, b) { + if (a.lineNumber < b.lineNumber) { + return true; + } + if (b.lineNumber < a.lineNumber) { + return false; + } + return a.column <= b.column; + } + /** + * A function that compares positions, useful for sorting + */ + static compare(a, b) { + const aLineNumber = a.lineNumber | 0; + const bLineNumber = b.lineNumber | 0; + if (aLineNumber === bLineNumber) { + const aColumn = a.column | 0; + const bColumn = b.column | 0; + return aColumn - bColumn; + } + return aLineNumber - bLineNumber; + } + /** + * Clone this position. + */ + clone() { + return new Position(this.lineNumber, this.column); + } + /** + * Convert to a human-readable representation. + */ + toString() { + return '(' + this.lineNumber + ',' + this.column + ')'; + } + // --- + /** + * Create a `Position` from an `IPosition`. + */ + static lift(pos) { + return new Position(pos.lineNumber, pos.column); + } + /** + * Test if `obj` is an `IPosition`. + */ + static isIPosition(obj) { + return (obj + && (typeof obj.lineNumber === 'number') + && (typeof obj.column === 'number')); + } + toJSON() { + return { + lineNumber: this.lineNumber, + column: this.column + }; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js": +/*!***********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/range.js ***! + \***********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Range: () => (/* binding */ Range) +/* harmony export */ }); +/* harmony import */ var _position_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./position.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn) + */ +class Range { + constructor(startLineNumber, startColumn, endLineNumber, endColumn) { + if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) { + this.startLineNumber = endLineNumber; + this.startColumn = endColumn; + this.endLineNumber = startLineNumber; + this.endColumn = startColumn; + } + else { + this.startLineNumber = startLineNumber; + this.startColumn = startColumn; + this.endLineNumber = endLineNumber; + this.endColumn = endColumn; + } + } + /** + * Test if this range is empty. + */ + isEmpty() { + return Range.isEmpty(this); + } + /** + * Test if `range` is empty. + */ + static isEmpty(range) { + return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn); + } + /** + * Test if position is in this range. If the position is at the edges, will return true. + */ + containsPosition(position) { + return Range.containsPosition(this, position); + } + /** + * Test if `position` is in `range`. If the position is at the edges, will return true. + */ + static containsPosition(range, position) { + if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) { + return false; + } + if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) { + return false; + } + if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) { + return false; + } + return true; + } + /** + * Test if `position` is in `range`. If the position is at the edges, will return false. + * @internal + */ + static strictContainsPosition(range, position) { + if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) { + return false; + } + if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) { + return false; + } + if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) { + return false; + } + return true; + } + /** + * Test if range is in this range. If the range is equal to this range, will return true. + */ + containsRange(range) { + return Range.containsRange(this, range); + } + /** + * Test if `otherRange` is in `range`. If the ranges are equal, will return true. + */ + static containsRange(range, otherRange) { + if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) { + return false; + } + if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) { + return false; + } + if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) { + return false; + } + if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) { + return false; + } + return true; + } + /** + * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true. + */ + strictContainsRange(range) { + return Range.strictContainsRange(this, range); + } + /** + * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false. + */ + static strictContainsRange(range, otherRange) { + if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) { + return false; + } + if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) { + return false; + } + if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) { + return false; + } + if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) { + return false; + } + return true; + } + /** + * A reunion of the two ranges. + * The smallest position will be used as the start point, and the largest one as the end point. + */ + plusRange(range) { + return Range.plusRange(this, range); + } + /** + * A reunion of the two ranges. + * The smallest position will be used as the start point, and the largest one as the end point. + */ + static plusRange(a, b) { + let startLineNumber; + let startColumn; + let endLineNumber; + let endColumn; + if (b.startLineNumber < a.startLineNumber) { + startLineNumber = b.startLineNumber; + startColumn = b.startColumn; + } + else if (b.startLineNumber === a.startLineNumber) { + startLineNumber = b.startLineNumber; + startColumn = Math.min(b.startColumn, a.startColumn); + } + else { + startLineNumber = a.startLineNumber; + startColumn = a.startColumn; + } + if (b.endLineNumber > a.endLineNumber) { + endLineNumber = b.endLineNumber; + endColumn = b.endColumn; + } + else if (b.endLineNumber === a.endLineNumber) { + endLineNumber = b.endLineNumber; + endColumn = Math.max(b.endColumn, a.endColumn); + } + else { + endLineNumber = a.endLineNumber; + endColumn = a.endColumn; + } + return new Range(startLineNumber, startColumn, endLineNumber, endColumn); + } + /** + * A intersection of the two ranges. + */ + intersectRanges(range) { + return Range.intersectRanges(this, range); + } + /** + * A intersection of the two ranges. + */ + static intersectRanges(a, b) { + let resultStartLineNumber = a.startLineNumber; + let resultStartColumn = a.startColumn; + let resultEndLineNumber = a.endLineNumber; + let resultEndColumn = a.endColumn; + const otherStartLineNumber = b.startLineNumber; + const otherStartColumn = b.startColumn; + const otherEndLineNumber = b.endLineNumber; + const otherEndColumn = b.endColumn; + if (resultStartLineNumber < otherStartLineNumber) { + resultStartLineNumber = otherStartLineNumber; + resultStartColumn = otherStartColumn; + } + else if (resultStartLineNumber === otherStartLineNumber) { + resultStartColumn = Math.max(resultStartColumn, otherStartColumn); + } + if (resultEndLineNumber > otherEndLineNumber) { + resultEndLineNumber = otherEndLineNumber; + resultEndColumn = otherEndColumn; + } + else if (resultEndLineNumber === otherEndLineNumber) { + resultEndColumn = Math.min(resultEndColumn, otherEndColumn); + } + // Check if selection is now empty + if (resultStartLineNumber > resultEndLineNumber) { + return null; + } + if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) { + return null; + } + return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn); + } + /** + * Test if this range equals other. + */ + equalsRange(other) { + return Range.equalsRange(this, other); + } + /** + * Test if range `a` equals `b`. + */ + static equalsRange(a, b) { + if (!a && !b) { + return true; + } + return (!!a && + !!b && + a.startLineNumber === b.startLineNumber && + a.startColumn === b.startColumn && + a.endLineNumber === b.endLineNumber && + a.endColumn === b.endColumn); + } + /** + * Return the end position (which will be after or equal to the start position) + */ + getEndPosition() { + return Range.getEndPosition(this); + } + /** + * Return the end position (which will be after or equal to the start position) + */ + static getEndPosition(range) { + return new _position_js__WEBPACK_IMPORTED_MODULE_0__.Position(range.endLineNumber, range.endColumn); + } + /** + * Return the start position (which will be before or equal to the end position) + */ + getStartPosition() { + return Range.getStartPosition(this); + } + /** + * Return the start position (which will be before or equal to the end position) + */ + static getStartPosition(range) { + return new _position_js__WEBPACK_IMPORTED_MODULE_0__.Position(range.startLineNumber, range.startColumn); + } + /** + * Transform to a user presentable string representation. + */ + toString() { + return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']'; + } + /** + * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position. + */ + setEndPosition(endLineNumber, endColumn) { + return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn); + } + /** + * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position. + */ + setStartPosition(startLineNumber, startColumn) { + return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn); + } + /** + * Create a new empty range using this range's start position. + */ + collapseToStart() { + return Range.collapseToStart(this); + } + /** + * Create a new empty range using this range's start position. + */ + static collapseToStart(range) { + return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn); + } + /** + * Create a new empty range using this range's end position. + */ + collapseToEnd() { + return Range.collapseToEnd(this); + } + /** + * Create a new empty range using this range's end position. + */ + static collapseToEnd(range) { + return new Range(range.endLineNumber, range.endColumn, range.endLineNumber, range.endColumn); + } + /** + * Moves the range by the given amount of lines. + */ + delta(lineCount) { + return new Range(this.startLineNumber + lineCount, this.startColumn, this.endLineNumber + lineCount, this.endColumn); + } + // --- + static fromPositions(start, end = start) { + return new Range(start.lineNumber, start.column, end.lineNumber, end.column); + } + static lift(range) { + if (!range) { + return null; + } + return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn); + } + /** + * Test if `obj` is an `IRange`. + */ + static isIRange(obj) { + return (obj + && (typeof obj.startLineNumber === 'number') + && (typeof obj.startColumn === 'number') + && (typeof obj.endLineNumber === 'number') + && (typeof obj.endColumn === 'number')); + } + /** + * Test if the two ranges are touching in any way. + */ + static areIntersectingOrTouching(a, b) { + // Check if `a` is before `b` + if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) { + return false; + } + // Check if `b` is before `a` + if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) { + return false; + } + // These ranges must intersect + return true; + } + /** + * Test if the two ranges are intersecting. If the ranges are touching it returns true. + */ + static areIntersecting(a, b) { + // Check if `a` is before `b` + if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) { + return false; + } + // Check if `b` is before `a` + if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) { + return false; + } + // These ranges must intersect + return true; + } + /** + * A function that compares ranges, useful for sorting ranges + * It will first compare ranges on the startPosition and then on the endPosition + */ + static compareRangesUsingStarts(a, b) { + if (a && b) { + const aStartLineNumber = a.startLineNumber | 0; + const bStartLineNumber = b.startLineNumber | 0; + if (aStartLineNumber === bStartLineNumber) { + const aStartColumn = a.startColumn | 0; + const bStartColumn = b.startColumn | 0; + if (aStartColumn === bStartColumn) { + const aEndLineNumber = a.endLineNumber | 0; + const bEndLineNumber = b.endLineNumber | 0; + if (aEndLineNumber === bEndLineNumber) { + const aEndColumn = a.endColumn | 0; + const bEndColumn = b.endColumn | 0; + return aEndColumn - bEndColumn; + } + return aEndLineNumber - bEndLineNumber; + } + return aStartColumn - bStartColumn; + } + return aStartLineNumber - bStartLineNumber; + } + const aExists = (a ? 1 : 0); + const bExists = (b ? 1 : 0); + return aExists - bExists; + } + /** + * A function that compares ranges, useful for sorting ranges + * It will first compare ranges on the endPosition and then on the startPosition + */ + static compareRangesUsingEnds(a, b) { + if (a.endLineNumber === b.endLineNumber) { + if (a.endColumn === b.endColumn) { + if (a.startLineNumber === b.startLineNumber) { + return a.startColumn - b.startColumn; + } + return a.startLineNumber - b.startLineNumber; + } + return a.endColumn - b.endColumn; + } + return a.endLineNumber - b.endLineNumber; + } + /** + * Test if the range spans multiple lines. + */ + static spansMultipleLines(range) { + return range.endLineNumber > range.startLineNumber; + } + toJSON() { + return this; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/selection.js": +/*!***************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/selection.js ***! + \***************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Selection: () => (/* binding */ Selection) +/* harmony export */ }); +/* harmony import */ var _position_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./position.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js"); +/* harmony import */ var _range_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +/** + * A selection in the editor. + * The selection is a range that has an orientation. + */ +class Selection extends _range_js__WEBPACK_IMPORTED_MODULE_1__.Range { + constructor(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) { + super(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn); + this.selectionStartLineNumber = selectionStartLineNumber; + this.selectionStartColumn = selectionStartColumn; + this.positionLineNumber = positionLineNumber; + this.positionColumn = positionColumn; + } + /** + * Transform to a human-readable representation. + */ + toString() { + return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']'; + } + /** + * Test if equals other selection. + */ + equalsSelection(other) { + return (Selection.selectionsEqual(this, other)); + } + /** + * Test if the two selections are equal. + */ + static selectionsEqual(a, b) { + return (a.selectionStartLineNumber === b.selectionStartLineNumber && + a.selectionStartColumn === b.selectionStartColumn && + a.positionLineNumber === b.positionLineNumber && + a.positionColumn === b.positionColumn); + } + /** + * Get directions (LTR or RTL). + */ + getDirection() { + if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) { + return 0 /* SelectionDirection.LTR */; + } + return 1 /* SelectionDirection.RTL */; + } + /** + * Create a new selection with a different `positionLineNumber` and `positionColumn`. + */ + setEndPosition(endLineNumber, endColumn) { + if (this.getDirection() === 0 /* SelectionDirection.LTR */) { + return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn); + } + return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn); + } + /** + * Get the position at `positionLineNumber` and `positionColumn`. + */ + getPosition() { + return new _position_js__WEBPACK_IMPORTED_MODULE_0__.Position(this.positionLineNumber, this.positionColumn); + } + /** + * Get the position at the start of the selection. + */ + getSelectionStart() { + return new _position_js__WEBPACK_IMPORTED_MODULE_0__.Position(this.selectionStartLineNumber, this.selectionStartColumn); + } + /** + * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`. + */ + setStartPosition(startLineNumber, startColumn) { + if (this.getDirection() === 0 /* SelectionDirection.LTR */) { + return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn); + } + return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn); + } + // ---- + /** + * Create a `Selection` from one or two positions + */ + static fromPositions(start, end = start) { + return new Selection(start.lineNumber, start.column, end.lineNumber, end.column); + } + /** + * Creates a `Selection` from a range, given a direction. + */ + static fromRange(range, direction) { + if (direction === 0 /* SelectionDirection.LTR */) { + return new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn); + } + else { + return new Selection(range.endLineNumber, range.endColumn, range.startLineNumber, range.startColumn); + } + } + /** + * Create a `Selection` from an `ISelection`. + */ + static liftSelection(sel) { + return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn); + } + /** + * `a` equals `b`. + */ + static selectionsArrEqual(a, b) { + if (a && !b || !a && b) { + return false; + } + if (!a && !b) { + return true; + } + if (a.length !== b.length) { + return false; + } + for (let i = 0, len = a.length; i < len; i++) { + if (!this.selectionsEqual(a[i], b[i])) { + return false; + } + } + return true; + } + /** + * Test if `obj` is an `ISelection`. + */ + static isISelection(obj) { + return (obj + && (typeof obj.selectionStartLineNumber === 'number') + && (typeof obj.selectionStartColumn === 'number') + && (typeof obj.positionLineNumber === 'number') + && (typeof obj.positionColumn === 'number')); + } + /** + * Create with a direction. + */ + static createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) { + if (direction === 0 /* SelectionDirection.LTR */) { + return new Selection(startLineNumber, startColumn, endLineNumber, endColumn); + } + return new Selection(endLineNumber, endColumn, startLineNumber, startColumn); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/wordCharacterClassifier.js": +/*!*****************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/wordCharacterClassifier.js ***! + \*****************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ WordCharacterClassifier: () => (/* binding */ WordCharacterClassifier), +/* harmony export */ getMapForWordSeparators: () => (/* binding */ getMapForWordSeparators) +/* harmony export */ }); +/* harmony import */ var _characterClassifier_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./characterClassifier.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +class WordCharacterClassifier extends _characterClassifier_js__WEBPACK_IMPORTED_MODULE_0__.CharacterClassifier { + constructor(wordSeparators) { + super(0 /* WordCharacterClass.Regular */); + for (let i = 0, len = wordSeparators.length; i < len; i++) { + this.set(wordSeparators.charCodeAt(i), 2 /* WordCharacterClass.WordSeparator */); + } + this.set(32 /* CharCode.Space */, 1 /* WordCharacterClass.Whitespace */); + this.set(9 /* CharCode.Tab */, 1 /* WordCharacterClass.Whitespace */); + } +} +function once(computeFn) { + const cache = {}; // TODO@Alex unbounded cache + return (input) => { + if (!cache.hasOwnProperty(input)) { + cache[input] = computeFn(input); + } + return cache[input]; + }; +} +const getMapForWordSeparators = once((input) => new WordCharacterClassifier(input)); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/core/wordHelper.js": +/*!****************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/core/wordHelper.js ***! + \****************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DEFAULT_WORD_REGEXP: () => (/* binding */ DEFAULT_WORD_REGEXP), +/* harmony export */ USUAL_WORD_SEPARATORS: () => (/* binding */ USUAL_WORD_SEPARATORS), +/* harmony export */ ensureValidWordDefinition: () => (/* binding */ ensureValidWordDefinition), +/* harmony export */ getWordAtText: () => (/* binding */ getWordAtText) +/* harmony export */ }); +/* harmony import */ var _base_common_iterator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/iterator.js */ "./node_modules/monaco-editor/esm/vs/base/common/iterator.js"); +/* harmony import */ var _base_common_linkedList_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../base/common/linkedList.js */ "./node_modules/monaco-editor/esm/vs/base/common/linkedList.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?'; +/** + * Create a word definition regular expression based on default word separators. + * Optionally provide allowed separators that should be included in words. + * + * The default would look like this: + * /(-?\d*\.\d\w*)|([^\`\~\!\@\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g + */ +function createWordRegExp(allowInWords = '') { + let source = '(-?\\d*\\.\\d\\w*)|([^'; + for (const sep of USUAL_WORD_SEPARATORS) { + if (allowInWords.indexOf(sep) >= 0) { + continue; + } + source += '\\' + sep; + } + source += '\\s]+)'; + return new RegExp(source, 'g'); +} +// catches numbers (including floating numbers) in the first group, and alphanum in the second +const DEFAULT_WORD_REGEXP = createWordRegExp(); +function ensureValidWordDefinition(wordDefinition) { + let result = DEFAULT_WORD_REGEXP; + if (wordDefinition && (wordDefinition instanceof RegExp)) { + if (!wordDefinition.global) { + let flags = 'g'; + if (wordDefinition.ignoreCase) { + flags += 'i'; + } + if (wordDefinition.multiline) { + flags += 'm'; + } + if (wordDefinition.unicode) { + flags += 'u'; + } + result = new RegExp(wordDefinition.source, flags); + } + else { + result = wordDefinition; + } + } + result.lastIndex = 0; + return result; +} +const _defaultConfig = new _base_common_linkedList_js__WEBPACK_IMPORTED_MODULE_1__.LinkedList(); +_defaultConfig.unshift({ + maxLen: 1000, + windowSize: 15, + timeBudget: 150 +}); +function getWordAtText(column, wordDefinition, text, textOffset, config) { + // Ensure the regex has the 'g' flag, otherwise this will loop forever + wordDefinition = ensureValidWordDefinition(wordDefinition); + if (!config) { + config = _base_common_iterator_js__WEBPACK_IMPORTED_MODULE_0__.Iterable.first(_defaultConfig); + } + if (text.length > config.maxLen) { + // don't throw strings that long at the regexp + // but use a sub-string in which a word must occur + let start = column - config.maxLen / 2; + if (start < 0) { + start = 0; + } + else { + textOffset += start; + } + text = text.substring(start, column + config.maxLen / 2); + return getWordAtText(column, wordDefinition, text, textOffset, config); + } + const t1 = Date.now(); + const pos = column - 1 - textOffset; + let prevRegexIndex = -1; + let match = null; + for (let i = 1;; i++) { + // check time budget + if (Date.now() - t1 >= config.timeBudget) { + break; + } + // reset the index at which the regexp should start matching, also know where it + // should stop so that subsequent search don't repeat previous searches + const regexIndex = pos - config.windowSize * i; + wordDefinition.lastIndex = Math.max(0, regexIndex); + const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex); + if (!thisMatch && match) { + // stop: we have something + break; + } + match = thisMatch; + // stop: searched at start + if (regexIndex <= 0) { + break; + } + prevRegexIndex = regexIndex; + } + if (match) { + const result = { + word: match[0], + startColumn: textOffset + 1 + match.index, + endColumn: textOffset + 1 + match.index + match[0].length + }; + wordDefinition.lastIndex = 0; + return result; + } + return null; +} +function _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) { + let match; + while (match = wordDefinition.exec(text)) { + const matchIndex = match.index || 0; + if (matchIndex <= pos && wordDefinition.lastIndex >= pos) { + return match; + } + else if (stopPos > 0 && matchIndex > stopPos) { + return null; + } + } + return null; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js": +/*!*******************************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js ***! + \*******************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DateTimeout: () => (/* binding */ DateTimeout), +/* harmony export */ DiffAlgorithmResult: () => (/* binding */ DiffAlgorithmResult), +/* harmony export */ InfiniteTimeout: () => (/* binding */ InfiniteTimeout), +/* harmony export */ OffsetPair: () => (/* binding */ OffsetPair), +/* harmony export */ SequenceDiff: () => (/* binding */ SequenceDiff) +/* harmony export */ }); +/* harmony import */ var _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../base/common/arrays.js */ "./node_modules/monaco-editor/esm/vs/base/common/arrays.js"); +/* harmony import */ var _base_common_errors_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../base/common/errors.js */ "./node_modules/monaco-editor/esm/vs/base/common/errors.js"); +/* harmony import */ var _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../core/offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + +class DiffAlgorithmResult { + static trivial(seq1, seq2) { + return new DiffAlgorithmResult([new SequenceDiff(_core_offsetRange_js__WEBPACK_IMPORTED_MODULE_2__.OffsetRange.ofLength(seq1.length), _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_2__.OffsetRange.ofLength(seq2.length))], false); + } + static trivialTimedOut(seq1, seq2) { + return new DiffAlgorithmResult([new SequenceDiff(_core_offsetRange_js__WEBPACK_IMPORTED_MODULE_2__.OffsetRange.ofLength(seq1.length), _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_2__.OffsetRange.ofLength(seq2.length))], true); + } + constructor(diffs, + /** + * Indicates if the time out was reached. + * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time. + */ + hitTimeout) { + this.diffs = diffs; + this.hitTimeout = hitTimeout; + } +} +class SequenceDiff { + static invert(sequenceDiffs, doc1Length) { + const result = []; + (0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__.forEachAdjacent)(sequenceDiffs, (a, b) => { + result.push(SequenceDiff.fromOffsetPairs(a ? a.getEndExclusives() : OffsetPair.zero, b ? b.getStarts() : new OffsetPair(doc1Length, (a ? a.seq2Range.endExclusive - a.seq1Range.endExclusive : 0) + doc1Length))); + }); + return result; + } + static fromOffsetPairs(start, endExclusive) { + return new SequenceDiff(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_2__.OffsetRange(start.offset1, endExclusive.offset1), new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_2__.OffsetRange(start.offset2, endExclusive.offset2)); + } + constructor(seq1Range, seq2Range) { + this.seq1Range = seq1Range; + this.seq2Range = seq2Range; + } + swap() { + return new SequenceDiff(this.seq2Range, this.seq1Range); + } + toString() { + return `${this.seq1Range} <-> ${this.seq2Range}`; + } + join(other) { + return new SequenceDiff(this.seq1Range.join(other.seq1Range), this.seq2Range.join(other.seq2Range)); + } + delta(offset) { + if (offset === 0) { + return this; + } + return new SequenceDiff(this.seq1Range.delta(offset), this.seq2Range.delta(offset)); + } + deltaStart(offset) { + if (offset === 0) { + return this; + } + return new SequenceDiff(this.seq1Range.deltaStart(offset), this.seq2Range.deltaStart(offset)); + } + deltaEnd(offset) { + if (offset === 0) { + return this; + } + return new SequenceDiff(this.seq1Range.deltaEnd(offset), this.seq2Range.deltaEnd(offset)); + } + intersect(other) { + const i1 = this.seq1Range.intersect(other.seq1Range); + const i2 = this.seq2Range.intersect(other.seq2Range); + if (!i1 || !i2) { + return undefined; + } + return new SequenceDiff(i1, i2); + } + getStarts() { + return new OffsetPair(this.seq1Range.start, this.seq2Range.start); + } + getEndExclusives() { + return new OffsetPair(this.seq1Range.endExclusive, this.seq2Range.endExclusive); + } +} +class OffsetPair { + constructor(offset1, offset2) { + this.offset1 = offset1; + this.offset2 = offset2; + } + toString() { + return `${this.offset1} <-> ${this.offset2}`; + } +} +OffsetPair.zero = new OffsetPair(0, 0); +OffsetPair.max = new OffsetPair(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); +class InfiniteTimeout { + isValid() { + return true; + } +} +InfiniteTimeout.instance = new InfiniteTimeout(); +class DateTimeout { + constructor(timeout) { + this.timeout = timeout; + this.startTime = Date.now(); + this.valid = true; + if (timeout <= 0) { + throw new _base_common_errors_js__WEBPACK_IMPORTED_MODULE_1__.BugIndicatingError('timeout must be positive'); + } + } + // Recommendation: Set a log-point `{this.disable()}` in the body + isValid() { + const valid = Date.now() - this.startTime < this.timeout; + if (!valid && this.valid) { + this.valid = false; // timeout reached + // eslint-disable-next-line no-debugger + debugger; // WARNING: Most likely debugging caused the timeout. Call `this.disable()` to continue without timing out. + } + return this.valid; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.js": +/*!*******************************************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.js ***! + \*******************************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DynamicProgrammingDiffing: () => (/* binding */ DynamicProgrammingDiffing) +/* harmony export */ }); +/* harmony import */ var _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../core/offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/* harmony import */ var _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./diffAlgorithm.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js"); +/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/utils.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + +/** + * A O(MN) diffing algorithm that supports a score function. + * The algorithm can be improved by processing the 2d array diagonally. +*/ +class DynamicProgrammingDiffing { + compute(sequence1, sequence2, timeout = _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.InfiniteTimeout.instance, equalityScore) { + if (sequence1.length === 0 || sequence2.length === 0) { + return _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.DiffAlgorithmResult.trivial(sequence1, sequence2); + } + /** + * lcsLengths.get(i, j): Length of the longest common subsequence of sequence1.substring(0, i + 1) and sequence2.substring(0, j + 1). + */ + const lcsLengths = new _utils_js__WEBPACK_IMPORTED_MODULE_2__.Array2D(sequence1.length, sequence2.length); + const directions = new _utils_js__WEBPACK_IMPORTED_MODULE_2__.Array2D(sequence1.length, sequence2.length); + const lengths = new _utils_js__WEBPACK_IMPORTED_MODULE_2__.Array2D(sequence1.length, sequence2.length); + // ==== Initializing lcsLengths ==== + for (let s1 = 0; s1 < sequence1.length; s1++) { + for (let s2 = 0; s2 < sequence2.length; s2++) { + if (!timeout.isValid()) { + return _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.DiffAlgorithmResult.trivialTimedOut(sequence1, sequence2); + } + const horizontalLen = s1 === 0 ? 0 : lcsLengths.get(s1 - 1, s2); + const verticalLen = s2 === 0 ? 0 : lcsLengths.get(s1, s2 - 1); + let extendedSeqScore; + if (sequence1.getElement(s1) === sequence2.getElement(s2)) { + if (s1 === 0 || s2 === 0) { + extendedSeqScore = 0; + } + else { + extendedSeqScore = lcsLengths.get(s1 - 1, s2 - 1); + } + if (s1 > 0 && s2 > 0 && directions.get(s1 - 1, s2 - 1) === 3) { + // Prefer consecutive diagonals + extendedSeqScore += lengths.get(s1 - 1, s2 - 1); + } + extendedSeqScore += (equalityScore ? equalityScore(s1, s2) : 1); + } + else { + extendedSeqScore = -1; + } + const newValue = Math.max(horizontalLen, verticalLen, extendedSeqScore); + if (newValue === extendedSeqScore) { + // Prefer diagonals + const prevLen = s1 > 0 && s2 > 0 ? lengths.get(s1 - 1, s2 - 1) : 0; + lengths.set(s1, s2, prevLen + 1); + directions.set(s1, s2, 3); + } + else if (newValue === horizontalLen) { + lengths.set(s1, s2, 0); + directions.set(s1, s2, 1); + } + else if (newValue === verticalLen) { + lengths.set(s1, s2, 0); + directions.set(s1, s2, 2); + } + lcsLengths.set(s1, s2, newValue); + } + } + // ==== Backtracking ==== + const result = []; + let lastAligningPosS1 = sequence1.length; + let lastAligningPosS2 = sequence2.length; + function reportDecreasingAligningPositions(s1, s2) { + if (s1 + 1 !== lastAligningPosS1 || s2 + 1 !== lastAligningPosS2) { + result.push(new _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.SequenceDiff(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_0__.OffsetRange(s1 + 1, lastAligningPosS1), new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_0__.OffsetRange(s2 + 1, lastAligningPosS2))); + } + lastAligningPosS1 = s1; + lastAligningPosS2 = s2; + } + let s1 = sequence1.length - 1; + let s2 = sequence2.length - 1; + while (s1 >= 0 && s2 >= 0) { + if (directions.get(s1, s2) === 3) { + reportDecreasingAligningPositions(s1, s2); + s1--; + s2--; + } + else { + if (directions.get(s1, s2) === 1) { + s1--; + } + else { + s2--; + } + } + } + reportDecreasingAligningPositions(-1, -1); + result.reverse(); + return new _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.DiffAlgorithmResult(result, false); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.js": +/*!************************************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.js ***! + \************************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ MyersDiffAlgorithm: () => (/* binding */ MyersDiffAlgorithm) +/* harmony export */ }); +/* harmony import */ var _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../core/offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/* harmony import */ var _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./diffAlgorithm.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +/** + * An O(ND) diff algorithm that has a quadratic space worst-case complexity. +*/ +class MyersDiffAlgorithm { + compute(seq1, seq2, timeout = _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.InfiniteTimeout.instance) { + // These are common special cases. + // The early return improves performance dramatically. + if (seq1.length === 0 || seq2.length === 0) { + return _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.DiffAlgorithmResult.trivial(seq1, seq2); + } + const seqX = seq1; // Text on the x axis + const seqY = seq2; // Text on the y axis + function getXAfterSnake(x, y) { + while (x < seqX.length && y < seqY.length && seqX.getElement(x) === seqY.getElement(y)) { + x++; + y++; + } + return x; + } + let d = 0; + // V[k]: X value of longest d-line that ends in diagonal k. + // d-line: path from (0,0) to (x,y) that uses exactly d non-diagonals. + // diagonal k: Set of points (x,y) with x-y = k. + // k=1 -> (1,0),(2,1) + const V = new FastInt32Array(); + V.set(0, getXAfterSnake(0, 0)); + const paths = new FastArrayNegativeIndices(); + paths.set(0, V.get(0) === 0 ? null : new SnakePath(null, 0, 0, V.get(0))); + let k = 0; + loop: while (true) { + d++; + if (!timeout.isValid()) { + return _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.DiffAlgorithmResult.trivialTimedOut(seqX, seqY); + } + // The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result. + const lowerBound = -Math.min(d, seqY.length + (d % 2)); + const upperBound = Math.min(d, seqX.length + (d % 2)); + for (k = lowerBound; k <= upperBound; k += 2) { + let step = 0; + // We can use the X values of (d-1)-lines to compute X value of the longest d-lines. + const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // We take a vertical non-diagonal (add a symbol in seqX) + const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x) (delete a symbol in seqX) + step++; + const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seqX.length); + const y = x - k; + step++; + if (x > seqX.length || y > seqY.length) { + // This diagonal is irrelevant for the result. + // TODO: Don't pay the cost for this in the next iteration. + continue; + } + const newMaxX = getXAfterSnake(x, y); + V.set(k, newMaxX); + const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1); + paths.set(k, newMaxX !== x ? new SnakePath(lastPath, x, y, newMaxX - x) : lastPath); + if (V.get(k) === seqX.length && V.get(k) - k === seqY.length) { + break loop; + } + } + } + let path = paths.get(k); + const result = []; + let lastAligningPosS1 = seqX.length; + let lastAligningPosS2 = seqY.length; + while (true) { + const endX = path ? path.x + path.length : 0; + const endY = path ? path.y + path.length : 0; + if (endX !== lastAligningPosS1 || endY !== lastAligningPosS2) { + result.push(new _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.SequenceDiff(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_0__.OffsetRange(endX, lastAligningPosS1), new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_0__.OffsetRange(endY, lastAligningPosS2))); + } + if (!path) { + break; + } + lastAligningPosS1 = path.x; + lastAligningPosS2 = path.y; + path = path.prev; + } + result.reverse(); + return new _diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_1__.DiffAlgorithmResult(result, false); + } +} +class SnakePath { + constructor(prev, x, y, length) { + this.prev = prev; + this.x = x; + this.y = y; + this.length = length; + } +} +/** + * An array that supports fast negative indices. +*/ +class FastInt32Array { + constructor() { + this.positiveArr = new Int32Array(10); + this.negativeArr = new Int32Array(10); + } + get(idx) { + if (idx < 0) { + idx = -idx - 1; + return this.negativeArr[idx]; + } + else { + return this.positiveArr[idx]; + } + } + set(idx, value) { + if (idx < 0) { + idx = -idx - 1; + if (idx >= this.negativeArr.length) { + const arr = this.negativeArr; + this.negativeArr = new Int32Array(arr.length * 2); + this.negativeArr.set(arr); + } + this.negativeArr[idx] = value; + } + else { + if (idx >= this.positiveArr.length) { + const arr = this.positiveArr; + this.positiveArr = new Int32Array(arr.length * 2); + this.positiveArr.set(arr); + } + this.positiveArr[idx] = value; + } + } +} +/** + * An array that supports fast negative indices. +*/ +class FastArrayNegativeIndices { + constructor() { + this.positiveArr = []; + this.negativeArr = []; + } + get(idx) { + if (idx < 0) { + idx = -idx - 1; + return this.negativeArr[idx]; + } + else { + return this.positiveArr[idx]; + } + } + set(idx, value) { + if (idx < 0) { + idx = -idx - 1; + this.negativeArr[idx] = value; + } + else { + this.positiveArr[idx] = value; + } + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/computeMovedLines.js": +/*!************************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/computeMovedLines.js ***! + \************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ computeMovedLines: () => (/* binding */ computeMovedLines) +/* harmony export */ }); +/* harmony import */ var _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./algorithms/diffAlgorithm.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js"); +/* harmony import */ var _rangeMapping_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../rangeMapping.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/rangeMapping.js"); +/* harmony import */ var _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../../base/common/arrays.js */ "./node_modules/monaco-editor/esm/vs/base/common/arrays.js"); +/* harmony import */ var _base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../../base/common/arraysFind.js */ "./node_modules/monaco-editor/esm/vs/base/common/arraysFind.js"); +/* harmony import */ var _base_common_map_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../../../base/common/map.js */ "./node_modules/monaco-editor/esm/vs/base/common/map.js"); +/* harmony import */ var _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../core/lineRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js"); +/* harmony import */ var _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../../core/offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/* harmony import */ var _linesSliceCharSequence_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./linesSliceCharSequence.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js"); +/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./utils.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/utils.js"); +/* harmony import */ var _algorithms_myersDiffAlgorithm_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./algorithms/myersDiffAlgorithm.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + + + + + + +function computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout) { + let { moves, excludedChanges } = computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout); + if (!timeout.isValid()) { + return []; + } + const filteredChanges = changes.filter(c => !excludedChanges.has(c)); + const unchangedMoves = computeUnchangedMoves(filteredChanges, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout); + (0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.pushMany)(moves, unchangedMoves); + moves = joinCloseConsecutiveMoves(moves); + // Ignore too short moves + moves = moves.filter(current => { + const lines = current.original.toOffsetRange().slice(originalLines).map(l => l.trim()); + const originalText = lines.join('\n'); + return originalText.length >= 15 && countWhere(lines, l => l.length >= 2) >= 2; + }); + moves = removeMovesInSameDiff(changes, moves); + return moves; +} +function countWhere(arr, predicate) { + let count = 0; + for (const t of arr) { + if (predicate(t)) { + count++; + } + } + return count; +} +function computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout) { + const moves = []; + const deletions = changes + .filter(c => c.modified.isEmpty && c.original.length >= 3) + .map(d => new _utils_js__WEBPACK_IMPORTED_MODULE_8__.LineRangeFragment(d.original, originalLines, d)); + const insertions = new Set(changes + .filter(c => c.original.isEmpty && c.modified.length >= 3) + .map(d => new _utils_js__WEBPACK_IMPORTED_MODULE_8__.LineRangeFragment(d.modified, modifiedLines, d))); + const excludedChanges = new Set(); + for (const deletion of deletions) { + let highestSimilarity = -1; + let best; + for (const insertion of insertions) { + const similarity = deletion.computeSimilarity(insertion); + if (similarity > highestSimilarity) { + highestSimilarity = similarity; + best = insertion; + } + } + if (highestSimilarity > 0.90 && best) { + insertions.delete(best); + moves.push(new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_1__.LineRangeMapping(deletion.range, best.range)); + excludedChanges.add(deletion.source); + excludedChanges.add(best.source); + } + if (!timeout.isValid()) { + return { moves, excludedChanges }; + } + } + return { moves, excludedChanges }; +} +function computeUnchangedMoves(changes, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout) { + const moves = []; + const original3LineHashes = new _base_common_map_js__WEBPACK_IMPORTED_MODULE_4__.SetMap(); + for (const change of changes) { + for (let i = change.original.startLineNumber; i < change.original.endLineNumberExclusive - 2; i++) { + const key = `${hashedOriginalLines[i - 1]}:${hashedOriginalLines[i + 1 - 1]}:${hashedOriginalLines[i + 2 - 1]}`; + original3LineHashes.add(key, { range: new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(i, i + 3) }); + } + } + const possibleMappings = []; + changes.sort((0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.compareBy)(c => c.modified.startLineNumber, _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.numberComparator)); + for (const change of changes) { + let lastMappings = []; + for (let i = change.modified.startLineNumber; i < change.modified.endLineNumberExclusive - 2; i++) { + const key = `${hashedModifiedLines[i - 1]}:${hashedModifiedLines[i + 1 - 1]}:${hashedModifiedLines[i + 2 - 1]}`; + const currentModifiedRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(i, i + 3); + const nextMappings = []; + original3LineHashes.forEach(key, ({ range }) => { + for (const lastMapping of lastMappings) { + // does this match extend some last match? + if (lastMapping.originalLineRange.endLineNumberExclusive + 1 === range.endLineNumberExclusive && + lastMapping.modifiedLineRange.endLineNumberExclusive + 1 === currentModifiedRange.endLineNumberExclusive) { + lastMapping.originalLineRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(lastMapping.originalLineRange.startLineNumber, range.endLineNumberExclusive); + lastMapping.modifiedLineRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(lastMapping.modifiedLineRange.startLineNumber, currentModifiedRange.endLineNumberExclusive); + nextMappings.push(lastMapping); + return; + } + } + const mapping = { + modifiedLineRange: currentModifiedRange, + originalLineRange: range, + }; + possibleMappings.push(mapping); + nextMappings.push(mapping); + }); + lastMappings = nextMappings; + } + if (!timeout.isValid()) { + return []; + } + } + possibleMappings.sort((0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.reverseOrder)((0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.compareBy)(m => m.modifiedLineRange.length, _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.numberComparator))); + const modifiedSet = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRangeSet(); + const originalSet = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRangeSet(); + for (const mapping of possibleMappings) { + const diffOrigToMod = mapping.modifiedLineRange.startLineNumber - mapping.originalLineRange.startLineNumber; + const modifiedSections = modifiedSet.subtractFrom(mapping.modifiedLineRange); + const originalTranslatedSections = originalSet.subtractFrom(mapping.originalLineRange).getWithDelta(diffOrigToMod); + const modifiedIntersectedSections = modifiedSections.getIntersection(originalTranslatedSections); + for (const s of modifiedIntersectedSections.ranges) { + if (s.length < 3) { + continue; + } + const modifiedLineRange = s; + const originalLineRange = s.delta(-diffOrigToMod); + moves.push(new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_1__.LineRangeMapping(originalLineRange, modifiedLineRange)); + modifiedSet.addRange(modifiedLineRange); + originalSet.addRange(originalLineRange); + } + } + moves.sort((0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.compareBy)(m => m.original.startLineNumber, _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.numberComparator)); + const monotonousChanges = new _base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.MonotonousArray(changes); + for (let i = 0; i < moves.length; i++) { + const move = moves[i]; + const firstTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber <= move.original.startLineNumber); + const firstTouchingChangeMod = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findLastMonotonous)(changes, c => c.modified.startLineNumber <= move.modified.startLineNumber); + const linesAbove = Math.max(move.original.startLineNumber - firstTouchingChangeOrig.original.startLineNumber, move.modified.startLineNumber - firstTouchingChangeMod.modified.startLineNumber); + const lastTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber < move.original.endLineNumberExclusive); + const lastTouchingChangeMod = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findLastMonotonous)(changes, c => c.modified.startLineNumber < move.modified.endLineNumberExclusive); + const linesBelow = Math.max(lastTouchingChangeOrig.original.endLineNumberExclusive - move.original.endLineNumberExclusive, lastTouchingChangeMod.modified.endLineNumberExclusive - move.modified.endLineNumberExclusive); + let extendToTop; + for (extendToTop = 0; extendToTop < linesAbove; extendToTop++) { + const origLine = move.original.startLineNumber - extendToTop - 1; + const modLine = move.modified.startLineNumber - extendToTop - 1; + if (origLine > originalLines.length || modLine > modifiedLines.length) { + break; + } + if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) { + break; + } + if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) { + break; + } + } + if (extendToTop > 0) { + originalSet.addRange(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(move.original.startLineNumber - extendToTop, move.original.startLineNumber)); + modifiedSet.addRange(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(move.modified.startLineNumber - extendToTop, move.modified.startLineNumber)); + } + let extendToBottom; + for (extendToBottom = 0; extendToBottom < linesBelow; extendToBottom++) { + const origLine = move.original.endLineNumberExclusive + extendToBottom; + const modLine = move.modified.endLineNumberExclusive + extendToBottom; + if (origLine > originalLines.length || modLine > modifiedLines.length) { + break; + } + if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) { + break; + } + if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) { + break; + } + } + if (extendToBottom > 0) { + originalSet.addRange(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(move.original.endLineNumberExclusive, move.original.endLineNumberExclusive + extendToBottom)); + modifiedSet.addRange(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(move.modified.endLineNumberExclusive, move.modified.endLineNumberExclusive + extendToBottom)); + } + if (extendToTop > 0 || extendToBottom > 0) { + moves[i] = new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_1__.LineRangeMapping(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(move.original.startLineNumber - extendToTop, move.original.endLineNumberExclusive + extendToBottom), new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(move.modified.startLineNumber - extendToTop, move.modified.endLineNumberExclusive + extendToBottom)); + } + } + return moves; +} +function areLinesSimilar(line1, line2, timeout) { + if (line1.trim() === line2.trim()) { + return true; + } + if (line1.length > 300 && line2.length > 300) { + return false; + } + const myersDiffingAlgorithm = new _algorithms_myersDiffAlgorithm_js__WEBPACK_IMPORTED_MODULE_9__.MyersDiffAlgorithm(); + const result = myersDiffingAlgorithm.compute(new _linesSliceCharSequence_js__WEBPACK_IMPORTED_MODULE_7__.LinesSliceCharSequence([line1], new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_6__.OffsetRange(0, 1), false), new _linesSliceCharSequence_js__WEBPACK_IMPORTED_MODULE_7__.LinesSliceCharSequence([line2], new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_6__.OffsetRange(0, 1), false), timeout); + let commonNonSpaceCharCount = 0; + const inverted = _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_0__.SequenceDiff.invert(result.diffs, line1.length); + for (const seq of inverted) { + seq.seq1Range.forEach(idx => { + if (!(0,_utils_js__WEBPACK_IMPORTED_MODULE_8__.isSpace)(line1.charCodeAt(idx))) { + commonNonSpaceCharCount++; + } + }); + } + function countNonWsChars(str) { + let count = 0; + for (let i = 0; i < line1.length; i++) { + if (!(0,_utils_js__WEBPACK_IMPORTED_MODULE_8__.isSpace)(str.charCodeAt(i))) { + count++; + } + } + return count; + } + const longerLineLength = countNonWsChars(line1.length > line2.length ? line1 : line2); + const r = commonNonSpaceCharCount / longerLineLength > 0.6 && longerLineLength > 10; + return r; +} +function joinCloseConsecutiveMoves(moves) { + if (moves.length === 0) { + return moves; + } + moves.sort((0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.compareBy)(m => m.original.startLineNumber, _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_2__.numberComparator)); + const result = [moves[0]]; + for (let i = 1; i < moves.length; i++) { + const last = result[result.length - 1]; + const current = moves[i]; + const originalDist = current.original.startLineNumber - last.original.endLineNumberExclusive; + const modifiedDist = current.modified.startLineNumber - last.modified.endLineNumberExclusive; + const currentMoveAfterLast = originalDist >= 0 && modifiedDist >= 0; + if (currentMoveAfterLast && originalDist + modifiedDist <= 2) { + result[result.length - 1] = last.join(current); + continue; + } + result.push(current); + } + return result; +} +function removeMovesInSameDiff(changes, moves) { + const changesMonotonous = new _base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.MonotonousArray(changes); + moves = moves.filter(m => { + const diffBeforeEndOfMoveOriginal = changesMonotonous.findLastMonotonous(c => c.original.startLineNumber < m.original.endLineNumberExclusive) + || new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_1__.LineRangeMapping(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(1, 1), new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_5__.LineRange(1, 1)); + const diffBeforeEndOfMoveModified = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_3__.findLastMonotonous)(changes, c => c.modified.startLineNumber < m.modified.endLineNumberExclusive); + const differentDiffs = diffBeforeEndOfMoveOriginal !== diffBeforeEndOfMoveModified; + return differentDiffs; + }); + return moves; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js": +/*!*******************************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js ***! + \*******************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DefaultLinesDiffComputer: () => (/* binding */ DefaultLinesDiffComputer), +/* harmony export */ getLineRangeMapping: () => (/* binding */ getLineRangeMapping), +/* harmony export */ lineRangeMappingFromRangeMappings: () => (/* binding */ lineRangeMappingFromRangeMappings) +/* harmony export */ }); +/* harmony import */ var _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../base/common/arrays.js */ "./node_modules/monaco-editor/esm/vs/base/common/arrays.js"); +/* harmony import */ var _base_common_assert_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../base/common/assert.js */ "./node_modules/monaco-editor/esm/vs/base/common/assert.js"); +/* harmony import */ var _core_lineRange_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../core/lineRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js"); +/* harmony import */ var _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../core/offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./algorithms/diffAlgorithm.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js"); +/* harmony import */ var _algorithms_dynamicProgrammingDiffing_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./algorithms/dynamicProgrammingDiffing.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.js"); +/* harmony import */ var _algorithms_myersDiffAlgorithm_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./algorithms/myersDiffAlgorithm.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.js"); +/* harmony import */ var _computeMovedLines_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./computeMovedLines.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/computeMovedLines.js"); +/* harmony import */ var _heuristicSequenceOptimizations_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./heuristicSequenceOptimizations.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js"); +/* harmony import */ var _linesDiffComputer_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../linesDiffComputer.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputer.js"); +/* harmony import */ var _rangeMapping_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../rangeMapping.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/rangeMapping.js"); +/* harmony import */ var _linesSliceCharSequence_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./linesSliceCharSequence.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js"); +/* harmony import */ var _lineSequence_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./lineSequence.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/lineSequence.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + + + + + + + + + + +class DefaultLinesDiffComputer { + constructor() { + this.dynamicProgrammingDiffing = new _algorithms_dynamicProgrammingDiffing_js__WEBPACK_IMPORTED_MODULE_6__.DynamicProgrammingDiffing(); + this.myersDiffingAlgorithm = new _algorithms_myersDiffAlgorithm_js__WEBPACK_IMPORTED_MODULE_7__.MyersDiffAlgorithm(); + } + computeDiff(originalLines, modifiedLines, options) { + if (originalLines.length <= 1 && (0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__.equals)(originalLines, modifiedLines, (a, b) => a === b)) { + return new _linesDiffComputer_js__WEBPACK_IMPORTED_MODULE_10__.LinesDiff([], [], false); + } + if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) { + return new _linesDiffComputer_js__WEBPACK_IMPORTED_MODULE_10__.LinesDiff([ + new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_11__.DetailedLineRangeMapping(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_2__.LineRange(1, originalLines.length + 1), new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_2__.LineRange(1, modifiedLines.length + 1), [ + new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_11__.RangeMapping(new _core_range_js__WEBPACK_IMPORTED_MODULE_4__.Range(1, 1, originalLines.length, originalLines[0].length + 1), new _core_range_js__WEBPACK_IMPORTED_MODULE_4__.Range(1, 1, modifiedLines.length, modifiedLines[0].length + 1)) + ]) + ], [], false); + } + const timeout = options.maxComputationTimeMs === 0 ? _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_5__.InfiniteTimeout.instance : new _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_5__.DateTimeout(options.maxComputationTimeMs); + const considerWhitespaceChanges = !options.ignoreTrimWhitespace; + const perfectHashes = new Map(); + function getOrCreateHash(text) { + let hash = perfectHashes.get(text); + if (hash === undefined) { + hash = perfectHashes.size; + perfectHashes.set(text, hash); + } + return hash; + } + const originalLinesHashes = originalLines.map((l) => getOrCreateHash(l.trim())); + const modifiedLinesHashes = modifiedLines.map((l) => getOrCreateHash(l.trim())); + const sequence1 = new _lineSequence_js__WEBPACK_IMPORTED_MODULE_13__.LineSequence(originalLinesHashes, originalLines); + const sequence2 = new _lineSequence_js__WEBPACK_IMPORTED_MODULE_13__.LineSequence(modifiedLinesHashes, modifiedLines); + const lineAlignmentResult = (() => { + if (sequence1.length + sequence2.length < 1700) { + // Use the improved algorithm for small files + return this.dynamicProgrammingDiffing.compute(sequence1, sequence2, timeout, (offset1, offset2) => originalLines[offset1] === modifiedLines[offset2] + ? modifiedLines[offset2].length === 0 + ? 0.1 + : 1 + Math.log(1 + modifiedLines[offset2].length) + : 0.99); + } + return this.myersDiffingAlgorithm.compute(sequence1, sequence2); + })(); + let lineAlignments = lineAlignmentResult.diffs; + let hitTimeout = lineAlignmentResult.hitTimeout; + lineAlignments = (0,_heuristicSequenceOptimizations_js__WEBPACK_IMPORTED_MODULE_9__.optimizeSequenceDiffs)(sequence1, sequence2, lineAlignments); + lineAlignments = (0,_heuristicSequenceOptimizations_js__WEBPACK_IMPORTED_MODULE_9__.removeVeryShortMatchingLinesBetweenDiffs)(sequence1, sequence2, lineAlignments); + const alignments = []; + const scanForWhitespaceChanges = (equalLinesCount) => { + if (!considerWhitespaceChanges) { + return; + } + for (let i = 0; i < equalLinesCount; i++) { + const seq1Offset = seq1LastStart + i; + const seq2Offset = seq2LastStart + i; + if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) { + // This is because of whitespace changes, diff these lines + const characterDiffs = this.refineDiff(originalLines, modifiedLines, new _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_5__.SequenceDiff(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_3__.OffsetRange(seq1Offset, seq1Offset + 1), new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_3__.OffsetRange(seq2Offset, seq2Offset + 1)), timeout, considerWhitespaceChanges); + for (const a of characterDiffs.mappings) { + alignments.push(a); + } + if (characterDiffs.hitTimeout) { + hitTimeout = true; + } + } + } + }; + let seq1LastStart = 0; + let seq2LastStart = 0; + for (const diff of lineAlignments) { + (0,_base_common_assert_js__WEBPACK_IMPORTED_MODULE_1__.assertFn)(() => diff.seq1Range.start - seq1LastStart === diff.seq2Range.start - seq2LastStart); + const equalLinesCount = diff.seq1Range.start - seq1LastStart; + scanForWhitespaceChanges(equalLinesCount); + seq1LastStart = diff.seq1Range.endExclusive; + seq2LastStart = diff.seq2Range.endExclusive; + const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges); + if (characterDiffs.hitTimeout) { + hitTimeout = true; + } + for (const a of characterDiffs.mappings) { + alignments.push(a); + } + } + scanForWhitespaceChanges(originalLines.length - seq1LastStart); + const changes = lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines); + let moves = []; + if (options.computeMoves) { + moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges); + } + // Make sure all ranges are valid + (0,_base_common_assert_js__WEBPACK_IMPORTED_MODULE_1__.assertFn)(() => { + function validatePosition(pos, lines) { + if (pos.lineNumber < 1 || pos.lineNumber > lines.length) { + return false; + } + const line = lines[pos.lineNumber - 1]; + if (pos.column < 1 || pos.column > line.length + 1) { + return false; + } + return true; + } + function validateRange(range, lines) { + if (range.startLineNumber < 1 || range.startLineNumber > lines.length + 1) { + return false; + } + if (range.endLineNumberExclusive < 1 || range.endLineNumberExclusive > lines.length + 1) { + return false; + } + return true; + } + for (const c of changes) { + if (!c.innerChanges) { + return false; + } + for (const ic of c.innerChanges) { + const valid = validatePosition(ic.modifiedRange.getStartPosition(), modifiedLines) && validatePosition(ic.modifiedRange.getEndPosition(), modifiedLines) && + validatePosition(ic.originalRange.getStartPosition(), originalLines) && validatePosition(ic.originalRange.getEndPosition(), originalLines); + if (!valid) { + return false; + } + } + if (!validateRange(c.modified, modifiedLines) || !validateRange(c.original, originalLines)) { + return false; + } + } + return true; + }); + return new _linesDiffComputer_js__WEBPACK_IMPORTED_MODULE_10__.LinesDiff(changes, moves, hitTimeout); + } + computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges) { + const moves = (0,_computeMovedLines_js__WEBPACK_IMPORTED_MODULE_8__.computeMovedLines)(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout); + const movesWithDiffs = moves.map(m => { + const moveChanges = this.refineDiff(originalLines, modifiedLines, new _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_5__.SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange()), timeout, considerWhitespaceChanges); + const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, originalLines, modifiedLines, true); + return new _linesDiffComputer_js__WEBPACK_IMPORTED_MODULE_10__.MovedText(m, mappings); + }); + return movesWithDiffs; + } + refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges) { + const slice1 = new _linesSliceCharSequence_js__WEBPACK_IMPORTED_MODULE_12__.LinesSliceCharSequence(originalLines, diff.seq1Range, considerWhitespaceChanges); + const slice2 = new _linesSliceCharSequence_js__WEBPACK_IMPORTED_MODULE_12__.LinesSliceCharSequence(modifiedLines, diff.seq2Range, considerWhitespaceChanges); + const diffResult = slice1.length + slice2.length < 500 + ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout) + : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout); + let diffs = diffResult.diffs; + diffs = (0,_heuristicSequenceOptimizations_js__WEBPACK_IMPORTED_MODULE_9__.optimizeSequenceDiffs)(slice1, slice2, diffs); + diffs = (0,_heuristicSequenceOptimizations_js__WEBPACK_IMPORTED_MODULE_9__.extendDiffsToEntireWordIfAppropriate)(slice1, slice2, diffs); + diffs = (0,_heuristicSequenceOptimizations_js__WEBPACK_IMPORTED_MODULE_9__.removeShortMatches)(slice1, slice2, diffs); + diffs = (0,_heuristicSequenceOptimizations_js__WEBPACK_IMPORTED_MODULE_9__.removeVeryShortMatchingTextBetweenLongDiffs)(slice1, slice2, diffs); + const result = diffs.map((d) => new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_11__.RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range))); + // Assert: result applied on original should be the same as diff applied to original + return { + mappings: result, + hitTimeout: diffResult.hitTimeout, + }; + } +} +function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines, dontAssertStartLine = false) { + const changes = []; + for (const g of (0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__.groupAdjacentBy)(alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines)), (a1, a2) => a1.original.overlapOrTouch(a2.original) + || a1.modified.overlapOrTouch(a2.modified))) { + const first = g[0]; + const last = g[g.length - 1]; + changes.push(new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_11__.DetailedLineRangeMapping(first.original.join(last.original), first.modified.join(last.modified), g.map(a => a.innerChanges[0]))); + } + (0,_base_common_assert_js__WEBPACK_IMPORTED_MODULE_1__.assertFn)(() => { + if (!dontAssertStartLine) { + if (changes.length > 0 && changes[0].original.startLineNumber !== changes[0].modified.startLineNumber) { + return false; + } + } + return (0,_base_common_assert_js__WEBPACK_IMPORTED_MODULE_1__.checkAdjacentItems)(changes, (m1, m2) => m2.original.startLineNumber - m1.original.endLineNumberExclusive === m2.modified.startLineNumber - m1.modified.endLineNumberExclusive && + // There has to be an unchanged line in between (otherwise both diffs should have been joined) + m1.original.endLineNumberExclusive < m2.original.startLineNumber && + m1.modified.endLineNumberExclusive < m2.modified.startLineNumber); + }); + return changes; +} +function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) { + let lineStartDelta = 0; + let lineEndDelta = 0; + // rangeMapping describes the edit that replaces `rangeMapping.originalRange` with `newText := getText(modifiedLines, rangeMapping.modifiedRange)`. + // original: ]xxx \n <- this line is not modified + // modified: ]xx \n + if (rangeMapping.modifiedRange.endColumn === 1 && rangeMapping.originalRange.endColumn === 1 + && rangeMapping.originalRange.startLineNumber + lineStartDelta <= rangeMapping.originalRange.endLineNumber + && rangeMapping.modifiedRange.startLineNumber + lineStartDelta <= rangeMapping.modifiedRange.endLineNumber) { + // We can only do this if the range is not empty yet + lineEndDelta = -1; + } + // original: xxx[ \n <- this line is not modified + // modified: xxx[ \n + if (rangeMapping.modifiedRange.startColumn - 1 >= modifiedLines[rangeMapping.modifiedRange.startLineNumber - 1].length + && rangeMapping.originalRange.startColumn - 1 >= originalLines[rangeMapping.originalRange.startLineNumber - 1].length + && rangeMapping.originalRange.startLineNumber <= rangeMapping.originalRange.endLineNumber + lineEndDelta + && rangeMapping.modifiedRange.startLineNumber <= rangeMapping.modifiedRange.endLineNumber + lineEndDelta) { + // We can only do this if the range is not empty yet + lineStartDelta = 1; + } + const originalLineRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_2__.LineRange(rangeMapping.originalRange.startLineNumber + lineStartDelta, rangeMapping.originalRange.endLineNumber + 1 + lineEndDelta); + const modifiedLineRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_2__.LineRange(rangeMapping.modifiedRange.startLineNumber + lineStartDelta, rangeMapping.modifiedRange.endLineNumber + 1 + lineEndDelta); + return new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_11__.DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]); +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js": +/*!*************************************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js ***! + \*************************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ extendDiffsToEntireWordIfAppropriate: () => (/* binding */ extendDiffsToEntireWordIfAppropriate), +/* harmony export */ optimizeSequenceDiffs: () => (/* binding */ optimizeSequenceDiffs), +/* harmony export */ removeShortMatches: () => (/* binding */ removeShortMatches), +/* harmony export */ removeVeryShortMatchingLinesBetweenDiffs: () => (/* binding */ removeVeryShortMatchingLinesBetweenDiffs), +/* harmony export */ removeVeryShortMatchingTextBetweenLongDiffs: () => (/* binding */ removeVeryShortMatchingTextBetweenLongDiffs) +/* harmony export */ }); +/* harmony import */ var _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../base/common/arrays.js */ "./node_modules/monaco-editor/esm/vs/base/common/arrays.js"); +/* harmony import */ var _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../core/offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/* harmony import */ var _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./algorithms/diffAlgorithm.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + +function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) { + let result = sequenceDiffs; + result = joinSequenceDiffsByShifting(sequence1, sequence2, result); + // Sometimes, calling this function twice improves the result. + // Uncomment the second invocation and run the tests to see the difference. + result = joinSequenceDiffsByShifting(sequence1, sequence2, result); + result = shiftSequenceDiffs(sequence1, sequence2, result); + return result; +} +/** + * This function fixes issues like this: + * ``` + * import { Baz, Bar } from "foo"; + * ``` + * <-> + * ``` + * import { Baz, Bar, Foo } from "foo"; + * ``` + * Computed diff: [ {Add "," after Bar}, {Add "Foo " after space} } + * Improved diff: [{Add ", Foo" after Bar}] + */ +function joinSequenceDiffsByShifting(sequence1, sequence2, sequenceDiffs) { + if (sequenceDiffs.length === 0) { + return sequenceDiffs; + } + const result = []; + result.push(sequenceDiffs[0]); + // First move them all to the left as much as possible and join them if possible + for (let i = 1; i < sequenceDiffs.length; i++) { + const prevResult = result[result.length - 1]; + let cur = sequenceDiffs[i]; + if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) { + const length = cur.seq1Range.start - prevResult.seq1Range.endExclusive; + let d; + for (d = 1; d <= length; d++) { + if (sequence1.getElement(cur.seq1Range.start - d) !== sequence1.getElement(cur.seq1Range.endExclusive - d) || + sequence2.getElement(cur.seq2Range.start - d) !== sequence2.getElement(cur.seq2Range.endExclusive - d)) { + break; + } + } + d--; + if (d === length) { + // Merge previous and current diff + result[result.length - 1] = new _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__.SequenceDiff(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(prevResult.seq1Range.start, cur.seq1Range.endExclusive - length), new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(prevResult.seq2Range.start, cur.seq2Range.endExclusive - length)); + continue; + } + cur = cur.delta(-d); + } + result.push(cur); + } + const result2 = []; + // Then move them all to the right and join them again if possible + for (let i = 0; i < result.length - 1; i++) { + const nextResult = result[i + 1]; + let cur = result[i]; + if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) { + const length = nextResult.seq1Range.start - cur.seq1Range.endExclusive; + let d; + for (d = 0; d < length; d++) { + if (!sequence1.isStronglyEqual(cur.seq1Range.start + d, cur.seq1Range.endExclusive + d) || + !sequence2.isStronglyEqual(cur.seq2Range.start + d, cur.seq2Range.endExclusive + d)) { + break; + } + } + if (d === length) { + // Merge previous and current diff, write to result! + result[i + 1] = new _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__.SequenceDiff(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(cur.seq1Range.start + length, nextResult.seq1Range.endExclusive), new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(cur.seq2Range.start + length, nextResult.seq2Range.endExclusive)); + continue; + } + if (d > 0) { + cur = cur.delta(d); + } + } + result2.push(cur); + } + if (result.length > 0) { + result2.push(result[result.length - 1]); + } + return result2; +} +// align character level diffs at whitespace characters +// import { IBar } from "foo"; +// import { I[Arr, I]Bar } from "foo"; +// -> +// import { [IArr, ]IBar } from "foo"; +// import { ITransaction, observableValue, transaction } from 'vs/base/common/observable'; +// import { ITransaction, observable[FromEvent, observable]Value, transaction } from 'vs/base/common/observable'; +// -> +// import { ITransaction, [observableFromEvent, ]observableValue, transaction } from 'vs/base/common/observable'; +// collectBrackets(level + 1, levelPerBracketType); +// collectBrackets(level + 1, levelPerBracket[ + 1, levelPerBracket]Type); +// -> +// collectBrackets(level + 1, [levelPerBracket + 1, ]levelPerBracketType); +function shiftSequenceDiffs(sequence1, sequence2, sequenceDiffs) { + if (!sequence1.getBoundaryScore || !sequence2.getBoundaryScore) { + return sequenceDiffs; + } + for (let i = 0; i < sequenceDiffs.length; i++) { + const prevDiff = (i > 0 ? sequenceDiffs[i - 1] : undefined); + const diff = sequenceDiffs[i]; + const nextDiff = (i + 1 < sequenceDiffs.length ? sequenceDiffs[i + 1] : undefined); + const seq1ValidRange = new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(prevDiff ? prevDiff.seq1Range.start + 1 : 0, nextDiff ? nextDiff.seq1Range.endExclusive - 1 : sequence1.length); + const seq2ValidRange = new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(prevDiff ? prevDiff.seq2Range.start + 1 : 0, nextDiff ? nextDiff.seq2Range.endExclusive - 1 : sequence2.length); + if (diff.seq1Range.isEmpty) { + sequenceDiffs[i] = shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange); + } + else if (diff.seq2Range.isEmpty) { + sequenceDiffs[i] = shiftDiffToBetterPosition(diff.swap(), sequence2, sequence1, seq2ValidRange, seq1ValidRange).swap(); + } + } + return sequenceDiffs; +} +function shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange) { + const maxShiftLimit = 100; // To prevent performance issues + // don't touch previous or next! + let deltaBefore = 1; + while (diff.seq1Range.start - deltaBefore >= seq1ValidRange.start && + diff.seq2Range.start - deltaBefore >= seq2ValidRange.start && + sequence2.isStronglyEqual(diff.seq2Range.start - deltaBefore, diff.seq2Range.endExclusive - deltaBefore) && deltaBefore < maxShiftLimit) { + deltaBefore++; + } + deltaBefore--; + let deltaAfter = 0; + while (diff.seq1Range.start + deltaAfter < seq1ValidRange.endExclusive && + diff.seq2Range.endExclusive + deltaAfter < seq2ValidRange.endExclusive && + sequence2.isStronglyEqual(diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter) && deltaAfter < maxShiftLimit) { + deltaAfter++; + } + if (deltaBefore === 0 && deltaAfter === 0) { + return diff; + } + // Visualize `[sequence1.text, diff.seq1Range.start + deltaAfter]` + // and `[sequence2.text, diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter]` + let bestDelta = 0; + let bestScore = -1; + // find best scored delta + for (let delta = -deltaBefore; delta <= deltaAfter; delta++) { + const seq2OffsetStart = diff.seq2Range.start + delta; + const seq2OffsetEndExclusive = diff.seq2Range.endExclusive + delta; + const seq1Offset = diff.seq1Range.start + delta; + const score = sequence1.getBoundaryScore(seq1Offset) + sequence2.getBoundaryScore(seq2OffsetStart) + sequence2.getBoundaryScore(seq2OffsetEndExclusive); + if (score > bestScore) { + bestScore = score; + bestDelta = delta; + } + } + return diff.delta(bestDelta); +} +function removeShortMatches(sequence1, sequence2, sequenceDiffs) { + const result = []; + for (const s of sequenceDiffs) { + const last = result[result.length - 1]; + if (!last) { + result.push(s); + continue; + } + if (s.seq1Range.start - last.seq1Range.endExclusive <= 2 || s.seq2Range.start - last.seq2Range.endExclusive <= 2) { + result[result.length - 1] = new _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__.SequenceDiff(last.seq1Range.join(s.seq1Range), last.seq2Range.join(s.seq2Range)); + } + else { + result.push(s); + } + } + return result; +} +function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs) { + const additional = []; + let lastModifiedWord = undefined; + function maybePushWordToAdditional() { + if (!lastModifiedWord) { + return; + } + const originalLength1 = lastModifiedWord.s1Range.length - lastModifiedWord.deleted; + const originalLength2 = lastModifiedWord.s2Range.length - lastModifiedWord.added; + if (originalLength1 !== originalLength2) { + // TODO figure out why this happens + } + if (Math.max(lastModifiedWord.deleted, lastModifiedWord.added) + (lastModifiedWord.count - 1) > originalLength1) { + additional.push(new _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__.SequenceDiff(lastModifiedWord.s1Range, lastModifiedWord.s2Range)); + } + lastModifiedWord = undefined; + } + for (const s of sequenceDiffs) { + function processWord(s1Range, s2Range) { + var _a, _b, _c, _d; + if (!lastModifiedWord || !lastModifiedWord.s1Range.containsRange(s1Range) || !lastModifiedWord.s2Range.containsRange(s2Range)) { + if (lastModifiedWord && !(lastModifiedWord.s1Range.endExclusive < s1Range.start && lastModifiedWord.s2Range.endExclusive < s2Range.start)) { + const s1Added = _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange.tryCreate(lastModifiedWord.s1Range.endExclusive, s1Range.start); + const s2Added = _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange.tryCreate(lastModifiedWord.s2Range.endExclusive, s2Range.start); + lastModifiedWord.deleted += (_a = s1Added === null || s1Added === void 0 ? void 0 : s1Added.length) !== null && _a !== void 0 ? _a : 0; + lastModifiedWord.added += (_b = s2Added === null || s2Added === void 0 ? void 0 : s2Added.length) !== null && _b !== void 0 ? _b : 0; + lastModifiedWord.s1Range = lastModifiedWord.s1Range.join(s1Range); + lastModifiedWord.s2Range = lastModifiedWord.s2Range.join(s2Range); + } + else { + maybePushWordToAdditional(); + lastModifiedWord = { added: 0, deleted: 0, count: 0, s1Range: s1Range, s2Range: s2Range }; + } + } + const changedS1 = s1Range.intersect(s.seq1Range); + const changedS2 = s2Range.intersect(s.seq2Range); + lastModifiedWord.count++; + lastModifiedWord.deleted += (_c = changedS1 === null || changedS1 === void 0 ? void 0 : changedS1.length) !== null && _c !== void 0 ? _c : 0; + lastModifiedWord.added += (_d = changedS2 === null || changedS2 === void 0 ? void 0 : changedS2.length) !== null && _d !== void 0 ? _d : 0; + } + const w1Before = sequence1.findWordContaining(s.seq1Range.start - 1); + const w2Before = sequence2.findWordContaining(s.seq2Range.start - 1); + const w1After = sequence1.findWordContaining(s.seq1Range.endExclusive); + const w2After = sequence2.findWordContaining(s.seq2Range.endExclusive); + if (w1Before && w1After && w2Before && w2After && w1Before.equals(w1After) && w2Before.equals(w2After)) { + processWord(w1Before, w2Before); + } + else { + if (w1Before && w2Before) { + processWord(w1Before, w2Before); + } + if (w1After && w2After) { + processWord(w1After, w2After); + } + } + } + maybePushWordToAdditional(); + const merged = mergeSequenceDiffs(sequenceDiffs, additional); + return merged; +} +function mergeSequenceDiffs(sequenceDiffs1, sequenceDiffs2) { + const result = []; + while (sequenceDiffs1.length > 0 || sequenceDiffs2.length > 0) { + const sd1 = sequenceDiffs1[0]; + const sd2 = sequenceDiffs2[0]; + let next; + if (sd1 && (!sd2 || sd1.seq1Range.start < sd2.seq1Range.start)) { + next = sequenceDiffs1.shift(); + } + else { + next = sequenceDiffs2.shift(); + } + if (result.length > 0 && result[result.length - 1].seq1Range.endExclusive >= next.seq1Range.start) { + result[result.length - 1] = result[result.length - 1].join(next); + } + else { + result.push(next); + } + } + return result; +} +function removeVeryShortMatchingLinesBetweenDiffs(sequence1, _sequence2, sequenceDiffs) { + let diffs = sequenceDiffs; + if (diffs.length === 0) { + return diffs; + } + let counter = 0; + let shouldRepeat; + do { + shouldRepeat = false; + const result = [ + diffs[0] + ]; + for (let i = 1; i < diffs.length; i++) { + const cur = diffs[i]; + const lastResult = result[result.length - 1]; + function shouldJoinDiffs(before, after) { + const unchangedRange = new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start); + const unchangedText = sequence1.getText(unchangedRange); + const unchangedTextWithoutWs = unchangedText.replace(/\s/g, ''); + if (unchangedTextWithoutWs.length <= 4 + && (before.seq1Range.length + before.seq2Range.length > 5 || after.seq1Range.length + after.seq2Range.length > 5)) { + return true; + } + return false; + } + const shouldJoin = shouldJoinDiffs(lastResult, cur); + if (shouldJoin) { + shouldRepeat = true; + result[result.length - 1] = result[result.length - 1].join(cur); + } + else { + result.push(cur); + } + } + diffs = result; + } while (counter++ < 10 && shouldRepeat); + return diffs; +} +function removeVeryShortMatchingTextBetweenLongDiffs(sequence1, sequence2, sequenceDiffs) { + let diffs = sequenceDiffs; + if (diffs.length === 0) { + return diffs; + } + let counter = 0; + let shouldRepeat; + do { + shouldRepeat = false; + const result = [ + diffs[0] + ]; + for (let i = 1; i < diffs.length; i++) { + const cur = diffs[i]; + const lastResult = result[result.length - 1]; + function shouldJoinDiffs(before, after) { + const unchangedRange = new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start); + const unchangedLineCount = sequence1.countLinesIn(unchangedRange); + if (unchangedLineCount > 5 || unchangedRange.length > 500) { + return false; + } + const unchangedText = sequence1.getText(unchangedRange).trim(); + if (unchangedText.length > 20 || unchangedText.split(/\r\n|\r|\n/).length > 1) { + return false; + } + const beforeLineCount1 = sequence1.countLinesIn(before.seq1Range); + const beforeSeq1Length = before.seq1Range.length; + const beforeLineCount2 = sequence2.countLinesIn(before.seq2Range); + const beforeSeq2Length = before.seq2Range.length; + const afterLineCount1 = sequence1.countLinesIn(after.seq1Range); + const afterSeq1Length = after.seq1Range.length; + const afterLineCount2 = sequence2.countLinesIn(after.seq2Range); + const afterSeq2Length = after.seq2Range.length; + // TODO: Maybe a neural net can be used to derive the result from these numbers + const max = 2 * 40 + 50; + function cap(v) { + return Math.min(v, max); + } + if (Math.pow(Math.pow(cap(beforeLineCount1 * 40 + beforeSeq1Length), 1.5) + Math.pow(cap(beforeLineCount2 * 40 + beforeSeq2Length), 1.5), 1.5) + + Math.pow(Math.pow(cap(afterLineCount1 * 40 + afterSeq1Length), 1.5) + Math.pow(cap(afterLineCount2 * 40 + afterSeq2Length), 1.5), 1.5) > ((max ** 1.5) ** 1.5) * 1.3) { + return true; + } + return false; + } + const shouldJoin = shouldJoinDiffs(lastResult, cur); + if (shouldJoin) { + shouldRepeat = true; + result[result.length - 1] = result[result.length - 1].join(cur); + } + else { + result.push(cur); + } + } + diffs = result; + } while (counter++ < 10 && shouldRepeat); + const newDiffs = []; + // Remove short suffixes/prefixes + (0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__.forEachWithNeighbors)(diffs, (prev, cur, next) => { + let newDiff = cur; + function shouldMarkAsChanged(text) { + return text.length > 0 && text.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100; + } + const fullRange1 = sequence1.extendToFullLines(cur.seq1Range); + const prefix = sequence1.getText(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(fullRange1.start, cur.seq1Range.start)); + if (shouldMarkAsChanged(prefix)) { + newDiff = newDiff.deltaStart(-prefix.length); + } + const suffix = sequence1.getText(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(cur.seq1Range.endExclusive, fullRange1.endExclusive)); + if (shouldMarkAsChanged(suffix)) { + newDiff = newDiff.deltaEnd(suffix.length); + } + const availableSpace = _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__.SequenceDiff.fromOffsetPairs(prev ? prev.getEndExclusives() : _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__.OffsetPair.zero, next ? next.getStarts() : _algorithms_diffAlgorithm_js__WEBPACK_IMPORTED_MODULE_2__.OffsetPair.max); + const result = newDiff.intersect(availableSpace); + newDiffs.push(result); + }); + return newDiffs; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/lineSequence.js": +/*!*******************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/lineSequence.js ***! + \*******************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LineSequence: () => (/* binding */ LineSequence) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +class LineSequence { + constructor(trimmedHash, lines) { + this.trimmedHash = trimmedHash; + this.lines = lines; + } + getElement(offset) { + return this.trimmedHash[offset]; + } + get length() { + return this.trimmedHash.length; + } + getBoundaryScore(length) { + const indentationBefore = length === 0 ? 0 : getIndentation(this.lines[length - 1]); + const indentationAfter = length === this.lines.length ? 0 : getIndentation(this.lines[length]); + return 1000 - (indentationBefore + indentationAfter); + } + getText(range) { + return this.lines.slice(range.start, range.endExclusive).join('\n'); + } + isStronglyEqual(offset1, offset2) { + return this.lines[offset1] === this.lines[offset2]; + } +} +function getIndentation(str) { + let i = 0; + while (i < str.length && (str.charCodeAt(i) === 32 /* CharCode.Space */ || str.charCodeAt(i) === 9 /* CharCode.Tab */)) { + i++; + } + return i; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js": +/*!*****************************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js ***! + \*****************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LinesSliceCharSequence: () => (/* binding */ LinesSliceCharSequence) +/* harmony export */ }); +/* harmony import */ var _base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../base/common/arraysFind.js */ "./node_modules/monaco-editor/esm/vs/base/common/arraysFind.js"); +/* harmony import */ var _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../core/offsetRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"); +/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../core/position.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js"); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./utils.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/utils.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + +class LinesSliceCharSequence { + constructor(lines, lineRange, considerWhitespaceChanges) { + // This slice has to have lineRange.length many \n! (otherwise diffing against an empty slice will be problematic) + // (Unless it covers the entire document, in that case the other slice also has to cover the entire document ands it's okay) + this.lines = lines; + this.considerWhitespaceChanges = considerWhitespaceChanges; + this.elements = []; + this.firstCharOffsetByLine = []; + // To account for trimming + this.additionalOffsetByLine = []; + // If the slice covers the end, but does not start at the beginning, we include just the \n of the previous line. + let trimFirstLineFully = false; + if (lineRange.start > 0 && lineRange.endExclusive >= lines.length) { + lineRange = new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(lineRange.start - 1, lineRange.endExclusive); + trimFirstLineFully = true; + } + this.lineRange = lineRange; + this.firstCharOffsetByLine[0] = 0; + for (let i = this.lineRange.start; i < this.lineRange.endExclusive; i++) { + let line = lines[i]; + let offset = 0; + if (trimFirstLineFully) { + offset = line.length; + line = ''; + trimFirstLineFully = false; + } + else if (!considerWhitespaceChanges) { + const trimmedStartLine = line.trimStart(); + offset = line.length - trimmedStartLine.length; + line = trimmedStartLine.trimEnd(); + } + this.additionalOffsetByLine.push(offset); + for (let i = 0; i < line.length; i++) { + this.elements.push(line.charCodeAt(i)); + } + // Don't add an \n that does not exist in the document. + if (i < lines.length - 1) { + this.elements.push('\n'.charCodeAt(0)); + this.firstCharOffsetByLine[i - this.lineRange.start + 1] = this.elements.length; + } + } + // To account for the last line + this.additionalOffsetByLine.push(0); + } + toString() { + return `Slice: "${this.text}"`; + } + get text() { + return this.getText(new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(0, this.length)); + } + getText(range) { + return this.elements.slice(range.start, range.endExclusive).map(e => String.fromCharCode(e)).join(''); + } + getElement(offset) { + return this.elements[offset]; + } + get length() { + return this.elements.length; + } + getBoundaryScore(length) { + // a b c , d e f + // 11 0 0 12 15 6 13 0 0 11 + const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1); + const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1); + if (prevCategory === 7 /* CharBoundaryCategory.LineBreakCR */ && nextCategory === 8 /* CharBoundaryCategory.LineBreakLF */) { + // don't break between \r and \n + return 0; + } + let score = 0; + if (prevCategory !== nextCategory) { + score += 10; + if (prevCategory === 0 /* CharBoundaryCategory.WordLower */ && nextCategory === 1 /* CharBoundaryCategory.WordUpper */) { + score += 1; + } + } + score += getCategoryBoundaryScore(prevCategory); + score += getCategoryBoundaryScore(nextCategory); + return score; + } + translateOffset(offset) { + // find smallest i, so that lineBreakOffsets[i] <= offset using binary search + if (this.lineRange.isEmpty) { + return new _core_position_js__WEBPACK_IMPORTED_MODULE_2__.Position(this.lineRange.start + 1, 1); + } + const i = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_0__.findLastIdxMonotonous)(this.firstCharOffsetByLine, (value) => value <= offset); + return new _core_position_js__WEBPACK_IMPORTED_MODULE_2__.Position(this.lineRange.start + i + 1, offset - this.firstCharOffsetByLine[i] + this.additionalOffsetByLine[i] + 1); + } + translateRange(range) { + return _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.fromPositions(this.translateOffset(range.start), this.translateOffset(range.endExclusive)); + } + /** + * Finds the word that contains the character at the given offset + */ + findWordContaining(offset) { + if (offset < 0 || offset >= this.elements.length) { + return undefined; + } + if (!isWordChar(this.elements[offset])) { + return undefined; + } + // find start + let start = offset; + while (start > 0 && isWordChar(this.elements[start - 1])) { + start--; + } + // find end + let end = offset; + while (end < this.elements.length && isWordChar(this.elements[end])) { + end++; + } + return new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(start, end); + } + countLinesIn(range) { + return this.translateOffset(range.endExclusive).lineNumber - this.translateOffset(range.start).lineNumber; + } + isStronglyEqual(offset1, offset2) { + return this.elements[offset1] === this.elements[offset2]; + } + extendToFullLines(range) { + var _a, _b; + const start = (_a = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_0__.findLastMonotonous)(this.firstCharOffsetByLine, x => x <= range.start)) !== null && _a !== void 0 ? _a : 0; + const end = (_b = (0,_base_common_arraysFind_js__WEBPACK_IMPORTED_MODULE_0__.findFirstMonotonous)(this.firstCharOffsetByLine, x => range.endExclusive <= x)) !== null && _b !== void 0 ? _b : this.elements.length; + return new _core_offsetRange_js__WEBPACK_IMPORTED_MODULE_1__.OffsetRange(start, end); + } +} +function isWordChar(charCode) { + return charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */ + || charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */ + || charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */; +} +const score = { + [0 /* CharBoundaryCategory.WordLower */]: 0, + [1 /* CharBoundaryCategory.WordUpper */]: 0, + [2 /* CharBoundaryCategory.WordNumber */]: 0, + [3 /* CharBoundaryCategory.End */]: 10, + [4 /* CharBoundaryCategory.Other */]: 2, + [5 /* CharBoundaryCategory.Separator */]: 3, + [6 /* CharBoundaryCategory.Space */]: 3, + [7 /* CharBoundaryCategory.LineBreakCR */]: 10, + [8 /* CharBoundaryCategory.LineBreakLF */]: 10, +}; +function getCategoryBoundaryScore(category) { + return score[category]; +} +function getCategory(charCode) { + if (charCode === 10 /* CharCode.LineFeed */) { + return 8 /* CharBoundaryCategory.LineBreakLF */; + } + else if (charCode === 13 /* CharCode.CarriageReturn */) { + return 7 /* CharBoundaryCategory.LineBreakCR */; + } + else if ((0,_utils_js__WEBPACK_IMPORTED_MODULE_4__.isSpace)(charCode)) { + return 6 /* CharBoundaryCategory.Space */; + } + else if (charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */) { + return 0 /* CharBoundaryCategory.WordLower */; + } + else if (charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */) { + return 1 /* CharBoundaryCategory.WordUpper */; + } + else if (charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */) { + return 2 /* CharBoundaryCategory.WordNumber */; + } + else if (charCode === -1) { + return 3 /* CharBoundaryCategory.End */; + } + else if (charCode === 44 /* CharCode.Comma */ || charCode === 59 /* CharCode.Semicolon */) { + return 5 /* CharBoundaryCategory.Separator */; + } + else { + return 4 /* CharBoundaryCategory.Other */; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/utils.js": +/*!************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/utils.js ***! + \************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Array2D: () => (/* binding */ Array2D), +/* harmony export */ LineRangeFragment: () => (/* binding */ LineRangeFragment), +/* harmony export */ isSpace: () => (/* binding */ isSpace) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +class Array2D { + constructor(width, height) { + this.width = width; + this.height = height; + this.array = []; + this.array = new Array(width * height); + } + get(x, y) { + return this.array[x + y * this.width]; + } + set(x, y, value) { + this.array[x + y * this.width] = value; + } +} +function isSpace(charCode) { + return charCode === 32 /* CharCode.Space */ || charCode === 9 /* CharCode.Tab */; +} +class LineRangeFragment { + static getKey(chr) { + let key = this.chrKeys.get(chr); + if (key === undefined) { + key = this.chrKeys.size; + this.chrKeys.set(chr, key); + } + return key; + } + constructor(range, lines, source) { + this.range = range; + this.lines = lines; + this.source = source; + this.histogram = []; + let counter = 0; + for (let i = range.startLineNumber - 1; i < range.endLineNumberExclusive - 1; i++) { + const line = lines[i]; + for (let j = 0; j < line.length; j++) { + counter++; + const chr = line[j]; + const key = LineRangeFragment.getKey(chr); + this.histogram[key] = (this.histogram[key] || 0) + 1; + } + counter++; + const key = LineRangeFragment.getKey('\n'); + this.histogram[key] = (this.histogram[key] || 0) + 1; + } + this.totalCount = counter; + } + computeSimilarity(other) { + var _a, _b; + let sumDifferences = 0; + const maxLength = Math.max(this.histogram.length, other.histogram.length); + for (let i = 0; i < maxLength; i++) { + sumDifferences += Math.abs(((_a = this.histogram[i]) !== null && _a !== void 0 ? _a : 0) - ((_b = other.histogram[i]) !== null && _b !== void 0 ? _b : 0)); + } + return 1 - (sumDifferences / (this.totalCount + other.totalCount)); + } +} +LineRangeFragment.chrKeys = new Map(); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/legacyLinesDiffComputer.js": +/*!*****************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/legacyLinesDiffComputer.js ***! + \*****************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DiffComputer: () => (/* binding */ DiffComputer), +/* harmony export */ LegacyLinesDiffComputer: () => (/* binding */ LegacyLinesDiffComputer) +/* harmony export */ }); +/* harmony import */ var _base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/diff/diff.js */ "./node_modules/monaco-editor/esm/vs/base/common/diff/diff.js"); +/* harmony import */ var _linesDiffComputer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./linesDiffComputer.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputer.js"); +/* harmony import */ var _rangeMapping_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./rangeMapping.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/rangeMapping.js"); +/* harmony import */ var _base_common_strings_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../base/common/strings.js */ "./node_modules/monaco-editor/esm/vs/base/common/strings.js"); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _base_common_assert_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../../base/common/assert.js */ "./node_modules/monaco-editor/esm/vs/base/common/assert.js"); +/* harmony import */ var _core_lineRange_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../core/lineRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + + + +const MINIMUM_MATCHING_CHARACTER_LENGTH = 3; +class LegacyLinesDiffComputer { + computeDiff(originalLines, modifiedLines, options) { + var _a; + const diffComputer = new DiffComputer(originalLines, modifiedLines, { + maxComputationTime: options.maxComputationTimeMs, + shouldIgnoreTrimWhitespace: options.ignoreTrimWhitespace, + shouldComputeCharChanges: true, + shouldMakePrettyDiff: true, + shouldPostProcessCharChanges: true, + }); + const result = diffComputer.computeDiff(); + const changes = []; + let lastChange = null; + for (const c of result.changes) { + let originalRange; + if (c.originalEndLineNumber === 0) { + // Insertion + originalRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_6__.LineRange(c.originalStartLineNumber + 1, c.originalStartLineNumber + 1); + } + else { + originalRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_6__.LineRange(c.originalStartLineNumber, c.originalEndLineNumber + 1); + } + let modifiedRange; + if (c.modifiedEndLineNumber === 0) { + // Deletion + modifiedRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_6__.LineRange(c.modifiedStartLineNumber + 1, c.modifiedStartLineNumber + 1); + } + else { + modifiedRange = new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_6__.LineRange(c.modifiedStartLineNumber, c.modifiedEndLineNumber + 1); + } + let change = new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_2__.DetailedLineRangeMapping(originalRange, modifiedRange, (_a = c.charChanges) === null || _a === void 0 ? void 0 : _a.map(c => new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_2__.RangeMapping(new _core_range_js__WEBPACK_IMPORTED_MODULE_4__.Range(c.originalStartLineNumber, c.originalStartColumn, c.originalEndLineNumber, c.originalEndColumn), new _core_range_js__WEBPACK_IMPORTED_MODULE_4__.Range(c.modifiedStartLineNumber, c.modifiedStartColumn, c.modifiedEndLineNumber, c.modifiedEndColumn)))); + if (lastChange) { + if (lastChange.modified.endLineNumberExclusive === change.modified.startLineNumber + || lastChange.original.endLineNumberExclusive === change.original.startLineNumber) { + // join touching diffs. Probably moving diffs up/down in the algorithm causes touching diffs. + change = new _rangeMapping_js__WEBPACK_IMPORTED_MODULE_2__.DetailedLineRangeMapping(lastChange.original.join(change.original), lastChange.modified.join(change.modified), lastChange.innerChanges && change.innerChanges ? + lastChange.innerChanges.concat(change.innerChanges) : undefined); + changes.pop(); + } + } + changes.push(change); + lastChange = change; + } + (0,_base_common_assert_js__WEBPACK_IMPORTED_MODULE_5__.assertFn)(() => { + return (0,_base_common_assert_js__WEBPACK_IMPORTED_MODULE_5__.checkAdjacentItems)(changes, (m1, m2) => m2.original.startLineNumber - m1.original.endLineNumberExclusive === m2.modified.startLineNumber - m1.modified.endLineNumberExclusive && + // There has to be an unchanged line in between (otherwise both diffs should have been joined) + m1.original.endLineNumberExclusive < m2.original.startLineNumber && + m1.modified.endLineNumberExclusive < m2.modified.startLineNumber); + }); + return new _linesDiffComputer_js__WEBPACK_IMPORTED_MODULE_1__.LinesDiff(changes, [], result.quitEarly); + } +} +function computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) { + const diffAlgo = new _base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_0__.LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate); + return diffAlgo.ComputeDiff(pretty); +} +class LineSequence { + constructor(lines) { + const startColumns = []; + const endColumns = []; + for (let i = 0, length = lines.length; i < length; i++) { + startColumns[i] = getFirstNonBlankColumn(lines[i], 1); + endColumns[i] = getLastNonBlankColumn(lines[i], 1); + } + this.lines = lines; + this._startColumns = startColumns; + this._endColumns = endColumns; + } + getElements() { + const elements = []; + for (let i = 0, len = this.lines.length; i < len; i++) { + elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1); + } + return elements; + } + getStrictElement(index) { + return this.lines[index]; + } + getStartLineNumber(i) { + return i + 1; + } + getEndLineNumber(i) { + return i + 1; + } + createCharSequence(shouldIgnoreTrimWhitespace, startIndex, endIndex) { + const charCodes = []; + const lineNumbers = []; + const columns = []; + let len = 0; + for (let index = startIndex; index <= endIndex; index++) { + const lineContent = this.lines[index]; + const startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1); + const endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1); + for (let col = startColumn; col < endColumn; col++) { + charCodes[len] = lineContent.charCodeAt(col - 1); + lineNumbers[len] = index + 1; + columns[len] = col; + len++; + } + if (!shouldIgnoreTrimWhitespace && index < endIndex) { + // Add \n if trim whitespace is not ignored + charCodes[len] = 10 /* CharCode.LineFeed */; + lineNumbers[len] = index + 1; + columns[len] = lineContent.length + 1; + len++; + } + } + return new CharSequence(charCodes, lineNumbers, columns); + } +} +class CharSequence { + constructor(charCodes, lineNumbers, columns) { + this._charCodes = charCodes; + this._lineNumbers = lineNumbers; + this._columns = columns; + } + toString() { + return ('[' + this._charCodes.map((s, idx) => (s === 10 /* CharCode.LineFeed */ ? '\\n' : String.fromCharCode(s)) + `-(${this._lineNumbers[idx]},${this._columns[idx]})`).join(', ') + ']'); + } + _assertIndex(index, arr) { + if (index < 0 || index >= arr.length) { + throw new Error(`Illegal index`); + } + } + getElements() { + return this._charCodes; + } + getStartLineNumber(i) { + if (i > 0 && i === this._lineNumbers.length) { + // the start line number of the element after the last element + // is the end line number of the last element + return this.getEndLineNumber(i - 1); + } + this._assertIndex(i, this._lineNumbers); + return this._lineNumbers[i]; + } + getEndLineNumber(i) { + if (i === -1) { + // the end line number of the element before the first element + // is the start line number of the first element + return this.getStartLineNumber(i + 1); + } + this._assertIndex(i, this._lineNumbers); + if (this._charCodes[i] === 10 /* CharCode.LineFeed */) { + return this._lineNumbers[i] + 1; + } + return this._lineNumbers[i]; + } + getStartColumn(i) { + if (i > 0 && i === this._columns.length) { + // the start column of the element after the last element + // is the end column of the last element + return this.getEndColumn(i - 1); + } + this._assertIndex(i, this._columns); + return this._columns[i]; + } + getEndColumn(i) { + if (i === -1) { + // the end column of the element before the first element + // is the start column of the first element + return this.getStartColumn(i + 1); + } + this._assertIndex(i, this._columns); + if (this._charCodes[i] === 10 /* CharCode.LineFeed */) { + return 1; + } + return this._columns[i] + 1; + } +} +class CharChange { + constructor(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) { + this.originalStartLineNumber = originalStartLineNumber; + this.originalStartColumn = originalStartColumn; + this.originalEndLineNumber = originalEndLineNumber; + this.originalEndColumn = originalEndColumn; + this.modifiedStartLineNumber = modifiedStartLineNumber; + this.modifiedStartColumn = modifiedStartColumn; + this.modifiedEndLineNumber = modifiedEndLineNumber; + this.modifiedEndColumn = modifiedEndColumn; + } + static createFromDiffChange(diffChange, originalCharSequence, modifiedCharSequence) { + const originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart); + const originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart); + const originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1); + const originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1); + const modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart); + const modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart); + const modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1); + const modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1); + return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn); + } +} +function postProcessCharChanges(rawChanges) { + if (rawChanges.length <= 1) { + return rawChanges; + } + const result = [rawChanges[0]]; + let prevChange = result[0]; + for (let i = 1, len = rawChanges.length; i < len; i++) { + const currChange = rawChanges[i]; + const originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength); + const modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength); + // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true + const matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength); + if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) { + // Merge the current change into the previous one + prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart; + prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart; + } + else { + // Add the current change + result.push(currChange); + prevChange = currChange; + } + } + return result; +} +class LineChange { + constructor(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) { + this.originalStartLineNumber = originalStartLineNumber; + this.originalEndLineNumber = originalEndLineNumber; + this.modifiedStartLineNumber = modifiedStartLineNumber; + this.modifiedEndLineNumber = modifiedEndLineNumber; + this.charChanges = charChanges; + } + static createFromDiffResult(shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) { + let originalStartLineNumber; + let originalEndLineNumber; + let modifiedStartLineNumber; + let modifiedEndLineNumber; + let charChanges = undefined; + if (diffChange.originalLength === 0) { + originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1; + originalEndLineNumber = 0; + } + else { + originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart); + originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1); + } + if (diffChange.modifiedLength === 0) { + modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1; + modifiedEndLineNumber = 0; + } + else { + modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart); + modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1); + } + if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) { + // Compute character changes for diff chunks of at most 20 lines... + const originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1); + const modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1); + if (originalCharSequence.getElements().length > 0 && modifiedCharSequence.getElements().length > 0) { + let rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes; + if (shouldPostProcessCharChanges) { + rawChanges = postProcessCharChanges(rawChanges); + } + charChanges = []; + for (let i = 0, length = rawChanges.length; i < length; i++) { + charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence)); + } + } + } + return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges); + } +} +class DiffComputer { + constructor(originalLines, modifiedLines, opts) { + this.shouldComputeCharChanges = opts.shouldComputeCharChanges; + this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges; + this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace; + this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff; + this.originalLines = originalLines; + this.modifiedLines = modifiedLines; + this.original = new LineSequence(originalLines); + this.modified = new LineSequence(modifiedLines); + this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime); + this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes... + } + computeDiff() { + if (this.original.lines.length === 1 && this.original.lines[0].length === 0) { + // empty original => fast path + if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) { + return { + quitEarly: false, + changes: [] + }; + } + return { + quitEarly: false, + changes: [{ + originalStartLineNumber: 1, + originalEndLineNumber: 1, + modifiedStartLineNumber: 1, + modifiedEndLineNumber: this.modified.lines.length, + charChanges: undefined + }] + }; + } + if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) { + // empty modified => fast path + return { + quitEarly: false, + changes: [{ + originalStartLineNumber: 1, + originalEndLineNumber: this.original.lines.length, + modifiedStartLineNumber: 1, + modifiedEndLineNumber: 1, + charChanges: undefined + }] + }; + } + const diffResult = computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff); + const rawChanges = diffResult.changes; + const quitEarly = diffResult.quitEarly; + // The diff is always computed with ignoring trim whitespace + // This ensures we get the prettiest diff + if (this.shouldIgnoreTrimWhitespace) { + const lineChanges = []; + for (let i = 0, length = rawChanges.length; i < length; i++) { + lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges)); + } + return { + quitEarly: quitEarly, + changes: lineChanges + }; + } + // Need to post-process and introduce changes where the trim whitespace is different + // Note that we are looping starting at -1 to also cover the lines before the first change + const result = []; + let originalLineIndex = 0; + let modifiedLineIndex = 0; + for (let i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) { + const nextChange = (i + 1 < len ? rawChanges[i + 1] : null); + const originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length); + const modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length); + while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) { + const originalLine = this.originalLines[originalLineIndex]; + const modifiedLine = this.modifiedLines[modifiedLineIndex]; + if (originalLine !== modifiedLine) { + // These lines differ only in trim whitespace + // Check the leading whitespace + { + let originalStartColumn = getFirstNonBlankColumn(originalLine, 1); + let modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1); + while (originalStartColumn > 1 && modifiedStartColumn > 1) { + const originalChar = originalLine.charCodeAt(originalStartColumn - 2); + const modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2); + if (originalChar !== modifiedChar) { + break; + } + originalStartColumn--; + modifiedStartColumn--; + } + if (originalStartColumn > 1 || modifiedStartColumn > 1) { + this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn); + } + } + // Check the trailing whitespace + { + let originalEndColumn = getLastNonBlankColumn(originalLine, 1); + let modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1); + const originalMaxColumn = originalLine.length + 1; + const modifiedMaxColumn = modifiedLine.length + 1; + while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) { + const originalChar = originalLine.charCodeAt(originalEndColumn - 1); + const modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1); + if (originalChar !== modifiedChar) { + break; + } + originalEndColumn++; + modifiedEndColumn++; + } + if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) { + this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn); + } + } + } + originalLineIndex++; + modifiedLineIndex++; + } + if (nextChange) { + // Emit the actual change + result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges)); + originalLineIndex += nextChange.originalLength; + modifiedLineIndex += nextChange.modifiedLength; + } + } + return { + quitEarly: quitEarly, + changes: result + }; + } + _pushTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) { + if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) { + // Merged into previous + return; + } + let charChanges = undefined; + if (this.shouldComputeCharChanges) { + charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)]; + } + result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges)); + } + _mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) { + const len = result.length; + if (len === 0) { + return false; + } + const prevChange = result[len - 1]; + if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) { + // Don't merge with inserts/deletes + return false; + } + if (prevChange.originalEndLineNumber === originalLineNumber && prevChange.modifiedEndLineNumber === modifiedLineNumber) { + if (this.shouldComputeCharChanges && prevChange.charChanges) { + prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)); + } + return true; + } + if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) { + prevChange.originalEndLineNumber = originalLineNumber; + prevChange.modifiedEndLineNumber = modifiedLineNumber; + if (this.shouldComputeCharChanges && prevChange.charChanges) { + prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)); + } + return true; + } + return false; + } +} +function getFirstNonBlankColumn(txt, defaultValue) { + const r = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_3__.firstNonWhitespaceIndex(txt); + if (r === -1) { + return defaultValue; + } + return r + 1; +} +function getLastNonBlankColumn(txt, defaultValue) { + const r = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_3__.lastNonWhitespaceIndex(txt); + if (r === -1) { + return defaultValue; + } + return r + 2; +} +function createContinueProcessingPredicate(maximumRuntime) { + if (maximumRuntime === 0) { + return () => true; + } + const startTime = Date.now(); + return () => { + return Date.now() - startTime < maximumRuntime; + }; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputer.js": +/*!***********************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputer.js ***! + \***********************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LinesDiff: () => (/* binding */ LinesDiff), +/* harmony export */ MovedText: () => (/* binding */ MovedText) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +class LinesDiff { + constructor(changes, + /** + * Sorted by original line ranges. + * The original line ranges and the modified line ranges must be disjoint (but can be touching). + */ + moves, + /** + * Indicates if the time out was reached. + * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time. + */ + hitTimeout) { + this.changes = changes; + this.moves = moves; + this.hitTimeout = hitTimeout; + } +} +class MovedText { + constructor(lineRangeMapping, changes) { + this.lineRangeMapping = lineRangeMapping; + this.changes = changes; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputers.js": +/*!************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputers.js ***! + \************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ linesDiffComputers: () => (/* binding */ linesDiffComputers) +/* harmony export */ }); +/* harmony import */ var _legacyLinesDiffComputer_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./legacyLinesDiffComputer.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/legacyLinesDiffComputer.js"); +/* harmony import */ var _defaultLinesDiffComputer_defaultLinesDiffComputer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./defaultLinesDiffComputer/defaultLinesDiffComputer.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +const linesDiffComputers = { + getLegacy: () => new _legacyLinesDiffComputer_js__WEBPACK_IMPORTED_MODULE_0__.LegacyLinesDiffComputer(), + getDefault: () => new _defaultLinesDiffComputer_defaultLinesDiffComputer_js__WEBPACK_IMPORTED_MODULE_1__.DefaultLinesDiffComputer(), +}; + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/diff/rangeMapping.js": +/*!******************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/diff/rangeMapping.js ***! + \******************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DetailedLineRangeMapping: () => (/* binding */ DetailedLineRangeMapping), +/* harmony export */ LineRangeMapping: () => (/* binding */ LineRangeMapping), +/* harmony export */ RangeMapping: () => (/* binding */ RangeMapping) +/* harmony export */ }); +/* harmony import */ var _core_lineRange_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/lineRange.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * Maps a line range in the original text model to a line range in the modified text model. + */ +class LineRangeMapping { + static inverse(mapping, originalLineCount, modifiedLineCount) { + const result = []; + let lastOriginalEndLineNumber = 1; + let lastModifiedEndLineNumber = 1; + for (const m of mapping) { + const r = new DetailedLineRangeMapping(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_0__.LineRange(lastOriginalEndLineNumber, m.original.startLineNumber), new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_0__.LineRange(lastModifiedEndLineNumber, m.modified.startLineNumber), undefined); + if (!r.modified.isEmpty) { + result.push(r); + } + lastOriginalEndLineNumber = m.original.endLineNumberExclusive; + lastModifiedEndLineNumber = m.modified.endLineNumberExclusive; + } + const r = new DetailedLineRangeMapping(new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_0__.LineRange(lastOriginalEndLineNumber, originalLineCount + 1), new _core_lineRange_js__WEBPACK_IMPORTED_MODULE_0__.LineRange(lastModifiedEndLineNumber, modifiedLineCount + 1), undefined); + if (!r.modified.isEmpty) { + result.push(r); + } + return result; + } + constructor(originalRange, modifiedRange) { + this.original = originalRange; + this.modified = modifiedRange; + } + toString() { + return `{${this.original.toString()}->${this.modified.toString()}}`; + } + flip() { + return new LineRangeMapping(this.modified, this.original); + } + join(other) { + return new LineRangeMapping(this.original.join(other.original), this.modified.join(other.modified)); + } +} +/** + * Maps a line range in the original text model to a line range in the modified text model. + * Also contains inner range mappings. + */ +class DetailedLineRangeMapping extends LineRangeMapping { + constructor(originalRange, modifiedRange, innerChanges) { + super(originalRange, modifiedRange); + this.innerChanges = innerChanges; + } + flip() { + var _a; + return new DetailedLineRangeMapping(this.modified, this.original, (_a = this.innerChanges) === null || _a === void 0 ? void 0 : _a.map(c => c.flip())); + } +} +/** + * Maps a range in the original text model to a range in the modified text model. + */ +class RangeMapping { + constructor(originalRange, modifiedRange) { + this.originalRange = originalRange; + this.modifiedRange = modifiedRange; + } + toString() { + return `{${this.originalRange.toString()}->${this.modifiedRange.toString()}}`; + } + flip() { + return new RangeMapping(this.modifiedRange, this.originalRange); + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/languages.js": +/*!**********************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/languages.js ***! + \**********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Command: () => (/* binding */ Command), +/* harmony export */ CompletionItemKinds: () => (/* binding */ CompletionItemKinds), +/* harmony export */ DocumentHighlightKind: () => (/* binding */ DocumentHighlightKind), +/* harmony export */ EncodedTokenizationResult: () => (/* binding */ EncodedTokenizationResult), +/* harmony export */ FoldingRangeKind: () => (/* binding */ FoldingRangeKind), +/* harmony export */ InlayHintKind: () => (/* binding */ InlayHintKind), +/* harmony export */ InlineCompletionTriggerKind: () => (/* binding */ InlineCompletionTriggerKind), +/* harmony export */ LazyTokenizationSupport: () => (/* binding */ LazyTokenizationSupport), +/* harmony export */ SelectedSuggestionInfo: () => (/* binding */ SelectedSuggestionInfo), +/* harmony export */ SignatureHelpTriggerKind: () => (/* binding */ SignatureHelpTriggerKind), +/* harmony export */ SymbolKinds: () => (/* binding */ SymbolKinds), +/* harmony export */ TextEdit: () => (/* binding */ TextEdit), +/* harmony export */ Token: () => (/* binding */ Token), +/* harmony export */ TokenizationRegistry: () => (/* binding */ TokenizationRegistry), +/* harmony export */ TokenizationResult: () => (/* binding */ TokenizationResult), +/* harmony export */ getAriaLabelForSymbol: () => (/* binding */ getAriaLabelForSymbol), +/* harmony export */ isLocationLink: () => (/* binding */ isLocationLink), +/* harmony export */ symbolKindNames: () => (/* binding */ symbolKindNames) +/* harmony export */ }); +/* harmony import */ var _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../base/common/codicons.js */ "./node_modules/monaco-editor/esm/vs/base/common/codicons.js"); +/* harmony import */ var _base_common_uri_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../base/common/uri.js */ "./node_modules/monaco-editor/esm/vs/base/common/uri.js"); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _tokenizationRegistry_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./tokenizationRegistry.js */ "./node_modules/monaco-editor/esm/vs/editor/common/tokenizationRegistry.js"); +/* harmony import */ var _nls_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../nls.js */ "./node_modules/monaco-editor/esm/vs/nls.js"); + + + + + +class Token { + constructor(offset, type, language) { + this.offset = offset; + this.type = type; + this.language = language; + this._tokenBrand = undefined; + } + toString() { + return '(' + this.offset + ', ' + this.type + ')'; + } +} +/** + * @internal + */ +class TokenizationResult { + constructor(tokens, endState) { + this.tokens = tokens; + this.endState = endState; + this._tokenizationResultBrand = undefined; + } +} +/** + * @internal + */ +class EncodedTokenizationResult { + constructor( + /** + * The tokens in binary format. Each token occupies two array indices. For token i: + * - at offset 2*i => startIndex + * - at offset 2*i + 1 => metadata + * + */ + tokens, endState) { + this.tokens = tokens; + this.endState = endState; + this._encodedTokenizationResultBrand = undefined; + } +} +/** + * @internal + */ +var CompletionItemKinds; +(function (CompletionItemKinds) { + const byKind = new Map(); + byKind.set(0 /* CompletionItemKind.Method */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolMethod); + byKind.set(1 /* CompletionItemKind.Function */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolFunction); + byKind.set(2 /* CompletionItemKind.Constructor */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolConstructor); + byKind.set(3 /* CompletionItemKind.Field */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolField); + byKind.set(4 /* CompletionItemKind.Variable */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolVariable); + byKind.set(5 /* CompletionItemKind.Class */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolClass); + byKind.set(6 /* CompletionItemKind.Struct */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolStruct); + byKind.set(7 /* CompletionItemKind.Interface */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolInterface); + byKind.set(8 /* CompletionItemKind.Module */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolModule); + byKind.set(9 /* CompletionItemKind.Property */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolProperty); + byKind.set(10 /* CompletionItemKind.Event */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolEvent); + byKind.set(11 /* CompletionItemKind.Operator */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolOperator); + byKind.set(12 /* CompletionItemKind.Unit */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolUnit); + byKind.set(13 /* CompletionItemKind.Value */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolValue); + byKind.set(15 /* CompletionItemKind.Enum */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolEnum); + byKind.set(14 /* CompletionItemKind.Constant */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolConstant); + byKind.set(15 /* CompletionItemKind.Enum */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolEnum); + byKind.set(16 /* CompletionItemKind.EnumMember */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolEnumMember); + byKind.set(17 /* CompletionItemKind.Keyword */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolKeyword); + byKind.set(27 /* CompletionItemKind.Snippet */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolSnippet); + byKind.set(18 /* CompletionItemKind.Text */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolText); + byKind.set(19 /* CompletionItemKind.Color */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolColor); + byKind.set(20 /* CompletionItemKind.File */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolFile); + byKind.set(21 /* CompletionItemKind.Reference */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolReference); + byKind.set(22 /* CompletionItemKind.Customcolor */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolCustomColor); + byKind.set(23 /* CompletionItemKind.Folder */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolFolder); + byKind.set(24 /* CompletionItemKind.TypeParameter */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolTypeParameter); + byKind.set(25 /* CompletionItemKind.User */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.account); + byKind.set(26 /* CompletionItemKind.Issue */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.issues); + /** + * @internal + */ + function toIcon(kind) { + let codicon = byKind.get(kind); + if (!codicon) { + console.info('No codicon found for CompletionItemKind ' + kind); + codicon = _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolProperty; + } + return codicon; + } + CompletionItemKinds.toIcon = toIcon; + const data = new Map(); + data.set('method', 0 /* CompletionItemKind.Method */); + data.set('function', 1 /* CompletionItemKind.Function */); + data.set('constructor', 2 /* CompletionItemKind.Constructor */); + data.set('field', 3 /* CompletionItemKind.Field */); + data.set('variable', 4 /* CompletionItemKind.Variable */); + data.set('class', 5 /* CompletionItemKind.Class */); + data.set('struct', 6 /* CompletionItemKind.Struct */); + data.set('interface', 7 /* CompletionItemKind.Interface */); + data.set('module', 8 /* CompletionItemKind.Module */); + data.set('property', 9 /* CompletionItemKind.Property */); + data.set('event', 10 /* CompletionItemKind.Event */); + data.set('operator', 11 /* CompletionItemKind.Operator */); + data.set('unit', 12 /* CompletionItemKind.Unit */); + data.set('value', 13 /* CompletionItemKind.Value */); + data.set('constant', 14 /* CompletionItemKind.Constant */); + data.set('enum', 15 /* CompletionItemKind.Enum */); + data.set('enum-member', 16 /* CompletionItemKind.EnumMember */); + data.set('enumMember', 16 /* CompletionItemKind.EnumMember */); + data.set('keyword', 17 /* CompletionItemKind.Keyword */); + data.set('snippet', 27 /* CompletionItemKind.Snippet */); + data.set('text', 18 /* CompletionItemKind.Text */); + data.set('color', 19 /* CompletionItemKind.Color */); + data.set('file', 20 /* CompletionItemKind.File */); + data.set('reference', 21 /* CompletionItemKind.Reference */); + data.set('customcolor', 22 /* CompletionItemKind.Customcolor */); + data.set('folder', 23 /* CompletionItemKind.Folder */); + data.set('type-parameter', 24 /* CompletionItemKind.TypeParameter */); + data.set('typeParameter', 24 /* CompletionItemKind.TypeParameter */); + data.set('account', 25 /* CompletionItemKind.User */); + data.set('issue', 26 /* CompletionItemKind.Issue */); + /** + * @internal + */ + function fromString(value, strict) { + let res = data.get(value); + if (typeof res === 'undefined' && !strict) { + res = 9 /* CompletionItemKind.Property */; + } + return res; + } + CompletionItemKinds.fromString = fromString; +})(CompletionItemKinds || (CompletionItemKinds = {})); +/** + * How an {@link InlineCompletionsProvider inline completion provider} was triggered. + */ +var InlineCompletionTriggerKind; +(function (InlineCompletionTriggerKind) { + /** + * Completion was triggered automatically while editing. + * It is sufficient to return a single completion item in this case. + */ + InlineCompletionTriggerKind[InlineCompletionTriggerKind["Automatic"] = 0] = "Automatic"; + /** + * Completion was triggered explicitly by a user gesture. + * Return multiple completion items to enable cycling through them. + */ + InlineCompletionTriggerKind[InlineCompletionTriggerKind["Explicit"] = 1] = "Explicit"; +})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {})); +class SelectedSuggestionInfo { + constructor(range, text, completionKind, isSnippetText) { + this.range = range; + this.text = text; + this.completionKind = completionKind; + this.isSnippetText = isSnippetText; + } + equals(other) { + return _core_range_js__WEBPACK_IMPORTED_MODULE_2__.Range.lift(this.range).equalsRange(other.range) + && this.text === other.text + && this.completionKind === other.completionKind + && this.isSnippetText === other.isSnippetText; + } +} +var SignatureHelpTriggerKind; +(function (SignatureHelpTriggerKind) { + SignatureHelpTriggerKind[SignatureHelpTriggerKind["Invoke"] = 1] = "Invoke"; + SignatureHelpTriggerKind[SignatureHelpTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter"; + SignatureHelpTriggerKind[SignatureHelpTriggerKind["ContentChange"] = 3] = "ContentChange"; +})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {})); +/** + * A document highlight kind. + */ +var DocumentHighlightKind; +(function (DocumentHighlightKind) { + /** + * A textual occurrence. + */ + DocumentHighlightKind[DocumentHighlightKind["Text"] = 0] = "Text"; + /** + * Read-access of a symbol, like reading a variable. + */ + DocumentHighlightKind[DocumentHighlightKind["Read"] = 1] = "Read"; + /** + * Write-access of a symbol, like writing to a variable. + */ + DocumentHighlightKind[DocumentHighlightKind["Write"] = 2] = "Write"; +})(DocumentHighlightKind || (DocumentHighlightKind = {})); +/** + * @internal + */ +function isLocationLink(thing) { + return thing + && _base_common_uri_js__WEBPACK_IMPORTED_MODULE_1__.URI.isUri(thing.uri) + && _core_range_js__WEBPACK_IMPORTED_MODULE_2__.Range.isIRange(thing.range) + && (_core_range_js__WEBPACK_IMPORTED_MODULE_2__.Range.isIRange(thing.originSelectionRange) || _core_range_js__WEBPACK_IMPORTED_MODULE_2__.Range.isIRange(thing.targetSelectionRange)); +} +/** + * @internal + */ +const symbolKindNames = { + [17 /* SymbolKind.Array */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Array', "array"), + [16 /* SymbolKind.Boolean */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Boolean', "boolean"), + [4 /* SymbolKind.Class */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Class', "class"), + [13 /* SymbolKind.Constant */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Constant', "constant"), + [8 /* SymbolKind.Constructor */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Constructor', "constructor"), + [9 /* SymbolKind.Enum */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Enum', "enumeration"), + [21 /* SymbolKind.EnumMember */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('EnumMember', "enumeration member"), + [23 /* SymbolKind.Event */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Event', "event"), + [7 /* SymbolKind.Field */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Field', "field"), + [0 /* SymbolKind.File */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('File', "file"), + [11 /* SymbolKind.Function */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Function', "function"), + [10 /* SymbolKind.Interface */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Interface', "interface"), + [19 /* SymbolKind.Key */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Key', "key"), + [5 /* SymbolKind.Method */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Method', "method"), + [1 /* SymbolKind.Module */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Module', "module"), + [2 /* SymbolKind.Namespace */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Namespace', "namespace"), + [20 /* SymbolKind.Null */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Null', "null"), + [15 /* SymbolKind.Number */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Number', "number"), + [18 /* SymbolKind.Object */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Object', "object"), + [24 /* SymbolKind.Operator */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Operator', "operator"), + [3 /* SymbolKind.Package */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Package', "package"), + [6 /* SymbolKind.Property */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Property', "property"), + [14 /* SymbolKind.String */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('String', "string"), + [22 /* SymbolKind.Struct */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Struct', "struct"), + [25 /* SymbolKind.TypeParameter */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('TypeParameter', "type parameter"), + [12 /* SymbolKind.Variable */]: (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('Variable', "variable"), +}; +/** + * @internal + */ +function getAriaLabelForSymbol(symbolName, kind) { + return (0,_nls_js__WEBPACK_IMPORTED_MODULE_4__.localize)('symbolAriaLabel', '{0} ({1})', symbolName, symbolKindNames[kind]); +} +/** + * @internal + */ +var SymbolKinds; +(function (SymbolKinds) { + const byKind = new Map(); + byKind.set(0 /* SymbolKind.File */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolFile); + byKind.set(1 /* SymbolKind.Module */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolModule); + byKind.set(2 /* SymbolKind.Namespace */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolNamespace); + byKind.set(3 /* SymbolKind.Package */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolPackage); + byKind.set(4 /* SymbolKind.Class */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolClass); + byKind.set(5 /* SymbolKind.Method */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolMethod); + byKind.set(6 /* SymbolKind.Property */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolProperty); + byKind.set(7 /* SymbolKind.Field */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolField); + byKind.set(8 /* SymbolKind.Constructor */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolConstructor); + byKind.set(9 /* SymbolKind.Enum */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolEnum); + byKind.set(10 /* SymbolKind.Interface */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolInterface); + byKind.set(11 /* SymbolKind.Function */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolFunction); + byKind.set(12 /* SymbolKind.Variable */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolVariable); + byKind.set(13 /* SymbolKind.Constant */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolConstant); + byKind.set(14 /* SymbolKind.String */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolString); + byKind.set(15 /* SymbolKind.Number */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolNumber); + byKind.set(16 /* SymbolKind.Boolean */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolBoolean); + byKind.set(17 /* SymbolKind.Array */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolArray); + byKind.set(18 /* SymbolKind.Object */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolObject); + byKind.set(19 /* SymbolKind.Key */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolKey); + byKind.set(20 /* SymbolKind.Null */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolNull); + byKind.set(21 /* SymbolKind.EnumMember */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolEnumMember); + byKind.set(22 /* SymbolKind.Struct */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolStruct); + byKind.set(23 /* SymbolKind.Event */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolEvent); + byKind.set(24 /* SymbolKind.Operator */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolOperator); + byKind.set(25 /* SymbolKind.TypeParameter */, _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolTypeParameter); + /** + * @internal + */ + function toIcon(kind) { + let icon = byKind.get(kind); + if (!icon) { + console.info('No codicon found for SymbolKind ' + kind); + icon = _base_common_codicons_js__WEBPACK_IMPORTED_MODULE_0__.Codicon.symbolProperty; + } + return icon; + } + SymbolKinds.toIcon = toIcon; +})(SymbolKinds || (SymbolKinds = {})); +/** @internal */ +class TextEdit { +} +class FoldingRangeKind { + /** + * Returns a {@link FoldingRangeKind} for the given value. + * + * @param value of the kind. + */ + static fromValue(value) { + switch (value) { + case 'comment': return FoldingRangeKind.Comment; + case 'imports': return FoldingRangeKind.Imports; + case 'region': return FoldingRangeKind.Region; + } + return new FoldingRangeKind(value); + } + /** + * Creates a new {@link FoldingRangeKind}. + * + * @param value of the kind. + */ + constructor(value) { + this.value = value; + } +} +/** + * Kind for folding range representing a comment. The value of the kind is 'comment'. + */ +FoldingRangeKind.Comment = new FoldingRangeKind('comment'); +/** + * Kind for folding range representing a import. The value of the kind is 'imports'. + */ +FoldingRangeKind.Imports = new FoldingRangeKind('imports'); +/** + * Kind for folding range representing regions (for example marked by `#region`, `#endregion`). + * The value of the kind is 'region'. + */ +FoldingRangeKind.Region = new FoldingRangeKind('region'); +/** + * @internal + */ +var Command; +(function (Command) { + /** + * @internal + */ + function is(obj) { + if (!obj || typeof obj !== 'object') { + return false; + } + return typeof obj.id === 'string' && + typeof obj.title === 'string'; + } + Command.is = is; +})(Command || (Command = {})); +var InlayHintKind; +(function (InlayHintKind) { + InlayHintKind[InlayHintKind["Type"] = 1] = "Type"; + InlayHintKind[InlayHintKind["Parameter"] = 2] = "Parameter"; +})(InlayHintKind || (InlayHintKind = {})); +/** + * @internal + */ +class LazyTokenizationSupport { + constructor(createSupport) { + this.createSupport = createSupport; + this._tokenizationSupport = null; + } + dispose() { + if (this._tokenizationSupport) { + this._tokenizationSupport.then((support) => { + if (support) { + support.dispose(); + } + }); + } + } + get tokenizationSupport() { + if (!this._tokenizationSupport) { + this._tokenizationSupport = this.createSupport(); + } + return this._tokenizationSupport; + } +} +/** + * @internal + */ +const TokenizationRegistry = new _tokenizationRegistry_js__WEBPACK_IMPORTED_MODULE_3__.TokenizationRegistry(); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/languages/defaultDocumentColorsComputer.js": +/*!****************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/languages/defaultDocumentColorsComputer.js ***! + \****************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ computeDefaultDocumentColors: () => (/* binding */ computeDefaultDocumentColors) +/* harmony export */ }); +/* harmony import */ var _base_common_color_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/color.js */ "./node_modules/monaco-editor/esm/vs/base/common/color.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +function _parseCaptureGroups(captureGroups) { + const values = []; + for (const captureGroup of captureGroups) { + const parsedNumber = Number(captureGroup); + if (parsedNumber || parsedNumber === 0 && captureGroup.replace(/\s/g, '') !== '') { + values.push(parsedNumber); + } + } + return values; +} +function _toIColor(r, g, b, a) { + return { + red: r / 255, + blue: b / 255, + green: g / 255, + alpha: a + }; +} +function _findRange(model, match) { + const index = match.index; + const length = match[0].length; + if (!index) { + return; + } + const startPosition = model.positionAt(index); + const range = { + startLineNumber: startPosition.lineNumber, + startColumn: startPosition.column, + endLineNumber: startPosition.lineNumber, + endColumn: startPosition.column + length + }; + return range; +} +function _findHexColorInformation(range, hexValue) { + if (!range) { + return; + } + const parsedHexColor = _base_common_color_js__WEBPACK_IMPORTED_MODULE_0__.Color.Format.CSS.parseHex(hexValue); + if (!parsedHexColor) { + return; + } + return { + range: range, + color: _toIColor(parsedHexColor.rgba.r, parsedHexColor.rgba.g, parsedHexColor.rgba.b, parsedHexColor.rgba.a) + }; +} +function _findRGBColorInformation(range, matches, isAlpha) { + if (!range || matches.length !== 1) { + return; + } + const match = matches[0]; + const captureGroups = match.values(); + const parsedRegex = _parseCaptureGroups(captureGroups); + return { + range: range, + color: _toIColor(parsedRegex[0], parsedRegex[1], parsedRegex[2], isAlpha ? parsedRegex[3] : 1) + }; +} +function _findHSLColorInformation(range, matches, isAlpha) { + if (!range || matches.length !== 1) { + return; + } + const match = matches[0]; + const captureGroups = match.values(); + const parsedRegex = _parseCaptureGroups(captureGroups); + const colorEquivalent = new _base_common_color_js__WEBPACK_IMPORTED_MODULE_0__.Color(new _base_common_color_js__WEBPACK_IMPORTED_MODULE_0__.HSLA(parsedRegex[0], parsedRegex[1] / 100, parsedRegex[2] / 100, isAlpha ? parsedRegex[3] : 1)); + return { + range: range, + color: _toIColor(colorEquivalent.rgba.r, colorEquivalent.rgba.g, colorEquivalent.rgba.b, colorEquivalent.rgba.a) + }; +} +function _findMatches(model, regex) { + if (typeof model === 'string') { + return [...model.matchAll(regex)]; + } + else { + return model.findMatches(regex); + } +} +function computeColors(model) { + const result = []; + // Early validation for RGB and HSL + const initialValidationRegex = /\b(rgb|rgba|hsl|hsla)(\([0-9\s,.\%]*\))|(#)([A-Fa-f0-9]{3})\b|(#)([A-Fa-f0-9]{4})\b|(#)([A-Fa-f0-9]{6})\b|(#)([A-Fa-f0-9]{8})\b/gm; + const initialValidationMatches = _findMatches(model, initialValidationRegex); + // Potential colors have been found, validate the parameters + if (initialValidationMatches.length > 0) { + for (const initialMatch of initialValidationMatches) { + const initialCaptureGroups = initialMatch.filter(captureGroup => captureGroup !== undefined); + const colorScheme = initialCaptureGroups[1]; + const colorParameters = initialCaptureGroups[2]; + if (!colorParameters) { + continue; + } + let colorInformation; + if (colorScheme === 'rgb') { + const regexParameters = /^\(\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*\)$/gm; + colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false); + } + else if (colorScheme === 'rgba') { + const regexParameters = /^\(\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\s*\)$/gm; + colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true); + } + else if (colorScheme === 'hsl') { + const regexParameters = /^\(\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*\)$/gm; + colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false); + } + else if (colorScheme === 'hsla') { + const regexParameters = /^\(\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*,\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\s*\)$/gm; + colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true); + } + else if (colorScheme === '#') { + colorInformation = _findHexColorInformation(_findRange(model, initialMatch), colorScheme + colorParameters); + } + if (colorInformation) { + result.push(colorInformation); + } + } + } + return result; +} +/** + * Returns an array of all default document colors in the provided document + */ +function computeDefaultDocumentColors(model) { + if (!model || typeof model.getValue !== 'function' || typeof model.positionAt !== 'function') { + // Unknown caller! + return []; + } + return computeColors(model); +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/languages/linkComputer.js": +/*!***********************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/languages/linkComputer.js ***! + \***********************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ LinkComputer: () => (/* binding */ LinkComputer), +/* harmony export */ StateMachine: () => (/* binding */ StateMachine), +/* harmony export */ computeLinks: () => (/* binding */ computeLinks) +/* harmony export */ }); +/* harmony import */ var _core_characterClassifier_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/characterClassifier.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +class Uint8Matrix { + constructor(rows, cols, defaultValue) { + const data = new Uint8Array(rows * cols); + for (let i = 0, len = rows * cols; i < len; i++) { + data[i] = defaultValue; + } + this._data = data; + this.rows = rows; + this.cols = cols; + } + get(row, col) { + return this._data[row * this.cols + col]; + } + set(row, col, value) { + this._data[row * this.cols + col] = value; + } +} +class StateMachine { + constructor(edges) { + let maxCharCode = 0; + let maxState = 0 /* State.Invalid */; + for (let i = 0, len = edges.length; i < len; i++) { + const [from, chCode, to] = edges[i]; + if (chCode > maxCharCode) { + maxCharCode = chCode; + } + if (from > maxState) { + maxState = from; + } + if (to > maxState) { + maxState = to; + } + } + maxCharCode++; + maxState++; + const states = new Uint8Matrix(maxState, maxCharCode, 0 /* State.Invalid */); + for (let i = 0, len = edges.length; i < len; i++) { + const [from, chCode, to] = edges[i]; + states.set(from, chCode, to); + } + this._states = states; + this._maxCharCode = maxCharCode; + } + nextState(currentState, chCode) { + if (chCode < 0 || chCode >= this._maxCharCode) { + return 0 /* State.Invalid */; + } + return this._states.get(currentState, chCode); + } +} +// State machine for http:// or https:// or file:// +let _stateMachine = null; +function getStateMachine() { + if (_stateMachine === null) { + _stateMachine = new StateMachine([ + [1 /* State.Start */, 104 /* CharCode.h */, 2 /* State.H */], + [1 /* State.Start */, 72 /* CharCode.H */, 2 /* State.H */], + [1 /* State.Start */, 102 /* CharCode.f */, 6 /* State.F */], + [1 /* State.Start */, 70 /* CharCode.F */, 6 /* State.F */], + [2 /* State.H */, 116 /* CharCode.t */, 3 /* State.HT */], + [2 /* State.H */, 84 /* CharCode.T */, 3 /* State.HT */], + [3 /* State.HT */, 116 /* CharCode.t */, 4 /* State.HTT */], + [3 /* State.HT */, 84 /* CharCode.T */, 4 /* State.HTT */], + [4 /* State.HTT */, 112 /* CharCode.p */, 5 /* State.HTTP */], + [4 /* State.HTT */, 80 /* CharCode.P */, 5 /* State.HTTP */], + [5 /* State.HTTP */, 115 /* CharCode.s */, 9 /* State.BeforeColon */], + [5 /* State.HTTP */, 83 /* CharCode.S */, 9 /* State.BeforeColon */], + [5 /* State.HTTP */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */], + [6 /* State.F */, 105 /* CharCode.i */, 7 /* State.FI */], + [6 /* State.F */, 73 /* CharCode.I */, 7 /* State.FI */], + [7 /* State.FI */, 108 /* CharCode.l */, 8 /* State.FIL */], + [7 /* State.FI */, 76 /* CharCode.L */, 8 /* State.FIL */], + [8 /* State.FIL */, 101 /* CharCode.e */, 9 /* State.BeforeColon */], + [8 /* State.FIL */, 69 /* CharCode.E */, 9 /* State.BeforeColon */], + [9 /* State.BeforeColon */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */], + [10 /* State.AfterColon */, 47 /* CharCode.Slash */, 11 /* State.AlmostThere */], + [11 /* State.AlmostThere */, 47 /* CharCode.Slash */, 12 /* State.End */], + ]); + } + return _stateMachine; +} +let _classifier = null; +function getClassifier() { + if (_classifier === null) { + _classifier = new _core_characterClassifier_js__WEBPACK_IMPORTED_MODULE_0__.CharacterClassifier(0 /* CharacterClass.None */); + // allow-any-unicode-next-line + const FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…'; + for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) { + _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* CharacterClass.ForceTermination */); + } + const CANNOT_END_WITH_CHARACTERS = '.,;:'; + for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) { + _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CharacterClass.CannotEndIn */); + } + } + return _classifier; +} +class LinkComputer { + static _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) { + // Do not allow to end link in certain characters... + let lastIncludedCharIndex = linkEndIndex - 1; + do { + const chCode = line.charCodeAt(lastIncludedCharIndex); + const chClass = classifier.get(chCode); + if (chClass !== 2 /* CharacterClass.CannotEndIn */) { + break; + } + lastIncludedCharIndex--; + } while (lastIncludedCharIndex > linkBeginIndex); + // Handle links enclosed in parens, square brackets and curlys. + if (linkBeginIndex > 0) { + const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1); + const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex); + if ((charCodeBeforeLink === 40 /* CharCode.OpenParen */ && lastCharCodeInLink === 41 /* CharCode.CloseParen */) + || (charCodeBeforeLink === 91 /* CharCode.OpenSquareBracket */ && lastCharCodeInLink === 93 /* CharCode.CloseSquareBracket */) + || (charCodeBeforeLink === 123 /* CharCode.OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CharCode.CloseCurlyBrace */)) { + // Do not end in ) if ( is before the link start + // Do not end in ] if [ is before the link start + // Do not end in } if { is before the link start + lastIncludedCharIndex--; + } + } + return { + range: { + startLineNumber: lineNumber, + startColumn: linkBeginIndex + 1, + endLineNumber: lineNumber, + endColumn: lastIncludedCharIndex + 2 + }, + url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1) + }; + } + static computeLinks(model, stateMachine = getStateMachine()) { + const classifier = getClassifier(); + const result = []; + for (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) { + const line = model.getLineContent(i); + const len = line.length; + let j = 0; + let linkBeginIndex = 0; + let linkBeginChCode = 0; + let state = 1 /* State.Start */; + let hasOpenParens = false; + let hasOpenSquareBracket = false; + let inSquareBrackets = false; + let hasOpenCurlyBracket = false; + while (j < len) { + let resetStateMachine = false; + const chCode = line.charCodeAt(j); + if (state === 13 /* State.Accept */) { + let chClass; + switch (chCode) { + case 40 /* CharCode.OpenParen */: + hasOpenParens = true; + chClass = 0 /* CharacterClass.None */; + break; + case 41 /* CharCode.CloseParen */: + chClass = (hasOpenParens ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */); + break; + case 91 /* CharCode.OpenSquareBracket */: + inSquareBrackets = true; + hasOpenSquareBracket = true; + chClass = 0 /* CharacterClass.None */; + break; + case 93 /* CharCode.CloseSquareBracket */: + inSquareBrackets = false; + chClass = (hasOpenSquareBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */); + break; + case 123 /* CharCode.OpenCurlyBrace */: + hasOpenCurlyBracket = true; + chClass = 0 /* CharacterClass.None */; + break; + case 125 /* CharCode.CloseCurlyBrace */: + chClass = (hasOpenCurlyBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */); + break; + // The following three rules make it that ' or " or ` are allowed inside links + // only if the link is wrapped by some other quote character + case 39 /* CharCode.SingleQuote */: + case 34 /* CharCode.DoubleQuote */: + case 96 /* CharCode.BackTick */: + if (linkBeginChCode === chCode) { + chClass = 1 /* CharacterClass.ForceTermination */; + } + else if (linkBeginChCode === 39 /* CharCode.SingleQuote */ || linkBeginChCode === 34 /* CharCode.DoubleQuote */ || linkBeginChCode === 96 /* CharCode.BackTick */) { + chClass = 0 /* CharacterClass.None */; + } + else { + chClass = 1 /* CharacterClass.ForceTermination */; + } + break; + case 42 /* CharCode.Asterisk */: + // `*` terminates a link if the link began with `*` + chClass = (linkBeginChCode === 42 /* CharCode.Asterisk */) ? 1 /* CharacterClass.ForceTermination */ : 0 /* CharacterClass.None */; + break; + case 124 /* CharCode.Pipe */: + // `|` terminates a link if the link began with `|` + chClass = (linkBeginChCode === 124 /* CharCode.Pipe */) ? 1 /* CharacterClass.ForceTermination */ : 0 /* CharacterClass.None */; + break; + case 32 /* CharCode.Space */: + // ` ` allow space in between [ and ] + chClass = (inSquareBrackets ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */); + break; + default: + chClass = classifier.get(chCode); + } + // Check if character terminates link + if (chClass === 1 /* CharacterClass.ForceTermination */) { + result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j)); + resetStateMachine = true; + } + } + else if (state === 12 /* State.End */) { + let chClass; + if (chCode === 91 /* CharCode.OpenSquareBracket */) { + // Allow for the authority part to contain ipv6 addresses which contain [ and ] + hasOpenSquareBracket = true; + chClass = 0 /* CharacterClass.None */; + } + else { + chClass = classifier.get(chCode); + } + // Check if character terminates link + if (chClass === 1 /* CharacterClass.ForceTermination */) { + resetStateMachine = true; + } + else { + state = 13 /* State.Accept */; + } + } + else { + state = stateMachine.nextState(state, chCode); + if (state === 0 /* State.Invalid */) { + resetStateMachine = true; + } + } + if (resetStateMachine) { + state = 1 /* State.Start */; + hasOpenParens = false; + hasOpenSquareBracket = false; + hasOpenCurlyBracket = false; + // Record where the link started + linkBeginIndex = j + 1; + linkBeginChCode = chCode; + } + j++; + } + if (state === 13 /* State.Accept */) { + result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len)); + } + } + return result; + } +} +/** + * Returns an array of all links contains in the provided + * document. *Note* that this operation is computational + * expensive and should not run in the UI thread. + */ +function computeLinks(model) { + if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') { + // Unknown caller! + return []; + } + return LinkComputer.computeLinks(model); +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/languages/supports/inplaceReplaceSupport.js": +/*!*****************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/languages/supports/inplaceReplaceSupport.js ***! + \*****************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ BasicInplaceReplace: () => (/* binding */ BasicInplaceReplace) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +class BasicInplaceReplace { + constructor() { + this._defaultValueSet = [ + ['true', 'false'], + ['True', 'False'], + ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'], + ['public', 'protected', 'private'], + ]; + } + navigateValueSet(range1, text1, range2, text2, up) { + if (range1 && text1) { + const result = this.doNavigateValueSet(text1, up); + if (result) { + return { + range: range1, + value: result + }; + } + } + if (range2 && text2) { + const result = this.doNavigateValueSet(text2, up); + if (result) { + return { + range: range2, + value: result + }; + } + } + return null; + } + doNavigateValueSet(text, up) { + const numberResult = this.numberReplace(text, up); + if (numberResult !== null) { + return numberResult; + } + return this.textReplace(text, up); + } + numberReplace(value, up) { + const precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1)); + let n1 = Number(value); + const n2 = parseFloat(value); + if (!isNaN(n1) && !isNaN(n2) && n1 === n2) { + if (n1 === 0 && !up) { + return null; // don't do negative + // } else if(n1 === 9 && up) { + // return null; // don't insert 10 into a number + } + else { + n1 = Math.floor(n1 * precision); + n1 += up ? precision : -precision; + return String(n1 / precision); + } + } + return null; + } + textReplace(value, up) { + return this.valueSetsReplace(this._defaultValueSet, value, up); + } + valueSetsReplace(valueSets, value, up) { + let result = null; + for (let i = 0, len = valueSets.length; result === null && i < len; i++) { + result = this.valueSetReplace(valueSets[i], value, up); + } + return result; + } + valueSetReplace(valueSet, value, up) { + let idx = valueSet.indexOf(value); + if (idx >= 0) { + idx += up ? +1 : -1; + if (idx < 0) { + idx = valueSet.length - 1; + } + else { + idx %= valueSet.length; + } + return valueSet[idx]; + } + return null; + } +} +BasicInplaceReplace.INSTANCE = new BasicInplaceReplace(); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/model.js": +/*!******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/model.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ ApplyEditsResult: () => (/* binding */ ApplyEditsResult), +/* harmony export */ FindMatch: () => (/* binding */ FindMatch), +/* harmony export */ GlyphMarginLane: () => (/* binding */ GlyphMarginLane), +/* harmony export */ InjectedTextCursorStops: () => (/* binding */ InjectedTextCursorStops), +/* harmony export */ MinimapPosition: () => (/* binding */ MinimapPosition), +/* harmony export */ OverviewRulerLane: () => (/* binding */ OverviewRulerLane), +/* harmony export */ SearchData: () => (/* binding */ SearchData), +/* harmony export */ TextModelResolvedOptions: () => (/* binding */ TextModelResolvedOptions), +/* harmony export */ ValidAnnotatedEditOperation: () => (/* binding */ ValidAnnotatedEditOperation), +/* harmony export */ isITextSnapshot: () => (/* binding */ isITextSnapshot), +/* harmony export */ shouldSynchronizeModel: () => (/* binding */ shouldSynchronizeModel) +/* harmony export */ }); +/* harmony import */ var _base_common_objects_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../base/common/objects.js */ "./node_modules/monaco-editor/esm/vs/base/common/objects.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * Vertical Lane in the overview ruler of the editor. + */ +var OverviewRulerLane; +(function (OverviewRulerLane) { + OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left"; + OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center"; + OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right"; + OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full"; +})(OverviewRulerLane || (OverviewRulerLane = {})); +/** + * Vertical Lane in the glyph margin of the editor. + */ +var GlyphMarginLane; +(function (GlyphMarginLane) { + GlyphMarginLane[GlyphMarginLane["Left"] = 1] = "Left"; + GlyphMarginLane[GlyphMarginLane["Right"] = 2] = "Right"; +})(GlyphMarginLane || (GlyphMarginLane = {})); +/** + * Position in the minimap to render the decoration. + */ +var MinimapPosition; +(function (MinimapPosition) { + MinimapPosition[MinimapPosition["Inline"] = 1] = "Inline"; + MinimapPosition[MinimapPosition["Gutter"] = 2] = "Gutter"; +})(MinimapPosition || (MinimapPosition = {})); +var InjectedTextCursorStops; +(function (InjectedTextCursorStops) { + InjectedTextCursorStops[InjectedTextCursorStops["Both"] = 0] = "Both"; + InjectedTextCursorStops[InjectedTextCursorStops["Right"] = 1] = "Right"; + InjectedTextCursorStops[InjectedTextCursorStops["Left"] = 2] = "Left"; + InjectedTextCursorStops[InjectedTextCursorStops["None"] = 3] = "None"; +})(InjectedTextCursorStops || (InjectedTextCursorStops = {})); +class TextModelResolvedOptions { + get originalIndentSize() { + return this._indentSizeIsTabSize ? 'tabSize' : this.indentSize; + } + /** + * @internal + */ + constructor(src) { + this._textModelResolvedOptionsBrand = undefined; + this.tabSize = Math.max(1, src.tabSize | 0); + if (src.indentSize === 'tabSize') { + this.indentSize = this.tabSize; + this._indentSizeIsTabSize = true; + } + else { + this.indentSize = Math.max(1, src.indentSize | 0); + this._indentSizeIsTabSize = false; + } + this.insertSpaces = Boolean(src.insertSpaces); + this.defaultEOL = src.defaultEOL | 0; + this.trimAutoWhitespace = Boolean(src.trimAutoWhitespace); + this.bracketPairColorizationOptions = src.bracketPairColorizationOptions; + } + /** + * @internal + */ + equals(other) { + return (this.tabSize === other.tabSize + && this._indentSizeIsTabSize === other._indentSizeIsTabSize + && this.indentSize === other.indentSize + && this.insertSpaces === other.insertSpaces + && this.defaultEOL === other.defaultEOL + && this.trimAutoWhitespace === other.trimAutoWhitespace + && (0,_base_common_objects_js__WEBPACK_IMPORTED_MODULE_0__.equals)(this.bracketPairColorizationOptions, other.bracketPairColorizationOptions)); + } + /** + * @internal + */ + createChangeEvent(newOpts) { + return { + tabSize: this.tabSize !== newOpts.tabSize, + indentSize: this.indentSize !== newOpts.indentSize, + insertSpaces: this.insertSpaces !== newOpts.insertSpaces, + trimAutoWhitespace: this.trimAutoWhitespace !== newOpts.trimAutoWhitespace, + }; + } +} +class FindMatch { + /** + * @internal + */ + constructor(range, matches) { + this._findMatchBrand = undefined; + this.range = range; + this.matches = matches; + } +} +/** + * @internal + */ +function isITextSnapshot(obj) { + return (obj && typeof obj.read === 'function'); +} +/** + * @internal + */ +class ValidAnnotatedEditOperation { + constructor(identifier, range, text, forceMoveMarkers, isAutoWhitespaceEdit, _isTracked) { + this.identifier = identifier; + this.range = range; + this.text = text; + this.forceMoveMarkers = forceMoveMarkers; + this.isAutoWhitespaceEdit = isAutoWhitespaceEdit; + this._isTracked = _isTracked; + } +} +/** + * @internal + */ +class SearchData { + constructor(regex, wordSeparators, simpleSearch) { + this.regex = regex; + this.wordSeparators = wordSeparators; + this.simpleSearch = simpleSearch; + } +} +/** + * @internal + */ +class ApplyEditsResult { + constructor(reverseEdits, changes, trimAutoWhitespaceLineNumbers) { + this.reverseEdits = reverseEdits; + this.changes = changes; + this.trimAutoWhitespaceLineNumbers = trimAutoWhitespaceLineNumbers; + } +} +/** + * @internal + */ +function shouldSynchronizeModel(model) { + return (!model.isTooLargeForSyncing() && !model.isForSimpleWidget); +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js": +/*!**********************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js ***! + \**********************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ MirrorTextModel: () => (/* binding */ MirrorTextModel) +/* harmony export */ }); +/* harmony import */ var _base_common_strings_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/strings.js */ "./node_modules/monaco-editor/esm/vs/base/common/strings.js"); +/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/position.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js"); +/* harmony import */ var _prefixSumComputer_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./prefixSumComputer.js */ "./node_modules/monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + +class MirrorTextModel { + constructor(uri, lines, eol, versionId) { + this._uri = uri; + this._lines = lines; + this._eol = eol; + this._versionId = versionId; + this._lineStarts = null; + this._cachedTextValue = null; + } + dispose() { + this._lines.length = 0; + } + get version() { + return this._versionId; + } + getText() { + if (this._cachedTextValue === null) { + this._cachedTextValue = this._lines.join(this._eol); + } + return this._cachedTextValue; + } + onEvents(e) { + if (e.eol && e.eol !== this._eol) { + this._eol = e.eol; + this._lineStarts = null; + } + // Update my lines + const changes = e.changes; + for (const change of changes) { + this._acceptDeleteRange(change.range); + this._acceptInsertText(new _core_position_js__WEBPACK_IMPORTED_MODULE_1__.Position(change.range.startLineNumber, change.range.startColumn), change.text); + } + this._versionId = e.versionId; + this._cachedTextValue = null; + } + _ensureLineStarts() { + if (!this._lineStarts) { + const eolLength = this._eol.length; + const linesLength = this._lines.length; + const lineStartValues = new Uint32Array(linesLength); + for (let i = 0; i < linesLength; i++) { + lineStartValues[i] = this._lines[i].length + eolLength; + } + this._lineStarts = new _prefixSumComputer_js__WEBPACK_IMPORTED_MODULE_2__.PrefixSumComputer(lineStartValues); + } + } + /** + * All changes to a line's text go through this method + */ + _setLineText(lineIndex, newValue) { + this._lines[lineIndex] = newValue; + if (this._lineStarts) { + // update prefix sum + this._lineStarts.setValue(lineIndex, this._lines[lineIndex].length + this._eol.length); + } + } + _acceptDeleteRange(range) { + if (range.startLineNumber === range.endLineNumber) { + if (range.startColumn === range.endColumn) { + // Nothing to delete + return; + } + // Delete text on the affected line + this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1) + + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1)); + return; + } + // Take remaining text on last line and append it to remaining text on first line + this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1) + + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1)); + // Delete middle lines + this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber); + if (this._lineStarts) { + // update prefix sum + this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber); + } + } + _acceptInsertText(position, insertText) { + if (insertText.length === 0) { + // Nothing to insert + return; + } + const insertLines = (0,_base_common_strings_js__WEBPACK_IMPORTED_MODULE_0__.splitLines)(insertText); + if (insertLines.length === 1) { + // Inserting text on one line + this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1) + + insertLines[0] + + this._lines[position.lineNumber - 1].substring(position.column - 1)); + return; + } + // Append overflowing text from first line to the end of text to insert + insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1); + // Delete overflowing text from first line and insert text on first line + this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1) + + insertLines[0]); + // Insert new lines & store lengths + const newLengths = new Uint32Array(insertLines.length - 1); + for (let i = 1; i < insertLines.length; i++) { + this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]); + newLengths[i - 1] = insertLines[i].length + this._eol.length; + } + if (this._lineStarts) { + // update prefix sum + this._lineStarts.insertValues(position.lineNumber, newLengths); + } + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js": +/*!************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js ***! + \************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ ConstantTimePrefixSumComputer: () => (/* binding */ ConstantTimePrefixSumComputer), +/* harmony export */ PrefixSumComputer: () => (/* binding */ PrefixSumComputer), +/* harmony export */ PrefixSumIndexOfResult: () => (/* binding */ PrefixSumIndexOfResult) +/* harmony export */ }); +/* harmony import */ var _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/arrays.js */ "./node_modules/monaco-editor/esm/vs/base/common/arrays.js"); +/* harmony import */ var _base_common_uint_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../base/common/uint.js */ "./node_modules/monaco-editor/esm/vs/base/common/uint.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +class PrefixSumComputer { + constructor(values) { + this.values = values; + this.prefixSum = new Uint32Array(values.length); + this.prefixSumValidIndex = new Int32Array(1); + this.prefixSumValidIndex[0] = -1; + } + insertValues(insertIndex, insertValues) { + insertIndex = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_1__.toUint32)(insertIndex); + const oldValues = this.values; + const oldPrefixSum = this.prefixSum; + const insertValuesLen = insertValues.length; + if (insertValuesLen === 0) { + return false; + } + this.values = new Uint32Array(oldValues.length + insertValuesLen); + this.values.set(oldValues.subarray(0, insertIndex), 0); + this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen); + this.values.set(insertValues, insertIndex); + if (insertIndex - 1 < this.prefixSumValidIndex[0]) { + this.prefixSumValidIndex[0] = insertIndex - 1; + } + this.prefixSum = new Uint32Array(this.values.length); + if (this.prefixSumValidIndex[0] >= 0) { + this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1)); + } + return true; + } + setValue(index, value) { + index = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_1__.toUint32)(index); + value = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_1__.toUint32)(value); + if (this.values[index] === value) { + return false; + } + this.values[index] = value; + if (index - 1 < this.prefixSumValidIndex[0]) { + this.prefixSumValidIndex[0] = index - 1; + } + return true; + } + removeValues(startIndex, count) { + startIndex = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_1__.toUint32)(startIndex); + count = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_1__.toUint32)(count); + const oldValues = this.values; + const oldPrefixSum = this.prefixSum; + if (startIndex >= oldValues.length) { + return false; + } + const maxCount = oldValues.length - startIndex; + if (count >= maxCount) { + count = maxCount; + } + if (count === 0) { + return false; + } + this.values = new Uint32Array(oldValues.length - count); + this.values.set(oldValues.subarray(0, startIndex), 0); + this.values.set(oldValues.subarray(startIndex + count), startIndex); + this.prefixSum = new Uint32Array(this.values.length); + if (startIndex - 1 < this.prefixSumValidIndex[0]) { + this.prefixSumValidIndex[0] = startIndex - 1; + } + if (this.prefixSumValidIndex[0] >= 0) { + this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1)); + } + return true; + } + getTotalSum() { + if (this.values.length === 0) { + return 0; + } + return this._getPrefixSum(this.values.length - 1); + } + /** + * Returns the sum of the first `index + 1` many items. + * @returns `SUM(0 <= j <= index, values[j])`. + */ + getPrefixSum(index) { + if (index < 0) { + return 0; + } + index = (0,_base_common_uint_js__WEBPACK_IMPORTED_MODULE_1__.toUint32)(index); + return this._getPrefixSum(index); + } + _getPrefixSum(index) { + if (index <= this.prefixSumValidIndex[0]) { + return this.prefixSum[index]; + } + let startIndex = this.prefixSumValidIndex[0] + 1; + if (startIndex === 0) { + this.prefixSum[0] = this.values[0]; + startIndex++; + } + if (index >= this.values.length) { + index = this.values.length - 1; + } + for (let i = startIndex; i <= index; i++) { + this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i]; + } + this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index); + return this.prefixSum[index]; + } + getIndexOf(sum) { + sum = Math.floor(sum); + // Compute all sums (to get a fully valid prefixSum) + this.getTotalSum(); + let low = 0; + let high = this.values.length - 1; + let mid = 0; + let midStop = 0; + let midStart = 0; + while (low <= high) { + mid = low + ((high - low) / 2) | 0; + midStop = this.prefixSum[mid]; + midStart = midStop - this.values[mid]; + if (sum < midStart) { + high = mid - 1; + } + else if (sum >= midStop) { + low = mid + 1; + } + else { + break; + } + } + return new PrefixSumIndexOfResult(mid, sum - midStart); + } +} +/** + * {@link getIndexOf} has an amortized runtime complexity of O(1). + * + * ({@link PrefixSumComputer.getIndexOf} is just O(log n)) +*/ +class ConstantTimePrefixSumComputer { + constructor(values) { + this._values = values; + this._isValid = false; + this._validEndIndex = -1; + this._prefixSum = []; + this._indexBySum = []; + } + /** + * @returns SUM(0 <= j < values.length, values[j]) + */ + getTotalSum() { + this._ensureValid(); + return this._indexBySum.length; + } + /** + * Returns the sum of the first `count` many items. + * @returns `SUM(0 <= j < count, values[j])`. + */ + getPrefixSum(count) { + this._ensureValid(); + if (count === 0) { + return 0; + } + return this._prefixSum[count - 1]; + } + /** + * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum` + */ + getIndexOf(sum) { + this._ensureValid(); + const idx = this._indexBySum[sum]; + const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0; + return new PrefixSumIndexOfResult(idx, sum - viewLinesAbove); + } + removeValues(start, deleteCount) { + this._values.splice(start, deleteCount); + this._invalidate(start); + } + insertValues(insertIndex, insertArr) { + this._values = (0,_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__.arrayInsert)(this._values, insertIndex, insertArr); + this._invalidate(insertIndex); + } + _invalidate(index) { + this._isValid = false; + this._validEndIndex = Math.min(this._validEndIndex, index - 1); + } + _ensureValid() { + if (this._isValid) { + return; + } + for (let i = this._validEndIndex + 1, len = this._values.length; i < len; i++) { + const value = this._values[i]; + const sumAbove = i > 0 ? this._prefixSum[i - 1] : 0; + this._prefixSum[i] = sumAbove + value; + for (let j = 0; j < value; j++) { + this._indexBySum[sumAbove + j] = i; + } + } + // trim things + this._prefixSum.length = this._values.length; + this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1]; + // mark as valid + this._isValid = true; + this._validEndIndex = this._values.length - 1; + } + setValue(index, value) { + if (this._values[index] === value) { + // no change + return; + } + this._values[index] = value; + this._invalidate(index); + } +} +class PrefixSumIndexOfResult { + constructor(index, remainder) { + this.index = index; + this.remainder = remainder; + this._prefixSumIndexOfResultBrand = undefined; + this.index = index; + this.remainder = remainder; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/model/textModelSearch.js": +/*!**********************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/model/textModelSearch.js ***! + \**********************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ SearchParams: () => (/* binding */ SearchParams), +/* harmony export */ Searcher: () => (/* binding */ Searcher), +/* harmony export */ TextModelSearch: () => (/* binding */ TextModelSearch), +/* harmony export */ createFindMatch: () => (/* binding */ createFindMatch), +/* harmony export */ isMultilineRegexSource: () => (/* binding */ isMultilineRegexSource), +/* harmony export */ isValidMatch: () => (/* binding */ isValidMatch) +/* harmony export */ }); +/* harmony import */ var _base_common_strings_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/strings.js */ "./node_modules/monaco-editor/esm/vs/base/common/strings.js"); +/* harmony import */ var _core_wordCharacterClassifier_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/wordCharacterClassifier.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/wordCharacterClassifier.js"); +/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/position.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js"); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _model_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../model.js */ "./node_modules/monaco-editor/esm/vs/editor/common/model.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + +const LIMIT_FIND_COUNT = 999; +class SearchParams { + constructor(searchString, isRegex, matchCase, wordSeparators) { + this.searchString = searchString; + this.isRegex = isRegex; + this.matchCase = matchCase; + this.wordSeparators = wordSeparators; + } + parseSearchRequest() { + if (this.searchString === '') { + return null; + } + // Try to create a RegExp out of the params + let multiline; + if (this.isRegex) { + multiline = isMultilineRegexSource(this.searchString); + } + else { + multiline = (this.searchString.indexOf('\n') >= 0); + } + let regex = null; + try { + regex = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_0__.createRegExp(this.searchString, this.isRegex, { + matchCase: this.matchCase, + wholeWord: false, + multiline: multiline, + global: true, + unicode: true + }); + } + catch (err) { + return null; + } + if (!regex) { + return null; + } + let canUseSimpleSearch = (!this.isRegex && !multiline); + if (canUseSimpleSearch && this.searchString.toLowerCase() !== this.searchString.toUpperCase()) { + // casing might make a difference + canUseSimpleSearch = this.matchCase; + } + return new _model_js__WEBPACK_IMPORTED_MODULE_4__.SearchData(regex, this.wordSeparators ? (0,_core_wordCharacterClassifier_js__WEBPACK_IMPORTED_MODULE_1__.getMapForWordSeparators)(this.wordSeparators) : null, canUseSimpleSearch ? this.searchString : null); + } +} +function isMultilineRegexSource(searchString) { + if (!searchString || searchString.length === 0) { + return false; + } + for (let i = 0, len = searchString.length; i < len; i++) { + const chCode = searchString.charCodeAt(i); + if (chCode === 10 /* CharCode.LineFeed */) { + return true; + } + if (chCode === 92 /* CharCode.Backslash */) { + // move to next char + i++; + if (i >= len) { + // string ends with a \ + break; + } + const nextChCode = searchString.charCodeAt(i); + if (nextChCode === 110 /* CharCode.n */ || nextChCode === 114 /* CharCode.r */ || nextChCode === 87 /* CharCode.W */) { + return true; + } + } + } + return false; +} +function createFindMatch(range, rawMatches, captureMatches) { + if (!captureMatches) { + return new _model_js__WEBPACK_IMPORTED_MODULE_4__.FindMatch(range, null); + } + const matches = []; + for (let i = 0, len = rawMatches.length; i < len; i++) { + matches[i] = rawMatches[i]; + } + return new _model_js__WEBPACK_IMPORTED_MODULE_4__.FindMatch(range, matches); +} +class LineFeedCounter { + constructor(text) { + const lineFeedsOffsets = []; + let lineFeedsOffsetsLen = 0; + for (let i = 0, textLen = text.length; i < textLen; i++) { + if (text.charCodeAt(i) === 10 /* CharCode.LineFeed */) { + lineFeedsOffsets[lineFeedsOffsetsLen++] = i; + } + } + this._lineFeedsOffsets = lineFeedsOffsets; + } + findLineFeedCountBeforeOffset(offset) { + const lineFeedsOffsets = this._lineFeedsOffsets; + let min = 0; + let max = lineFeedsOffsets.length - 1; + if (max === -1) { + // no line feeds + return 0; + } + if (offset <= lineFeedsOffsets[0]) { + // before first line feed + return 0; + } + while (min < max) { + const mid = min + ((max - min) / 2 >> 0); + if (lineFeedsOffsets[mid] >= offset) { + max = mid - 1; + } + else { + if (lineFeedsOffsets[mid + 1] >= offset) { + // bingo! + min = mid; + max = mid; + } + else { + min = mid + 1; + } + } + } + return min + 1; + } +} +class TextModelSearch { + static findMatches(model, searchParams, searchRange, captureMatches, limitResultCount) { + const searchData = searchParams.parseSearchRequest(); + if (!searchData) { + return []; + } + if (searchData.regex.multiline) { + return this._doFindMatchesMultiline(model, searchRange, new Searcher(searchData.wordSeparators, searchData.regex), captureMatches, limitResultCount); + } + return this._doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount); + } + /** + * Multiline search always executes on the lines concatenated with \n. + * We must therefore compensate for the count of \n in case the model is CRLF + */ + static _getMultilineMatchRange(model, deltaOffset, text, lfCounter, matchIndex, match0) { + let startOffset; + let lineFeedCountBeforeMatch = 0; + if (lfCounter) { + lineFeedCountBeforeMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex); + startOffset = deltaOffset + matchIndex + lineFeedCountBeforeMatch /* add as many \r as there were \n */; + } + else { + startOffset = deltaOffset + matchIndex; + } + let endOffset; + if (lfCounter) { + const lineFeedCountBeforeEndOfMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex + match0.length); + const lineFeedCountInMatch = lineFeedCountBeforeEndOfMatch - lineFeedCountBeforeMatch; + endOffset = startOffset + match0.length + lineFeedCountInMatch /* add as many \r as there were \n */; + } + else { + endOffset = startOffset + match0.length; + } + const startPosition = model.getPositionAt(startOffset); + const endPosition = model.getPositionAt(endOffset); + return new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column); + } + static _doFindMatchesMultiline(model, searchRange, searcher, captureMatches, limitResultCount) { + const deltaOffset = model.getOffsetAt(searchRange.getStartPosition()); + // We always execute multiline search over the lines joined with \n + // This makes it that \n will match the EOL for both CRLF and LF models + // We compensate for offset errors in `_getMultilineMatchRange` + const text = model.getValueInRange(searchRange, 1 /* EndOfLinePreference.LF */); + const lfCounter = (model.getEOL() === '\r\n' ? new LineFeedCounter(text) : null); + const result = []; + let counter = 0; + let m; + searcher.reset(0); + while ((m = searcher.next(text))) { + result[counter++] = createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches); + if (counter >= limitResultCount) { + return result; + } + } + return result; + } + static _doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount) { + const result = []; + let resultLen = 0; + // Early case for a search range that starts & stops on the same line number + if (searchRange.startLineNumber === searchRange.endLineNumber) { + const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1, searchRange.endColumn - 1); + resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount); + return result; + } + // Collect results from first line + const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1); + resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount); + // Collect results from middle lines + for (let lineNumber = searchRange.startLineNumber + 1; lineNumber < searchRange.endLineNumber && resultLen < limitResultCount; lineNumber++) { + resultLen = this._findMatchesInLine(searchData, model.getLineContent(lineNumber), lineNumber, 0, resultLen, result, captureMatches, limitResultCount); + } + // Collect results from last line + if (resultLen < limitResultCount) { + const text = model.getLineContent(searchRange.endLineNumber).substring(0, searchRange.endColumn - 1); + resultLen = this._findMatchesInLine(searchData, text, searchRange.endLineNumber, 0, resultLen, result, captureMatches, limitResultCount); + } + return result; + } + static _findMatchesInLine(searchData, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) { + const wordSeparators = searchData.wordSeparators; + if (!captureMatches && searchData.simpleSearch) { + const searchString = searchData.simpleSearch; + const searchStringLen = searchString.length; + const textLength = text.length; + let lastMatchIndex = -searchStringLen; + while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) { + if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) { + result[resultLen++] = new _model_js__WEBPACK_IMPORTED_MODULE_4__.FindMatch(new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null); + if (resultLen >= limitResultCount) { + return resultLen; + } + } + } + return resultLen; + } + const searcher = new Searcher(searchData.wordSeparators, searchData.regex); + let m; + // Reset regex to search from the beginning + searcher.reset(0); + do { + m = searcher.next(text); + if (m) { + result[resultLen++] = createFindMatch(new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches); + if (resultLen >= limitResultCount) { + return resultLen; + } + } + } while (m); + return resultLen; + } + static findNextMatch(model, searchParams, searchStart, captureMatches) { + const searchData = searchParams.parseSearchRequest(); + if (!searchData) { + return null; + } + const searcher = new Searcher(searchData.wordSeparators, searchData.regex); + if (searchData.regex.multiline) { + return this._doFindNextMatchMultiline(model, searchStart, searcher, captureMatches); + } + return this._doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches); + } + static _doFindNextMatchMultiline(model, searchStart, searcher, captureMatches) { + const searchTextStart = new _core_position_js__WEBPACK_IMPORTED_MODULE_2__.Position(searchStart.lineNumber, 1); + const deltaOffset = model.getOffsetAt(searchTextStart); + const lineCount = model.getLineCount(); + // We always execute multiline search over the lines joined with \n + // This makes it that \n will match the EOL for both CRLF and LF models + // We compensate for offset errors in `_getMultilineMatchRange` + const text = model.getValueInRange(new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(searchTextStart.lineNumber, searchTextStart.column, lineCount, model.getLineMaxColumn(lineCount)), 1 /* EndOfLinePreference.LF */); + const lfCounter = (model.getEOL() === '\r\n' ? new LineFeedCounter(text) : null); + searcher.reset(searchStart.column - 1); + const m = searcher.next(text); + if (m) { + return createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches); + } + if (searchStart.lineNumber !== 1 || searchStart.column !== 1) { + // Try again from the top + return this._doFindNextMatchMultiline(model, new _core_position_js__WEBPACK_IMPORTED_MODULE_2__.Position(1, 1), searcher, captureMatches); + } + return null; + } + static _doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches) { + const lineCount = model.getLineCount(); + const startLineNumber = searchStart.lineNumber; + // Look in first line + const text = model.getLineContent(startLineNumber); + const r = this._findFirstMatchInLine(searcher, text, startLineNumber, searchStart.column, captureMatches); + if (r) { + return r; + } + for (let i = 1; i <= lineCount; i++) { + const lineIndex = (startLineNumber + i - 1) % lineCount; + const text = model.getLineContent(lineIndex + 1); + const r = this._findFirstMatchInLine(searcher, text, lineIndex + 1, 1, captureMatches); + if (r) { + return r; + } + } + return null; + } + static _findFirstMatchInLine(searcher, text, lineNumber, fromColumn, captureMatches) { + // Set regex to search from column + searcher.reset(fromColumn - 1); + const m = searcher.next(text); + if (m) { + return createFindMatch(new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches); + } + return null; + } + static findPreviousMatch(model, searchParams, searchStart, captureMatches) { + const searchData = searchParams.parseSearchRequest(); + if (!searchData) { + return null; + } + const searcher = new Searcher(searchData.wordSeparators, searchData.regex); + if (searchData.regex.multiline) { + return this._doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches); + } + return this._doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches); + } + static _doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches) { + const matches = this._doFindMatchesMultiline(model, new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(1, 1, searchStart.lineNumber, searchStart.column), searcher, captureMatches, 10 * LIMIT_FIND_COUNT); + if (matches.length > 0) { + return matches[matches.length - 1]; + } + const lineCount = model.getLineCount(); + if (searchStart.lineNumber !== lineCount || searchStart.column !== model.getLineMaxColumn(lineCount)) { + // Try again with all content + return this._doFindPreviousMatchMultiline(model, new _core_position_js__WEBPACK_IMPORTED_MODULE_2__.Position(lineCount, model.getLineMaxColumn(lineCount)), searcher, captureMatches); + } + return null; + } + static _doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches) { + const lineCount = model.getLineCount(); + const startLineNumber = searchStart.lineNumber; + // Look in first line + const text = model.getLineContent(startLineNumber).substring(0, searchStart.column - 1); + const r = this._findLastMatchInLine(searcher, text, startLineNumber, captureMatches); + if (r) { + return r; + } + for (let i = 1; i <= lineCount; i++) { + const lineIndex = (lineCount + startLineNumber - i - 1) % lineCount; + const text = model.getLineContent(lineIndex + 1); + const r = this._findLastMatchInLine(searcher, text, lineIndex + 1, captureMatches); + if (r) { + return r; + } + } + return null; + } + static _findLastMatchInLine(searcher, text, lineNumber, captureMatches) { + let bestResult = null; + let m; + searcher.reset(0); + while ((m = searcher.next(text))) { + bestResult = createFindMatch(new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches); + } + return bestResult; + } +} +function leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) { + if (matchStartIndex === 0) { + // Match starts at start of string + return true; + } + const charBefore = text.charCodeAt(matchStartIndex - 1); + if (wordSeparators.get(charBefore) !== 0 /* WordCharacterClass.Regular */) { + // The character before the match is a word separator + return true; + } + if (charBefore === 13 /* CharCode.CarriageReturn */ || charBefore === 10 /* CharCode.LineFeed */) { + // The character before the match is line break or carriage return. + return true; + } + if (matchLength > 0) { + const firstCharInMatch = text.charCodeAt(matchStartIndex); + if (wordSeparators.get(firstCharInMatch) !== 0 /* WordCharacterClass.Regular */) { + // The first character inside the match is a word separator + return true; + } + } + return false; +} +function rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) { + if (matchStartIndex + matchLength === textLength) { + // Match ends at end of string + return true; + } + const charAfter = text.charCodeAt(matchStartIndex + matchLength); + if (wordSeparators.get(charAfter) !== 0 /* WordCharacterClass.Regular */) { + // The character after the match is a word separator + return true; + } + if (charAfter === 13 /* CharCode.CarriageReturn */ || charAfter === 10 /* CharCode.LineFeed */) { + // The character after the match is line break or carriage return. + return true; + } + if (matchLength > 0) { + const lastCharInMatch = text.charCodeAt(matchStartIndex + matchLength - 1); + if (wordSeparators.get(lastCharInMatch) !== 0 /* WordCharacterClass.Regular */) { + // The last character in the match is a word separator + return true; + } + } + return false; +} +function isValidMatch(wordSeparators, text, textLength, matchStartIndex, matchLength) { + return (leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) + && rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength)); +} +class Searcher { + constructor(wordSeparators, searchRegex) { + this._wordSeparators = wordSeparators; + this._searchRegex = searchRegex; + this._prevMatchStartIndex = -1; + this._prevMatchLength = 0; + } + reset(lastIndex) { + this._searchRegex.lastIndex = lastIndex; + this._prevMatchStartIndex = -1; + this._prevMatchLength = 0; + } + next(text) { + const textLength = text.length; + let m; + do { + if (this._prevMatchStartIndex + this._prevMatchLength === textLength) { + // Reached the end of the line + return null; + } + m = this._searchRegex.exec(text); + if (!m) { + return null; + } + const matchStartIndex = m.index; + const matchLength = m[0].length; + if (matchStartIndex === this._prevMatchStartIndex && matchLength === this._prevMatchLength) { + if (matchLength === 0) { + // the search result is an empty string and won't advance `regex.lastIndex`, so `regex.exec` will stuck here + // we attempt to recover from that by advancing by two if surrogate pair found and by one otherwise + if (_base_common_strings_js__WEBPACK_IMPORTED_MODULE_0__.getNextCodePoint(text, textLength, this._searchRegex.lastIndex) > 0xFFFF) { + this._searchRegex.lastIndex += 2; + } + else { + this._searchRegex.lastIndex += 1; + } + continue; + } + // Exit early if the regex matches the same range twice + return null; + } + this._prevMatchStartIndex = matchStartIndex; + this._prevMatchLength = matchLength; + if (!this._wordSeparators || isValidMatch(this._wordSeparators, text, textLength, matchStartIndex, matchLength)) { + return m; + } + } while (m); + return null; + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/services/editorBaseApi.js": +/*!***********************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/services/editorBaseApi.js ***! + \***********************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ KeyMod: () => (/* binding */ KeyMod), +/* harmony export */ createMonacoBaseAPI: () => (/* binding */ createMonacoBaseAPI) +/* harmony export */ }); +/* harmony import */ var _base_common_cancellation_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/cancellation.js */ "./node_modules/monaco-editor/esm/vs/base/common/cancellation.js"); +/* harmony import */ var _base_common_event_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../base/common/event.js */ "./node_modules/monaco-editor/esm/vs/base/common/event.js"); +/* harmony import */ var _base_common_keyCodes_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../base/common/keyCodes.js */ "./node_modules/monaco-editor/esm/vs/base/common/keyCodes.js"); +/* harmony import */ var _base_common_uri_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../base/common/uri.js */ "./node_modules/monaco-editor/esm/vs/base/common/uri.js"); +/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../core/position.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js"); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _core_selection_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../core/selection.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/selection.js"); +/* harmony import */ var _languages_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../languages.js */ "./node_modules/monaco-editor/esm/vs/editor/common/languages.js"); +/* harmony import */ var _standalone_standaloneEnums_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../standalone/standaloneEnums.js */ "./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + + + + + +class KeyMod { + static chord(firstPart, secondPart) { + return (0,_base_common_keyCodes_js__WEBPACK_IMPORTED_MODULE_2__.KeyChord)(firstPart, secondPart); + } +} +KeyMod.CtrlCmd = 2048 /* ConstKeyMod.CtrlCmd */; +KeyMod.Shift = 1024 /* ConstKeyMod.Shift */; +KeyMod.Alt = 512 /* ConstKeyMod.Alt */; +KeyMod.WinCtrl = 256 /* ConstKeyMod.WinCtrl */; +function createMonacoBaseAPI() { + return { + editor: undefined, // undefined override expected here + languages: undefined, // undefined override expected here + CancellationTokenSource: _base_common_cancellation_js__WEBPACK_IMPORTED_MODULE_0__.CancellationTokenSource, + Emitter: _base_common_event_js__WEBPACK_IMPORTED_MODULE_1__.Emitter, + KeyCode: _standalone_standaloneEnums_js__WEBPACK_IMPORTED_MODULE_8__.KeyCode, + KeyMod: KeyMod, + Position: _core_position_js__WEBPACK_IMPORTED_MODULE_4__.Position, + Range: _core_range_js__WEBPACK_IMPORTED_MODULE_5__.Range, + Selection: _core_selection_js__WEBPACK_IMPORTED_MODULE_6__.Selection, + SelectionDirection: _standalone_standaloneEnums_js__WEBPACK_IMPORTED_MODULE_8__.SelectionDirection, + MarkerSeverity: _standalone_standaloneEnums_js__WEBPACK_IMPORTED_MODULE_8__.MarkerSeverity, + MarkerTag: _standalone_standaloneEnums_js__WEBPACK_IMPORTED_MODULE_8__.MarkerTag, + Uri: _base_common_uri_js__WEBPACK_IMPORTED_MODULE_3__.URI, + Token: _languages_js__WEBPACK_IMPORTED_MODULE_7__.Token + }; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js": +/*!****************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js ***! + \****************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ EditorSimpleWorker: () => (/* binding */ EditorSimpleWorker), +/* harmony export */ create: () => (/* binding */ create) +/* harmony export */ }); +/* harmony import */ var _base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/diff/diff.js */ "./node_modules/monaco-editor/esm/vs/base/common/diff/diff.js"); +/* harmony import */ var _base_common_uri_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../base/common/uri.js */ "./node_modules/monaco-editor/esm/vs/base/common/uri.js"); +/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/position.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/position.js"); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _model_mirrorTextModel_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../model/mirrorTextModel.js */ "./node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js"); +/* harmony import */ var _core_wordHelper_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../core/wordHelper.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/wordHelper.js"); +/* harmony import */ var _languages_linkComputer_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../languages/linkComputer.js */ "./node_modules/monaco-editor/esm/vs/editor/common/languages/linkComputer.js"); +/* harmony import */ var _languages_supports_inplaceReplaceSupport_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../languages/supports/inplaceReplaceSupport.js */ "./node_modules/monaco-editor/esm/vs/editor/common/languages/supports/inplaceReplaceSupport.js"); +/* harmony import */ var _editorBaseApi_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./editorBaseApi.js */ "./node_modules/monaco-editor/esm/vs/editor/common/services/editorBaseApi.js"); +/* harmony import */ var _base_common_stopwatch_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../../../base/common/stopwatch.js */ "./node_modules/monaco-editor/esm/vs/base/common/stopwatch.js"); +/* harmony import */ var _unicodeTextModelHighlighter_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./unicodeTextModelHighlighter.js */ "./node_modules/monaco-editor/esm/vs/editor/common/services/unicodeTextModelHighlighter.js"); +/* harmony import */ var _diff_linesDiffComputers_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../diff/linesDiffComputers.js */ "./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputers.js"); +/* harmony import */ var _base_common_objects_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../../../base/common/objects.js */ "./node_modules/monaco-editor/esm/vs/base/common/objects.js"); +/* harmony import */ var _languages_defaultDocumentColorsComputer_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../languages/defaultDocumentColorsComputer.js */ "./node_modules/monaco-editor/esm/vs/editor/common/languages/defaultDocumentColorsComputer.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + + + + + + + + + + +/** + * @internal + */ +class MirrorModel extends _model_mirrorTextModel_js__WEBPACK_IMPORTED_MODULE_4__.MirrorTextModel { + get uri() { + return this._uri; + } + get eol() { + return this._eol; + } + getValue() { + return this.getText(); + } + findMatches(regex) { + const matches = []; + for (let i = 0; i < this._lines.length; i++) { + const line = this._lines[i]; + const offsetToAdd = this.offsetAt(new _core_position_js__WEBPACK_IMPORTED_MODULE_2__.Position(i + 1, 1)); + const iteratorOverMatches = line.matchAll(regex); + for (const match of iteratorOverMatches) { + if (match.index || match.index === 0) { + match.index = match.index + offsetToAdd; + } + matches.push(match); + } + } + return matches; + } + getLinesContent() { + return this._lines.slice(0); + } + getLineCount() { + return this._lines.length; + } + getLineContent(lineNumber) { + return this._lines[lineNumber - 1]; + } + getWordAtPosition(position, wordDefinition) { + const wordAtText = (0,_core_wordHelper_js__WEBPACK_IMPORTED_MODULE_5__.getWordAtText)(position.column, (0,_core_wordHelper_js__WEBPACK_IMPORTED_MODULE_5__.ensureValidWordDefinition)(wordDefinition), this._lines[position.lineNumber - 1], 0); + if (wordAtText) { + return new _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn); + } + return null; + } + words(wordDefinition) { + const lines = this._lines; + const wordenize = this._wordenize.bind(this); + let lineNumber = 0; + let lineText = ''; + let wordRangesIdx = 0; + let wordRanges = []; + return { + *[Symbol.iterator]() { + while (true) { + if (wordRangesIdx < wordRanges.length) { + const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end); + wordRangesIdx += 1; + yield value; + } + else { + if (lineNumber < lines.length) { + lineText = lines[lineNumber]; + wordRanges = wordenize(lineText, wordDefinition); + wordRangesIdx = 0; + lineNumber += 1; + } + else { + break; + } + } + } + } + }; + } + getLineWords(lineNumber, wordDefinition) { + const content = this._lines[lineNumber - 1]; + const ranges = this._wordenize(content, wordDefinition); + const words = []; + for (const range of ranges) { + words.push({ + word: content.substring(range.start, range.end), + startColumn: range.start + 1, + endColumn: range.end + 1 + }); + } + return words; + } + _wordenize(content, wordDefinition) { + const result = []; + let match; + wordDefinition.lastIndex = 0; // reset lastIndex just to be sure + while (match = wordDefinition.exec(content)) { + if (match[0].length === 0) { + // it did match the empty string + break; + } + result.push({ start: match.index, end: match.index + match[0].length }); + } + return result; + } + getValueInRange(range) { + range = this._validateRange(range); + if (range.startLineNumber === range.endLineNumber) { + return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1); + } + const lineEnding = this._eol; + const startLineIndex = range.startLineNumber - 1; + const endLineIndex = range.endLineNumber - 1; + const resultLines = []; + resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1)); + for (let i = startLineIndex + 1; i < endLineIndex; i++) { + resultLines.push(this._lines[i]); + } + resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1)); + return resultLines.join(lineEnding); + } + offsetAt(position) { + position = this._validatePosition(position); + this._ensureLineStarts(); + return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1); + } + positionAt(offset) { + offset = Math.floor(offset); + offset = Math.max(0, offset); + this._ensureLineStarts(); + const out = this._lineStarts.getIndexOf(offset); + const lineLength = this._lines[out.index].length; + // Ensure we return a valid position + return { + lineNumber: 1 + out.index, + column: 1 + Math.min(out.remainder, lineLength) + }; + } + _validateRange(range) { + const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn }); + const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn }); + if (start.lineNumber !== range.startLineNumber + || start.column !== range.startColumn + || end.lineNumber !== range.endLineNumber + || end.column !== range.endColumn) { + return { + startLineNumber: start.lineNumber, + startColumn: start.column, + endLineNumber: end.lineNumber, + endColumn: end.column + }; + } + return range; + } + _validatePosition(position) { + if (!_core_position_js__WEBPACK_IMPORTED_MODULE_2__.Position.isIPosition(position)) { + throw new Error('bad position'); + } + let { lineNumber, column } = position; + let hasChanged = false; + if (lineNumber < 1) { + lineNumber = 1; + column = 1; + hasChanged = true; + } + else if (lineNumber > this._lines.length) { + lineNumber = this._lines.length; + column = this._lines[lineNumber - 1].length + 1; + hasChanged = true; + } + else { + const maxCharacter = this._lines[lineNumber - 1].length + 1; + if (column < 1) { + column = 1; + hasChanged = true; + } + else if (column > maxCharacter) { + column = maxCharacter; + hasChanged = true; + } + } + if (!hasChanged) { + return position; + } + else { + return { lineNumber, column }; + } + } +} +/** + * @internal + */ +class EditorSimpleWorker { + constructor(host, foreignModuleFactory) { + this._host = host; + this._models = Object.create(null); + this._foreignModuleFactory = foreignModuleFactory; + this._foreignModule = null; + } + dispose() { + this._models = Object.create(null); + } + _getModel(uri) { + return this._models[uri]; + } + _getModels() { + const all = []; + Object.keys(this._models).forEach((key) => all.push(this._models[key])); + return all; + } + acceptNewModel(data) { + this._models[data.url] = new MirrorModel(_base_common_uri_js__WEBPACK_IMPORTED_MODULE_1__.URI.parse(data.url), data.lines, data.EOL, data.versionId); + } + acceptModelChanged(strURL, e) { + if (!this._models[strURL]) { + return; + } + const model = this._models[strURL]; + model.onEvents(e); + } + acceptRemovedModel(strURL) { + if (!this._models[strURL]) { + return; + } + delete this._models[strURL]; + } + async computeUnicodeHighlights(url, options, range) { + const model = this._getModel(url); + if (!model) { + return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 }; + } + return _unicodeTextModelHighlighter_js__WEBPACK_IMPORTED_MODULE_10__.UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range); + } + // ---- BEGIN diff -------------------------------------------------------------------------- + async computeDiff(originalUrl, modifiedUrl, options, algorithm) { + const original = this._getModel(originalUrl); + const modified = this._getModel(modifiedUrl); + if (!original || !modified) { + return null; + } + return EditorSimpleWorker.computeDiff(original, modified, options, algorithm); + } + static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) { + const diffAlgorithm = algorithm === 'advanced' ? _diff_linesDiffComputers_js__WEBPACK_IMPORTED_MODULE_11__.linesDiffComputers.getDefault() : _diff_linesDiffComputers_js__WEBPACK_IMPORTED_MODULE_11__.linesDiffComputers.getLegacy(); + const originalLines = originalTextModel.getLinesContent(); + const modifiedLines = modifiedTextModel.getLinesContent(); + const result = diffAlgorithm.computeDiff(originalLines, modifiedLines, options); + const identical = (result.changes.length > 0 ? false : this._modelsAreIdentical(originalTextModel, modifiedTextModel)); + function getLineChanges(changes) { + return changes.map(m => { + var _a; + return ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, (_a = m.innerChanges) === null || _a === void 0 ? void 0 : _a.map(m => [ + m.originalRange.startLineNumber, + m.originalRange.startColumn, + m.originalRange.endLineNumber, + m.originalRange.endColumn, + m.modifiedRange.startLineNumber, + m.modifiedRange.startColumn, + m.modifiedRange.endLineNumber, + m.modifiedRange.endColumn, + ])]); + }); + } + return { + identical, + quitEarly: result.hitTimeout, + changes: getLineChanges(result.changes), + moves: result.moves.map(m => ([ + m.lineRangeMapping.original.startLineNumber, + m.lineRangeMapping.original.endLineNumberExclusive, + m.lineRangeMapping.modified.startLineNumber, + m.lineRangeMapping.modified.endLineNumberExclusive, + getLineChanges(m.changes) + ])), + }; + } + static _modelsAreIdentical(original, modified) { + const originalLineCount = original.getLineCount(); + const modifiedLineCount = modified.getLineCount(); + if (originalLineCount !== modifiedLineCount) { + return false; + } + for (let line = 1; line <= originalLineCount; line++) { + const originalLine = original.getLineContent(line); + const modifiedLine = modified.getLineContent(line); + if (originalLine !== modifiedLine) { + return false; + } + } + return true; + } + async computeMoreMinimalEdits(modelUrl, edits, pretty) { + const model = this._getModel(modelUrl); + if (!model) { + return edits; + } + const result = []; + let lastEol = undefined; + edits = edits.slice(0).sort((a, b) => { + if (a.range && b.range) { + return _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.compareRangesUsingStarts(a.range, b.range); + } + // eol only changes should go to the end + const aRng = a.range ? 0 : 1; + const bRng = b.range ? 0 : 1; + return aRng - bRng; + }); + // merge adjacent edits + let writeIndex = 0; + for (let readIndex = 1; readIndex < edits.length; readIndex++) { + if (_core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.getEndPosition(edits[writeIndex].range).equals(_core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.getStartPosition(edits[readIndex].range))) { + edits[writeIndex].range = _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.fromPositions(_core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.getStartPosition(edits[writeIndex].range), _core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.getEndPosition(edits[readIndex].range)); + edits[writeIndex].text += edits[readIndex].text; + } + else { + writeIndex++; + edits[writeIndex] = edits[readIndex]; + } + } + edits.length = writeIndex + 1; + for (let { range, text, eol } of edits) { + if (typeof eol === 'number') { + lastEol = eol; + } + if (_core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.isEmpty(range) && !text) { + // empty change + continue; + } + const original = model.getValueInRange(range); + text = text.replace(/\r\n|\n|\r/g, model.eol); + if (original === text) { + // noop + continue; + } + // make sure diff won't take too long + if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) { + result.push({ range, text }); + continue; + } + // compute diff between original and edit.text + const changes = (0,_base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_0__.stringDiff)(original, text, pretty); + const editOffset = model.offsetAt(_core_range_js__WEBPACK_IMPORTED_MODULE_3__.Range.lift(range).getStartPosition()); + for (const change of changes) { + const start = model.positionAt(editOffset + change.originalStart); + const end = model.positionAt(editOffset + change.originalStart + change.originalLength); + const newEdit = { + text: text.substr(change.modifiedStart, change.modifiedLength), + range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column } + }; + if (model.getValueInRange(newEdit.range) !== newEdit.text) { + result.push(newEdit); + } + } + } + if (typeof lastEol === 'number') { + result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } }); + } + return result; + } + // ---- END minimal edits --------------------------------------------------------------- + async computeLinks(modelUrl) { + const model = this._getModel(modelUrl); + if (!model) { + return null; + } + return (0,_languages_linkComputer_js__WEBPACK_IMPORTED_MODULE_6__.computeLinks)(model); + } + // --- BEGIN default document colors ----------------------------------------------------------- + async computeDefaultDocumentColors(modelUrl) { + const model = this._getModel(modelUrl); + if (!model) { + return null; + } + return (0,_languages_defaultDocumentColorsComputer_js__WEBPACK_IMPORTED_MODULE_13__.computeDefaultDocumentColors)(model); + } + async textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) { + const sw = new _base_common_stopwatch_js__WEBPACK_IMPORTED_MODULE_9__.StopWatch(); + const wordDefRegExp = new RegExp(wordDef, wordDefFlags); + const seen = new Set(); + outer: for (const url of modelUrls) { + const model = this._getModel(url); + if (!model) { + continue; + } + for (const word of model.words(wordDefRegExp)) { + if (word === leadingWord || !isNaN(Number(word))) { + continue; + } + seen.add(word); + if (seen.size > EditorSimpleWorker._suggestionsLimit) { + break outer; + } + } + } + return { words: Array.from(seen), duration: sw.elapsed() }; + } + // ---- END suggest -------------------------------------------------------------------------- + //#region -- word ranges -- + async computeWordRanges(modelUrl, range, wordDef, wordDefFlags) { + const model = this._getModel(modelUrl); + if (!model) { + return Object.create(null); + } + const wordDefRegExp = new RegExp(wordDef, wordDefFlags); + const result = Object.create(null); + for (let line = range.startLineNumber; line < range.endLineNumber; line++) { + const words = model.getLineWords(line, wordDefRegExp); + for (const word of words) { + if (!isNaN(Number(word.word))) { + continue; + } + let array = result[word.word]; + if (!array) { + array = []; + result[word.word] = array; + } + array.push({ + startLineNumber: line, + startColumn: word.startColumn, + endLineNumber: line, + endColumn: word.endColumn + }); + } + } + return result; + } + //#endregion + async navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) { + const model = this._getModel(modelUrl); + if (!model) { + return null; + } + const wordDefRegExp = new RegExp(wordDef, wordDefFlags); + if (range.startColumn === range.endColumn) { + range = { + startLineNumber: range.startLineNumber, + startColumn: range.startColumn, + endLineNumber: range.endLineNumber, + endColumn: range.endColumn + 1 + }; + } + const selectionText = model.getValueInRange(range); + const wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp); + if (!wordRange) { + return null; + } + const word = model.getValueInRange(wordRange); + const result = _languages_supports_inplaceReplaceSupport_js__WEBPACK_IMPORTED_MODULE_7__.BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up); + return result; + } + // ---- BEGIN foreign module support -------------------------------------------------------------------------- + loadForeignModule(moduleId, createData, foreignHostMethods) { + const proxyMethodRequest = (method, args) => { + return this._host.fhr(method, args); + }; + const foreignHost = (0,_base_common_objects_js__WEBPACK_IMPORTED_MODULE_12__.createProxyObject)(foreignHostMethods, proxyMethodRequest); + const ctx = { + host: foreignHost, + getMirrorModels: () => { + return this._getModels(); + } + }; + if (this._foreignModuleFactory) { + this._foreignModule = this._foreignModuleFactory(ctx, createData); + // static foreing module + return Promise.resolve((0,_base_common_objects_js__WEBPACK_IMPORTED_MODULE_12__.getAllMethodNames)(this._foreignModule)); + } + // ESM-comment-begin + // return new Promise((resolve, reject) => { + // require([moduleId], (foreignModule: { create: IForeignModuleFactory }) => { + // this._foreignModule = foreignModule.create(ctx, createData); + // + // resolve(getAllMethodNames(this._foreignModule)); + // + // }, reject); + // }); + // ESM-comment-end + // ESM-uncomment-begin + return Promise.reject(new Error(`Unexpected usage`)); + // ESM-uncomment-end + } + // foreign method request + fmr(method, args) { + if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') { + return Promise.reject(new Error('Missing requestHandler or method: ' + method)); + } + try { + return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args)); + } + catch (e) { + return Promise.reject(e); + } + } +} +// ---- END diff -------------------------------------------------------------------------- +// ---- BEGIN minimal edits --------------------------------------------------------------- +EditorSimpleWorker._diffLimit = 100000; +// ---- BEGIN suggest -------------------------------------------------------------------------- +EditorSimpleWorker._suggestionsLimit = 10000; +/** + * Called on the worker side + * @internal + */ +function create(host) { + return new EditorSimpleWorker(host, null); +} +if (typeof importScripts === 'function') { + // Running in a web worker + globalThis.monaco = (0,_editorBaseApi_js__WEBPACK_IMPORTED_MODULE_8__.createMonacoBaseAPI)(); +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/services/unicodeTextModelHighlighter.js": +/*!*************************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/services/unicodeTextModelHighlighter.js ***! + \*************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ UnicodeTextModelHighlighter: () => (/* binding */ UnicodeTextModelHighlighter) +/* harmony export */ }); +/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/range.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/range.js"); +/* harmony import */ var _model_textModelSearch_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../model/textModelSearch.js */ "./node_modules/monaco-editor/esm/vs/editor/common/model/textModelSearch.js"); +/* harmony import */ var _base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../base/common/strings.js */ "./node_modules/monaco-editor/esm/vs/base/common/strings.js"); +/* harmony import */ var _base_common_assert_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../base/common/assert.js */ "./node_modules/monaco-editor/esm/vs/base/common/assert.js"); +/* harmony import */ var _core_wordHelper_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../core/wordHelper.js */ "./node_modules/monaco-editor/esm/vs/editor/common/core/wordHelper.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + + + + +class UnicodeTextModelHighlighter { + static computeUnicodeHighlights(model, options, range) { + const startLine = range ? range.startLineNumber : 1; + const endLine = range ? range.endLineNumber : model.getLineCount(); + const codePointHighlighter = new CodePointHighlighter(options); + const candidates = codePointHighlighter.getCandidateCodePoints(); + let regex; + if (candidates === 'allNonBasicAscii') { + regex = new RegExp('[^\\t\\n\\r\\x20-\\x7E]', 'g'); + } + else { + regex = new RegExp(`${buildRegExpCharClassExpr(Array.from(candidates))}`, 'g'); + } + const searcher = new _model_textModelSearch_js__WEBPACK_IMPORTED_MODULE_1__.Searcher(null, regex); + const ranges = []; + let hasMore = false; + let m; + let ambiguousCharacterCount = 0; + let invisibleCharacterCount = 0; + let nonBasicAsciiCharacterCount = 0; + forLoop: for (let lineNumber = startLine, lineCount = endLine; lineNumber <= lineCount; lineNumber++) { + const lineContent = model.getLineContent(lineNumber); + const lineLength = lineContent.length; + // Reset regex to search from the beginning + searcher.reset(0); + do { + m = searcher.next(lineContent); + if (m) { + let startIndex = m.index; + let endIndex = m.index + m[0].length; + // Extend range to entire code point + if (startIndex > 0) { + const charCodeBefore = lineContent.charCodeAt(startIndex - 1); + if (_base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.isHighSurrogate(charCodeBefore)) { + startIndex--; + } + } + if (endIndex + 1 < lineLength) { + const charCodeBefore = lineContent.charCodeAt(endIndex - 1); + if (_base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.isHighSurrogate(charCodeBefore)) { + endIndex++; + } + } + const str = lineContent.substring(startIndex, endIndex); + let word = (0,_core_wordHelper_js__WEBPACK_IMPORTED_MODULE_4__.getWordAtText)(startIndex + 1, _core_wordHelper_js__WEBPACK_IMPORTED_MODULE_4__.DEFAULT_WORD_REGEXP, lineContent, 0); + if (word && word.endColumn <= startIndex + 1) { + // The word does not include the problematic character, ignore the word + word = null; + } + const highlightReason = codePointHighlighter.shouldHighlightNonBasicASCII(str, word ? word.word : null); + if (highlightReason !== 0 /* SimpleHighlightReason.None */) { + if (highlightReason === 3 /* SimpleHighlightReason.Ambiguous */) { + ambiguousCharacterCount++; + } + else if (highlightReason === 2 /* SimpleHighlightReason.Invisible */) { + invisibleCharacterCount++; + } + else if (highlightReason === 1 /* SimpleHighlightReason.NonBasicASCII */) { + nonBasicAsciiCharacterCount++; + } + else { + (0,_base_common_assert_js__WEBPACK_IMPORTED_MODULE_3__.assertNever)(highlightReason); + } + const MAX_RESULT_LENGTH = 1000; + if (ranges.length >= MAX_RESULT_LENGTH) { + hasMore = true; + break forLoop; + } + ranges.push(new _core_range_js__WEBPACK_IMPORTED_MODULE_0__.Range(lineNumber, startIndex + 1, lineNumber, endIndex + 1)); + } + } + } while (m); + } + return { + ranges, + hasMore, + ambiguousCharacterCount, + invisibleCharacterCount, + nonBasicAsciiCharacterCount + }; + } + static computeUnicodeHighlightReason(char, options) { + const codePointHighlighter = new CodePointHighlighter(options); + const reason = codePointHighlighter.shouldHighlightNonBasicASCII(char, null); + switch (reason) { + case 0 /* SimpleHighlightReason.None */: + return null; + case 2 /* SimpleHighlightReason.Invisible */: + return { kind: 1 /* UnicodeHighlighterReasonKind.Invisible */ }; + case 3 /* SimpleHighlightReason.Ambiguous */: { + const codePoint = char.codePointAt(0); + const primaryConfusable = codePointHighlighter.ambiguousCharacters.getPrimaryConfusable(codePoint); + const notAmbiguousInLocales = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.AmbiguousCharacters.getLocales().filter((l) => !_base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.AmbiguousCharacters.getInstance(new Set([...options.allowedLocales, l])).isAmbiguous(codePoint)); + return { kind: 0 /* UnicodeHighlighterReasonKind.Ambiguous */, confusableWith: String.fromCodePoint(primaryConfusable), notAmbiguousInLocales }; + } + case 1 /* SimpleHighlightReason.NonBasicASCII */: + return { kind: 2 /* UnicodeHighlighterReasonKind.NonBasicAscii */ }; + } + } +} +function buildRegExpCharClassExpr(codePoints, flags) { + const src = `[${_base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.escapeRegExpCharacters(codePoints.map((i) => String.fromCodePoint(i)).join(''))}]`; + return src; +} +class CodePointHighlighter { + constructor(options) { + this.options = options; + this.allowedCodePoints = new Set(options.allowedCodePoints); + this.ambiguousCharacters = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.AmbiguousCharacters.getInstance(new Set(options.allowedLocales)); + } + getCandidateCodePoints() { + if (this.options.nonBasicASCII) { + return 'allNonBasicAscii'; + } + const set = new Set(); + if (this.options.invisibleCharacters) { + for (const cp of _base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.InvisibleCharacters.codePoints) { + if (!isAllowedInvisibleCharacter(String.fromCodePoint(cp))) { + set.add(cp); + } + } + } + if (this.options.ambiguousCharacters) { + for (const cp of this.ambiguousCharacters.getConfusableCodePoints()) { + set.add(cp); + } + } + for (const cp of this.allowedCodePoints) { + set.delete(cp); + } + return set; + } + shouldHighlightNonBasicASCII(character, wordContext) { + const codePoint = character.codePointAt(0); + if (this.allowedCodePoints.has(codePoint)) { + return 0 /* SimpleHighlightReason.None */; + } + if (this.options.nonBasicASCII) { + return 1 /* SimpleHighlightReason.NonBasicASCII */; + } + let hasBasicASCIICharacters = false; + let hasNonConfusableNonBasicAsciiCharacter = false; + if (wordContext) { + for (const char of wordContext) { + const codePoint = char.codePointAt(0); + const isBasicASCII = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.isBasicASCII(char); + hasBasicASCIICharacters = hasBasicASCIICharacters || isBasicASCII; + if (!isBasicASCII && + !this.ambiguousCharacters.isAmbiguous(codePoint) && + !_base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.InvisibleCharacters.isInvisibleCharacter(codePoint)) { + hasNonConfusableNonBasicAsciiCharacter = true; + } + } + } + if ( + /* Don't allow mixing weird looking characters with ASCII */ !hasBasicASCIICharacters && + /* Is there an obviously weird looking character? */ hasNonConfusableNonBasicAsciiCharacter) { + return 0 /* SimpleHighlightReason.None */; + } + if (this.options.invisibleCharacters) { + // TODO check for emojis + if (!isAllowedInvisibleCharacter(character) && _base_common_strings_js__WEBPACK_IMPORTED_MODULE_2__.InvisibleCharacters.isInvisibleCharacter(codePoint)) { + return 2 /* SimpleHighlightReason.Invisible */; + } + } + if (this.options.ambiguousCharacters) { + if (this.ambiguousCharacters.isAmbiguous(codePoint)) { + return 3 /* SimpleHighlightReason.Ambiguous */; + } + } + return 0 /* SimpleHighlightReason.None */; + } +} +function isAllowedInvisibleCharacter(character) { + return character === ' ' || character === '\n' || character === '\t'; +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js": +/*!***************************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js ***! + \***************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ AccessibilitySupport: () => (/* binding */ AccessibilitySupport), +/* harmony export */ CodeActionTriggerType: () => (/* binding */ CodeActionTriggerType), +/* harmony export */ CompletionItemInsertTextRule: () => (/* binding */ CompletionItemInsertTextRule), +/* harmony export */ CompletionItemKind: () => (/* binding */ CompletionItemKind), +/* harmony export */ CompletionItemTag: () => (/* binding */ CompletionItemTag), +/* harmony export */ CompletionTriggerKind: () => (/* binding */ CompletionTriggerKind), +/* harmony export */ ContentWidgetPositionPreference: () => (/* binding */ ContentWidgetPositionPreference), +/* harmony export */ CursorChangeReason: () => (/* binding */ CursorChangeReason), +/* harmony export */ DefaultEndOfLine: () => (/* binding */ DefaultEndOfLine), +/* harmony export */ DocumentHighlightKind: () => (/* binding */ DocumentHighlightKind), +/* harmony export */ EditorAutoIndentStrategy: () => (/* binding */ EditorAutoIndentStrategy), +/* harmony export */ EditorOption: () => (/* binding */ EditorOption), +/* harmony export */ EndOfLinePreference: () => (/* binding */ EndOfLinePreference), +/* harmony export */ EndOfLineSequence: () => (/* binding */ EndOfLineSequence), +/* harmony export */ GlyphMarginLane: () => (/* binding */ GlyphMarginLane), +/* harmony export */ IndentAction: () => (/* binding */ IndentAction), +/* harmony export */ InjectedTextCursorStops: () => (/* binding */ InjectedTextCursorStops), +/* harmony export */ InlayHintKind: () => (/* binding */ InlayHintKind), +/* harmony export */ InlineCompletionTriggerKind: () => (/* binding */ InlineCompletionTriggerKind), +/* harmony export */ KeyCode: () => (/* binding */ KeyCode), +/* harmony export */ MarkerSeverity: () => (/* binding */ MarkerSeverity), +/* harmony export */ MarkerTag: () => (/* binding */ MarkerTag), +/* harmony export */ MinimapPosition: () => (/* binding */ MinimapPosition), +/* harmony export */ MouseTargetType: () => (/* binding */ MouseTargetType), +/* harmony export */ OverlayWidgetPositionPreference: () => (/* binding */ OverlayWidgetPositionPreference), +/* harmony export */ OverviewRulerLane: () => (/* binding */ OverviewRulerLane), +/* harmony export */ PositionAffinity: () => (/* binding */ PositionAffinity), +/* harmony export */ RenderLineNumbersType: () => (/* binding */ RenderLineNumbersType), +/* harmony export */ RenderMinimap: () => (/* binding */ RenderMinimap), +/* harmony export */ ScrollType: () => (/* binding */ ScrollType), +/* harmony export */ ScrollbarVisibility: () => (/* binding */ ScrollbarVisibility), +/* harmony export */ SelectionDirection: () => (/* binding */ SelectionDirection), +/* harmony export */ ShowAiIconMode: () => (/* binding */ ShowAiIconMode), +/* harmony export */ SignatureHelpTriggerKind: () => (/* binding */ SignatureHelpTriggerKind), +/* harmony export */ SymbolKind: () => (/* binding */ SymbolKind), +/* harmony export */ SymbolTag: () => (/* binding */ SymbolTag), +/* harmony export */ TextEditorCursorBlinkingStyle: () => (/* binding */ TextEditorCursorBlinkingStyle), +/* harmony export */ TextEditorCursorStyle: () => (/* binding */ TextEditorCursorStyle), +/* harmony export */ TrackedRangeStickiness: () => (/* binding */ TrackedRangeStickiness), +/* harmony export */ WrappingIndent: () => (/* binding */ WrappingIndent) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY. +var AccessibilitySupport; +(function (AccessibilitySupport) { + /** + * This should be the browser case where it is not known if a screen reader is attached or no. + */ + AccessibilitySupport[AccessibilitySupport["Unknown"] = 0] = "Unknown"; + AccessibilitySupport[AccessibilitySupport["Disabled"] = 1] = "Disabled"; + AccessibilitySupport[AccessibilitySupport["Enabled"] = 2] = "Enabled"; +})(AccessibilitySupport || (AccessibilitySupport = {})); +var CodeActionTriggerType; +(function (CodeActionTriggerType) { + CodeActionTriggerType[CodeActionTriggerType["Invoke"] = 1] = "Invoke"; + CodeActionTriggerType[CodeActionTriggerType["Auto"] = 2] = "Auto"; +})(CodeActionTriggerType || (CodeActionTriggerType = {})); +var CompletionItemInsertTextRule; +(function (CompletionItemInsertTextRule) { + CompletionItemInsertTextRule[CompletionItemInsertTextRule["None"] = 0] = "None"; + /** + * Adjust whitespace/indentation of multiline insert texts to + * match the current line indentation. + */ + CompletionItemInsertTextRule[CompletionItemInsertTextRule["KeepWhitespace"] = 1] = "KeepWhitespace"; + /** + * `insertText` is a snippet. + */ + CompletionItemInsertTextRule[CompletionItemInsertTextRule["InsertAsSnippet"] = 4] = "InsertAsSnippet"; +})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {})); +var CompletionItemKind; +(function (CompletionItemKind) { + CompletionItemKind[CompletionItemKind["Method"] = 0] = "Method"; + CompletionItemKind[CompletionItemKind["Function"] = 1] = "Function"; + CompletionItemKind[CompletionItemKind["Constructor"] = 2] = "Constructor"; + CompletionItemKind[CompletionItemKind["Field"] = 3] = "Field"; + CompletionItemKind[CompletionItemKind["Variable"] = 4] = "Variable"; + CompletionItemKind[CompletionItemKind["Class"] = 5] = "Class"; + CompletionItemKind[CompletionItemKind["Struct"] = 6] = "Struct"; + CompletionItemKind[CompletionItemKind["Interface"] = 7] = "Interface"; + CompletionItemKind[CompletionItemKind["Module"] = 8] = "Module"; + CompletionItemKind[CompletionItemKind["Property"] = 9] = "Property"; + CompletionItemKind[CompletionItemKind["Event"] = 10] = "Event"; + CompletionItemKind[CompletionItemKind["Operator"] = 11] = "Operator"; + CompletionItemKind[CompletionItemKind["Unit"] = 12] = "Unit"; + CompletionItemKind[CompletionItemKind["Value"] = 13] = "Value"; + CompletionItemKind[CompletionItemKind["Constant"] = 14] = "Constant"; + CompletionItemKind[CompletionItemKind["Enum"] = 15] = "Enum"; + CompletionItemKind[CompletionItemKind["EnumMember"] = 16] = "EnumMember"; + CompletionItemKind[CompletionItemKind["Keyword"] = 17] = "Keyword"; + CompletionItemKind[CompletionItemKind["Text"] = 18] = "Text"; + CompletionItemKind[CompletionItemKind["Color"] = 19] = "Color"; + CompletionItemKind[CompletionItemKind["File"] = 20] = "File"; + CompletionItemKind[CompletionItemKind["Reference"] = 21] = "Reference"; + CompletionItemKind[CompletionItemKind["Customcolor"] = 22] = "Customcolor"; + CompletionItemKind[CompletionItemKind["Folder"] = 23] = "Folder"; + CompletionItemKind[CompletionItemKind["TypeParameter"] = 24] = "TypeParameter"; + CompletionItemKind[CompletionItemKind["User"] = 25] = "User"; + CompletionItemKind[CompletionItemKind["Issue"] = 26] = "Issue"; + CompletionItemKind[CompletionItemKind["Snippet"] = 27] = "Snippet"; +})(CompletionItemKind || (CompletionItemKind = {})); +var CompletionItemTag; +(function (CompletionItemTag) { + CompletionItemTag[CompletionItemTag["Deprecated"] = 1] = "Deprecated"; +})(CompletionItemTag || (CompletionItemTag = {})); +/** + * How a suggest provider was triggered. + */ +var CompletionTriggerKind; +(function (CompletionTriggerKind) { + CompletionTriggerKind[CompletionTriggerKind["Invoke"] = 0] = "Invoke"; + CompletionTriggerKind[CompletionTriggerKind["TriggerCharacter"] = 1] = "TriggerCharacter"; + CompletionTriggerKind[CompletionTriggerKind["TriggerForIncompleteCompletions"] = 2] = "TriggerForIncompleteCompletions"; +})(CompletionTriggerKind || (CompletionTriggerKind = {})); +/** + * A positioning preference for rendering content widgets. + */ +var ContentWidgetPositionPreference; +(function (ContentWidgetPositionPreference) { + /** + * Place the content widget exactly at a position + */ + ContentWidgetPositionPreference[ContentWidgetPositionPreference["EXACT"] = 0] = "EXACT"; + /** + * Place the content widget above a position + */ + ContentWidgetPositionPreference[ContentWidgetPositionPreference["ABOVE"] = 1] = "ABOVE"; + /** + * Place the content widget below a position + */ + ContentWidgetPositionPreference[ContentWidgetPositionPreference["BELOW"] = 2] = "BELOW"; +})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {})); +/** + * Describes the reason the cursor has changed its position. + */ +var CursorChangeReason; +(function (CursorChangeReason) { + /** + * Unknown or not set. + */ + CursorChangeReason[CursorChangeReason["NotSet"] = 0] = "NotSet"; + /** + * A `model.setValue()` was called. + */ + CursorChangeReason[CursorChangeReason["ContentFlush"] = 1] = "ContentFlush"; + /** + * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers. + */ + CursorChangeReason[CursorChangeReason["RecoverFromMarkers"] = 2] = "RecoverFromMarkers"; + /** + * There was an explicit user gesture. + */ + CursorChangeReason[CursorChangeReason["Explicit"] = 3] = "Explicit"; + /** + * There was a Paste. + */ + CursorChangeReason[CursorChangeReason["Paste"] = 4] = "Paste"; + /** + * There was an Undo. + */ + CursorChangeReason[CursorChangeReason["Undo"] = 5] = "Undo"; + /** + * There was a Redo. + */ + CursorChangeReason[CursorChangeReason["Redo"] = 6] = "Redo"; +})(CursorChangeReason || (CursorChangeReason = {})); +/** + * The default end of line to use when instantiating models. + */ +var DefaultEndOfLine; +(function (DefaultEndOfLine) { + /** + * Use line feed (\n) as the end of line character. + */ + DefaultEndOfLine[DefaultEndOfLine["LF"] = 1] = "LF"; + /** + * Use carriage return and line feed (\r\n) as the end of line character. + */ + DefaultEndOfLine[DefaultEndOfLine["CRLF"] = 2] = "CRLF"; +})(DefaultEndOfLine || (DefaultEndOfLine = {})); +/** + * A document highlight kind. + */ +var DocumentHighlightKind; +(function (DocumentHighlightKind) { + /** + * A textual occurrence. + */ + DocumentHighlightKind[DocumentHighlightKind["Text"] = 0] = "Text"; + /** + * Read-access of a symbol, like reading a variable. + */ + DocumentHighlightKind[DocumentHighlightKind["Read"] = 1] = "Read"; + /** + * Write-access of a symbol, like writing to a variable. + */ + DocumentHighlightKind[DocumentHighlightKind["Write"] = 2] = "Write"; +})(DocumentHighlightKind || (DocumentHighlightKind = {})); +/** + * Configuration options for auto indentation in the editor + */ +var EditorAutoIndentStrategy; +(function (EditorAutoIndentStrategy) { + EditorAutoIndentStrategy[EditorAutoIndentStrategy["None"] = 0] = "None"; + EditorAutoIndentStrategy[EditorAutoIndentStrategy["Keep"] = 1] = "Keep"; + EditorAutoIndentStrategy[EditorAutoIndentStrategy["Brackets"] = 2] = "Brackets"; + EditorAutoIndentStrategy[EditorAutoIndentStrategy["Advanced"] = 3] = "Advanced"; + EditorAutoIndentStrategy[EditorAutoIndentStrategy["Full"] = 4] = "Full"; +})(EditorAutoIndentStrategy || (EditorAutoIndentStrategy = {})); +var EditorOption; +(function (EditorOption) { + EditorOption[EditorOption["acceptSuggestionOnCommitCharacter"] = 0] = "acceptSuggestionOnCommitCharacter"; + EditorOption[EditorOption["acceptSuggestionOnEnter"] = 1] = "acceptSuggestionOnEnter"; + EditorOption[EditorOption["accessibilitySupport"] = 2] = "accessibilitySupport"; + EditorOption[EditorOption["accessibilityPageSize"] = 3] = "accessibilityPageSize"; + EditorOption[EditorOption["ariaLabel"] = 4] = "ariaLabel"; + EditorOption[EditorOption["ariaRequired"] = 5] = "ariaRequired"; + EditorOption[EditorOption["autoClosingBrackets"] = 6] = "autoClosingBrackets"; + EditorOption[EditorOption["autoClosingComments"] = 7] = "autoClosingComments"; + EditorOption[EditorOption["screenReaderAnnounceInlineSuggestion"] = 8] = "screenReaderAnnounceInlineSuggestion"; + EditorOption[EditorOption["autoClosingDelete"] = 9] = "autoClosingDelete"; + EditorOption[EditorOption["autoClosingOvertype"] = 10] = "autoClosingOvertype"; + EditorOption[EditorOption["autoClosingQuotes"] = 11] = "autoClosingQuotes"; + EditorOption[EditorOption["autoIndent"] = 12] = "autoIndent"; + EditorOption[EditorOption["automaticLayout"] = 13] = "automaticLayout"; + EditorOption[EditorOption["autoSurround"] = 14] = "autoSurround"; + EditorOption[EditorOption["bracketPairColorization"] = 15] = "bracketPairColorization"; + EditorOption[EditorOption["guides"] = 16] = "guides"; + EditorOption[EditorOption["codeLens"] = 17] = "codeLens"; + EditorOption[EditorOption["codeLensFontFamily"] = 18] = "codeLensFontFamily"; + EditorOption[EditorOption["codeLensFontSize"] = 19] = "codeLensFontSize"; + EditorOption[EditorOption["colorDecorators"] = 20] = "colorDecorators"; + EditorOption[EditorOption["colorDecoratorsLimit"] = 21] = "colorDecoratorsLimit"; + EditorOption[EditorOption["columnSelection"] = 22] = "columnSelection"; + EditorOption[EditorOption["comments"] = 23] = "comments"; + EditorOption[EditorOption["contextmenu"] = 24] = "contextmenu"; + EditorOption[EditorOption["copyWithSyntaxHighlighting"] = 25] = "copyWithSyntaxHighlighting"; + EditorOption[EditorOption["cursorBlinking"] = 26] = "cursorBlinking"; + EditorOption[EditorOption["cursorSmoothCaretAnimation"] = 27] = "cursorSmoothCaretAnimation"; + EditorOption[EditorOption["cursorStyle"] = 28] = "cursorStyle"; + EditorOption[EditorOption["cursorSurroundingLines"] = 29] = "cursorSurroundingLines"; + EditorOption[EditorOption["cursorSurroundingLinesStyle"] = 30] = "cursorSurroundingLinesStyle"; + EditorOption[EditorOption["cursorWidth"] = 31] = "cursorWidth"; + EditorOption[EditorOption["disableLayerHinting"] = 32] = "disableLayerHinting"; + EditorOption[EditorOption["disableMonospaceOptimizations"] = 33] = "disableMonospaceOptimizations"; + EditorOption[EditorOption["domReadOnly"] = 34] = "domReadOnly"; + EditorOption[EditorOption["dragAndDrop"] = 35] = "dragAndDrop"; + EditorOption[EditorOption["dropIntoEditor"] = 36] = "dropIntoEditor"; + EditorOption[EditorOption["emptySelectionClipboard"] = 37] = "emptySelectionClipboard"; + EditorOption[EditorOption["experimentalWhitespaceRendering"] = 38] = "experimentalWhitespaceRendering"; + EditorOption[EditorOption["extraEditorClassName"] = 39] = "extraEditorClassName"; + EditorOption[EditorOption["fastScrollSensitivity"] = 40] = "fastScrollSensitivity"; + EditorOption[EditorOption["find"] = 41] = "find"; + EditorOption[EditorOption["fixedOverflowWidgets"] = 42] = "fixedOverflowWidgets"; + EditorOption[EditorOption["folding"] = 43] = "folding"; + EditorOption[EditorOption["foldingStrategy"] = 44] = "foldingStrategy"; + EditorOption[EditorOption["foldingHighlight"] = 45] = "foldingHighlight"; + EditorOption[EditorOption["foldingImportsByDefault"] = 46] = "foldingImportsByDefault"; + EditorOption[EditorOption["foldingMaximumRegions"] = 47] = "foldingMaximumRegions"; + EditorOption[EditorOption["unfoldOnClickAfterEndOfLine"] = 48] = "unfoldOnClickAfterEndOfLine"; + EditorOption[EditorOption["fontFamily"] = 49] = "fontFamily"; + EditorOption[EditorOption["fontInfo"] = 50] = "fontInfo"; + EditorOption[EditorOption["fontLigatures"] = 51] = "fontLigatures"; + EditorOption[EditorOption["fontSize"] = 52] = "fontSize"; + EditorOption[EditorOption["fontWeight"] = 53] = "fontWeight"; + EditorOption[EditorOption["fontVariations"] = 54] = "fontVariations"; + EditorOption[EditorOption["formatOnPaste"] = 55] = "formatOnPaste"; + EditorOption[EditorOption["formatOnType"] = 56] = "formatOnType"; + EditorOption[EditorOption["glyphMargin"] = 57] = "glyphMargin"; + EditorOption[EditorOption["gotoLocation"] = 58] = "gotoLocation"; + EditorOption[EditorOption["hideCursorInOverviewRuler"] = 59] = "hideCursorInOverviewRuler"; + EditorOption[EditorOption["hover"] = 60] = "hover"; + EditorOption[EditorOption["inDiffEditor"] = 61] = "inDiffEditor"; + EditorOption[EditorOption["inlineSuggest"] = 62] = "inlineSuggest"; + EditorOption[EditorOption["letterSpacing"] = 63] = "letterSpacing"; + EditorOption[EditorOption["lightbulb"] = 64] = "lightbulb"; + EditorOption[EditorOption["lineDecorationsWidth"] = 65] = "lineDecorationsWidth"; + EditorOption[EditorOption["lineHeight"] = 66] = "lineHeight"; + EditorOption[EditorOption["lineNumbers"] = 67] = "lineNumbers"; + EditorOption[EditorOption["lineNumbersMinChars"] = 68] = "lineNumbersMinChars"; + EditorOption[EditorOption["linkedEditing"] = 69] = "linkedEditing"; + EditorOption[EditorOption["links"] = 70] = "links"; + EditorOption[EditorOption["matchBrackets"] = 71] = "matchBrackets"; + EditorOption[EditorOption["minimap"] = 72] = "minimap"; + EditorOption[EditorOption["mouseStyle"] = 73] = "mouseStyle"; + EditorOption[EditorOption["mouseWheelScrollSensitivity"] = 74] = "mouseWheelScrollSensitivity"; + EditorOption[EditorOption["mouseWheelZoom"] = 75] = "mouseWheelZoom"; + EditorOption[EditorOption["multiCursorMergeOverlapping"] = 76] = "multiCursorMergeOverlapping"; + EditorOption[EditorOption["multiCursorModifier"] = 77] = "multiCursorModifier"; + EditorOption[EditorOption["multiCursorPaste"] = 78] = "multiCursorPaste"; + EditorOption[EditorOption["multiCursorLimit"] = 79] = "multiCursorLimit"; + EditorOption[EditorOption["occurrencesHighlight"] = 80] = "occurrencesHighlight"; + EditorOption[EditorOption["overviewRulerBorder"] = 81] = "overviewRulerBorder"; + EditorOption[EditorOption["overviewRulerLanes"] = 82] = "overviewRulerLanes"; + EditorOption[EditorOption["padding"] = 83] = "padding"; + EditorOption[EditorOption["pasteAs"] = 84] = "pasteAs"; + EditorOption[EditorOption["parameterHints"] = 85] = "parameterHints"; + EditorOption[EditorOption["peekWidgetDefaultFocus"] = 86] = "peekWidgetDefaultFocus"; + EditorOption[EditorOption["definitionLinkOpensInPeek"] = 87] = "definitionLinkOpensInPeek"; + EditorOption[EditorOption["quickSuggestions"] = 88] = "quickSuggestions"; + EditorOption[EditorOption["quickSuggestionsDelay"] = 89] = "quickSuggestionsDelay"; + EditorOption[EditorOption["readOnly"] = 90] = "readOnly"; + EditorOption[EditorOption["readOnlyMessage"] = 91] = "readOnlyMessage"; + EditorOption[EditorOption["renameOnType"] = 92] = "renameOnType"; + EditorOption[EditorOption["renderControlCharacters"] = 93] = "renderControlCharacters"; + EditorOption[EditorOption["renderFinalNewline"] = 94] = "renderFinalNewline"; + EditorOption[EditorOption["renderLineHighlight"] = 95] = "renderLineHighlight"; + EditorOption[EditorOption["renderLineHighlightOnlyWhenFocus"] = 96] = "renderLineHighlightOnlyWhenFocus"; + EditorOption[EditorOption["renderValidationDecorations"] = 97] = "renderValidationDecorations"; + EditorOption[EditorOption["renderWhitespace"] = 98] = "renderWhitespace"; + EditorOption[EditorOption["revealHorizontalRightPadding"] = 99] = "revealHorizontalRightPadding"; + EditorOption[EditorOption["roundedSelection"] = 100] = "roundedSelection"; + EditorOption[EditorOption["rulers"] = 101] = "rulers"; + EditorOption[EditorOption["scrollbar"] = 102] = "scrollbar"; + EditorOption[EditorOption["scrollBeyondLastColumn"] = 103] = "scrollBeyondLastColumn"; + EditorOption[EditorOption["scrollBeyondLastLine"] = 104] = "scrollBeyondLastLine"; + EditorOption[EditorOption["scrollPredominantAxis"] = 105] = "scrollPredominantAxis"; + EditorOption[EditorOption["selectionClipboard"] = 106] = "selectionClipboard"; + EditorOption[EditorOption["selectionHighlight"] = 107] = "selectionHighlight"; + EditorOption[EditorOption["selectOnLineNumbers"] = 108] = "selectOnLineNumbers"; + EditorOption[EditorOption["showFoldingControls"] = 109] = "showFoldingControls"; + EditorOption[EditorOption["showUnused"] = 110] = "showUnused"; + EditorOption[EditorOption["snippetSuggestions"] = 111] = "snippetSuggestions"; + EditorOption[EditorOption["smartSelect"] = 112] = "smartSelect"; + EditorOption[EditorOption["smoothScrolling"] = 113] = "smoothScrolling"; + EditorOption[EditorOption["stickyScroll"] = 114] = "stickyScroll"; + EditorOption[EditorOption["stickyTabStops"] = 115] = "stickyTabStops"; + EditorOption[EditorOption["stopRenderingLineAfter"] = 116] = "stopRenderingLineAfter"; + EditorOption[EditorOption["suggest"] = 117] = "suggest"; + EditorOption[EditorOption["suggestFontSize"] = 118] = "suggestFontSize"; + EditorOption[EditorOption["suggestLineHeight"] = 119] = "suggestLineHeight"; + EditorOption[EditorOption["suggestOnTriggerCharacters"] = 120] = "suggestOnTriggerCharacters"; + EditorOption[EditorOption["suggestSelection"] = 121] = "suggestSelection"; + EditorOption[EditorOption["tabCompletion"] = 122] = "tabCompletion"; + EditorOption[EditorOption["tabIndex"] = 123] = "tabIndex"; + EditorOption[EditorOption["unicodeHighlighting"] = 124] = "unicodeHighlighting"; + EditorOption[EditorOption["unusualLineTerminators"] = 125] = "unusualLineTerminators"; + EditorOption[EditorOption["useShadowDOM"] = 126] = "useShadowDOM"; + EditorOption[EditorOption["useTabStops"] = 127] = "useTabStops"; + EditorOption[EditorOption["wordBreak"] = 128] = "wordBreak"; + EditorOption[EditorOption["wordSeparators"] = 129] = "wordSeparators"; + EditorOption[EditorOption["wordWrap"] = 130] = "wordWrap"; + EditorOption[EditorOption["wordWrapBreakAfterCharacters"] = 131] = "wordWrapBreakAfterCharacters"; + EditorOption[EditorOption["wordWrapBreakBeforeCharacters"] = 132] = "wordWrapBreakBeforeCharacters"; + EditorOption[EditorOption["wordWrapColumn"] = 133] = "wordWrapColumn"; + EditorOption[EditorOption["wordWrapOverride1"] = 134] = "wordWrapOverride1"; + EditorOption[EditorOption["wordWrapOverride2"] = 135] = "wordWrapOverride2"; + EditorOption[EditorOption["wrappingIndent"] = 136] = "wrappingIndent"; + EditorOption[EditorOption["wrappingStrategy"] = 137] = "wrappingStrategy"; + EditorOption[EditorOption["showDeprecated"] = 138] = "showDeprecated"; + EditorOption[EditorOption["inlayHints"] = 139] = "inlayHints"; + EditorOption[EditorOption["editorClassName"] = 140] = "editorClassName"; + EditorOption[EditorOption["pixelRatio"] = 141] = "pixelRatio"; + EditorOption[EditorOption["tabFocusMode"] = 142] = "tabFocusMode"; + EditorOption[EditorOption["layoutInfo"] = 143] = "layoutInfo"; + EditorOption[EditorOption["wrappingInfo"] = 144] = "wrappingInfo"; + EditorOption[EditorOption["defaultColorDecorators"] = 145] = "defaultColorDecorators"; + EditorOption[EditorOption["colorDecoratorsActivatedOn"] = 146] = "colorDecoratorsActivatedOn"; + EditorOption[EditorOption["inlineCompletionsAccessibilityVerbose"] = 147] = "inlineCompletionsAccessibilityVerbose"; +})(EditorOption || (EditorOption = {})); +/** + * End of line character preference. + */ +var EndOfLinePreference; +(function (EndOfLinePreference) { + /** + * Use the end of line character identified in the text buffer. + */ + EndOfLinePreference[EndOfLinePreference["TextDefined"] = 0] = "TextDefined"; + /** + * Use line feed (\n) as the end of line character. + */ + EndOfLinePreference[EndOfLinePreference["LF"] = 1] = "LF"; + /** + * Use carriage return and line feed (\r\n) as the end of line character. + */ + EndOfLinePreference[EndOfLinePreference["CRLF"] = 2] = "CRLF"; +})(EndOfLinePreference || (EndOfLinePreference = {})); +/** + * End of line character preference. + */ +var EndOfLineSequence; +(function (EndOfLineSequence) { + /** + * Use line feed (\n) as the end of line character. + */ + EndOfLineSequence[EndOfLineSequence["LF"] = 0] = "LF"; + /** + * Use carriage return and line feed (\r\n) as the end of line character. + */ + EndOfLineSequence[EndOfLineSequence["CRLF"] = 1] = "CRLF"; +})(EndOfLineSequence || (EndOfLineSequence = {})); +/** + * Vertical Lane in the glyph margin of the editor. + */ +var GlyphMarginLane; +(function (GlyphMarginLane) { + GlyphMarginLane[GlyphMarginLane["Left"] = 1] = "Left"; + GlyphMarginLane[GlyphMarginLane["Right"] = 2] = "Right"; +})(GlyphMarginLane || (GlyphMarginLane = {})); +/** + * Describes what to do with the indentation when pressing Enter. + */ +var IndentAction; +(function (IndentAction) { + /** + * Insert new line and copy the previous line's indentation. + */ + IndentAction[IndentAction["None"] = 0] = "None"; + /** + * Insert new line and indent once (relative to the previous line's indentation). + */ + IndentAction[IndentAction["Indent"] = 1] = "Indent"; + /** + * Insert two new lines: + * - the first one indented which will hold the cursor + * - the second one at the same indentation level + */ + IndentAction[IndentAction["IndentOutdent"] = 2] = "IndentOutdent"; + /** + * Insert new line and outdent once (relative to the previous line's indentation). + */ + IndentAction[IndentAction["Outdent"] = 3] = "Outdent"; +})(IndentAction || (IndentAction = {})); +var InjectedTextCursorStops; +(function (InjectedTextCursorStops) { + InjectedTextCursorStops[InjectedTextCursorStops["Both"] = 0] = "Both"; + InjectedTextCursorStops[InjectedTextCursorStops["Right"] = 1] = "Right"; + InjectedTextCursorStops[InjectedTextCursorStops["Left"] = 2] = "Left"; + InjectedTextCursorStops[InjectedTextCursorStops["None"] = 3] = "None"; +})(InjectedTextCursorStops || (InjectedTextCursorStops = {})); +var InlayHintKind; +(function (InlayHintKind) { + InlayHintKind[InlayHintKind["Type"] = 1] = "Type"; + InlayHintKind[InlayHintKind["Parameter"] = 2] = "Parameter"; +})(InlayHintKind || (InlayHintKind = {})); +/** + * How an {@link InlineCompletionsProvider inline completion provider} was triggered. + */ +var InlineCompletionTriggerKind; +(function (InlineCompletionTriggerKind) { + /** + * Completion was triggered automatically while editing. + * It is sufficient to return a single completion item in this case. + */ + InlineCompletionTriggerKind[InlineCompletionTriggerKind["Automatic"] = 0] = "Automatic"; + /** + * Completion was triggered explicitly by a user gesture. + * Return multiple completion items to enable cycling through them. + */ + InlineCompletionTriggerKind[InlineCompletionTriggerKind["Explicit"] = 1] = "Explicit"; +})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {})); +/** + * Virtual Key Codes, the value does not hold any inherent meaning. + * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx + * But these are "more general", as they should work across browsers & OS`s. + */ +var KeyCode; +(function (KeyCode) { + KeyCode[KeyCode["DependsOnKbLayout"] = -1] = "DependsOnKbLayout"; + /** + * Placed first to cover the 0 value of the enum. + */ + KeyCode[KeyCode["Unknown"] = 0] = "Unknown"; + KeyCode[KeyCode["Backspace"] = 1] = "Backspace"; + KeyCode[KeyCode["Tab"] = 2] = "Tab"; + KeyCode[KeyCode["Enter"] = 3] = "Enter"; + KeyCode[KeyCode["Shift"] = 4] = "Shift"; + KeyCode[KeyCode["Ctrl"] = 5] = "Ctrl"; + KeyCode[KeyCode["Alt"] = 6] = "Alt"; + KeyCode[KeyCode["PauseBreak"] = 7] = "PauseBreak"; + KeyCode[KeyCode["CapsLock"] = 8] = "CapsLock"; + KeyCode[KeyCode["Escape"] = 9] = "Escape"; + KeyCode[KeyCode["Space"] = 10] = "Space"; + KeyCode[KeyCode["PageUp"] = 11] = "PageUp"; + KeyCode[KeyCode["PageDown"] = 12] = "PageDown"; + KeyCode[KeyCode["End"] = 13] = "End"; + KeyCode[KeyCode["Home"] = 14] = "Home"; + KeyCode[KeyCode["LeftArrow"] = 15] = "LeftArrow"; + KeyCode[KeyCode["UpArrow"] = 16] = "UpArrow"; + KeyCode[KeyCode["RightArrow"] = 17] = "RightArrow"; + KeyCode[KeyCode["DownArrow"] = 18] = "DownArrow"; + KeyCode[KeyCode["Insert"] = 19] = "Insert"; + KeyCode[KeyCode["Delete"] = 20] = "Delete"; + KeyCode[KeyCode["Digit0"] = 21] = "Digit0"; + KeyCode[KeyCode["Digit1"] = 22] = "Digit1"; + KeyCode[KeyCode["Digit2"] = 23] = "Digit2"; + KeyCode[KeyCode["Digit3"] = 24] = "Digit3"; + KeyCode[KeyCode["Digit4"] = 25] = "Digit4"; + KeyCode[KeyCode["Digit5"] = 26] = "Digit5"; + KeyCode[KeyCode["Digit6"] = 27] = "Digit6"; + KeyCode[KeyCode["Digit7"] = 28] = "Digit7"; + KeyCode[KeyCode["Digit8"] = 29] = "Digit8"; + KeyCode[KeyCode["Digit9"] = 30] = "Digit9"; + KeyCode[KeyCode["KeyA"] = 31] = "KeyA"; + KeyCode[KeyCode["KeyB"] = 32] = "KeyB"; + KeyCode[KeyCode["KeyC"] = 33] = "KeyC"; + KeyCode[KeyCode["KeyD"] = 34] = "KeyD"; + KeyCode[KeyCode["KeyE"] = 35] = "KeyE"; + KeyCode[KeyCode["KeyF"] = 36] = "KeyF"; + KeyCode[KeyCode["KeyG"] = 37] = "KeyG"; + KeyCode[KeyCode["KeyH"] = 38] = "KeyH"; + KeyCode[KeyCode["KeyI"] = 39] = "KeyI"; + KeyCode[KeyCode["KeyJ"] = 40] = "KeyJ"; + KeyCode[KeyCode["KeyK"] = 41] = "KeyK"; + KeyCode[KeyCode["KeyL"] = 42] = "KeyL"; + KeyCode[KeyCode["KeyM"] = 43] = "KeyM"; + KeyCode[KeyCode["KeyN"] = 44] = "KeyN"; + KeyCode[KeyCode["KeyO"] = 45] = "KeyO"; + KeyCode[KeyCode["KeyP"] = 46] = "KeyP"; + KeyCode[KeyCode["KeyQ"] = 47] = "KeyQ"; + KeyCode[KeyCode["KeyR"] = 48] = "KeyR"; + KeyCode[KeyCode["KeyS"] = 49] = "KeyS"; + KeyCode[KeyCode["KeyT"] = 50] = "KeyT"; + KeyCode[KeyCode["KeyU"] = 51] = "KeyU"; + KeyCode[KeyCode["KeyV"] = 52] = "KeyV"; + KeyCode[KeyCode["KeyW"] = 53] = "KeyW"; + KeyCode[KeyCode["KeyX"] = 54] = "KeyX"; + KeyCode[KeyCode["KeyY"] = 55] = "KeyY"; + KeyCode[KeyCode["KeyZ"] = 56] = "KeyZ"; + KeyCode[KeyCode["Meta"] = 57] = "Meta"; + KeyCode[KeyCode["ContextMenu"] = 58] = "ContextMenu"; + KeyCode[KeyCode["F1"] = 59] = "F1"; + KeyCode[KeyCode["F2"] = 60] = "F2"; + KeyCode[KeyCode["F3"] = 61] = "F3"; + KeyCode[KeyCode["F4"] = 62] = "F4"; + KeyCode[KeyCode["F5"] = 63] = "F5"; + KeyCode[KeyCode["F6"] = 64] = "F6"; + KeyCode[KeyCode["F7"] = 65] = "F7"; + KeyCode[KeyCode["F8"] = 66] = "F8"; + KeyCode[KeyCode["F9"] = 67] = "F9"; + KeyCode[KeyCode["F10"] = 68] = "F10"; + KeyCode[KeyCode["F11"] = 69] = "F11"; + KeyCode[KeyCode["F12"] = 70] = "F12"; + KeyCode[KeyCode["F13"] = 71] = "F13"; + KeyCode[KeyCode["F14"] = 72] = "F14"; + KeyCode[KeyCode["F15"] = 73] = "F15"; + KeyCode[KeyCode["F16"] = 74] = "F16"; + KeyCode[KeyCode["F17"] = 75] = "F17"; + KeyCode[KeyCode["F18"] = 76] = "F18"; + KeyCode[KeyCode["F19"] = 77] = "F19"; + KeyCode[KeyCode["F20"] = 78] = "F20"; + KeyCode[KeyCode["F21"] = 79] = "F21"; + KeyCode[KeyCode["F22"] = 80] = "F22"; + KeyCode[KeyCode["F23"] = 81] = "F23"; + KeyCode[KeyCode["F24"] = 82] = "F24"; + KeyCode[KeyCode["NumLock"] = 83] = "NumLock"; + KeyCode[KeyCode["ScrollLock"] = 84] = "ScrollLock"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + * For the US standard keyboard, the ';:' key + */ + KeyCode[KeyCode["Semicolon"] = 85] = "Semicolon"; + /** + * For any country/region, the '+' key + * For the US standard keyboard, the '=+' key + */ + KeyCode[KeyCode["Equal"] = 86] = "Equal"; + /** + * For any country/region, the ',' key + * For the US standard keyboard, the ',<' key + */ + KeyCode[KeyCode["Comma"] = 87] = "Comma"; + /** + * For any country/region, the '-' key + * For the US standard keyboard, the '-_' key + */ + KeyCode[KeyCode["Minus"] = 88] = "Minus"; + /** + * For any country/region, the '.' key + * For the US standard keyboard, the '.>' key + */ + KeyCode[KeyCode["Period"] = 89] = "Period"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + * For the US standard keyboard, the '/?' key + */ + KeyCode[KeyCode["Slash"] = 90] = "Slash"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + * For the US standard keyboard, the '`~' key + */ + KeyCode[KeyCode["Backquote"] = 91] = "Backquote"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + * For the US standard keyboard, the '[{' key + */ + KeyCode[KeyCode["BracketLeft"] = 92] = "BracketLeft"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + * For the US standard keyboard, the '\|' key + */ + KeyCode[KeyCode["Backslash"] = 93] = "Backslash"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + * For the US standard keyboard, the ']}' key + */ + KeyCode[KeyCode["BracketRight"] = 94] = "BracketRight"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + * For the US standard keyboard, the ''"' key + */ + KeyCode[KeyCode["Quote"] = 95] = "Quote"; + /** + * Used for miscellaneous characters; it can vary by keyboard. + */ + KeyCode[KeyCode["OEM_8"] = 96] = "OEM_8"; + /** + * Either the angle bracket key or the backslash key on the RT 102-key keyboard. + */ + KeyCode[KeyCode["IntlBackslash"] = 97] = "IntlBackslash"; + KeyCode[KeyCode["Numpad0"] = 98] = "Numpad0"; + KeyCode[KeyCode["Numpad1"] = 99] = "Numpad1"; + KeyCode[KeyCode["Numpad2"] = 100] = "Numpad2"; + KeyCode[KeyCode["Numpad3"] = 101] = "Numpad3"; + KeyCode[KeyCode["Numpad4"] = 102] = "Numpad4"; + KeyCode[KeyCode["Numpad5"] = 103] = "Numpad5"; + KeyCode[KeyCode["Numpad6"] = 104] = "Numpad6"; + KeyCode[KeyCode["Numpad7"] = 105] = "Numpad7"; + KeyCode[KeyCode["Numpad8"] = 106] = "Numpad8"; + KeyCode[KeyCode["Numpad9"] = 107] = "Numpad9"; + KeyCode[KeyCode["NumpadMultiply"] = 108] = "NumpadMultiply"; + KeyCode[KeyCode["NumpadAdd"] = 109] = "NumpadAdd"; + KeyCode[KeyCode["NUMPAD_SEPARATOR"] = 110] = "NUMPAD_SEPARATOR"; + KeyCode[KeyCode["NumpadSubtract"] = 111] = "NumpadSubtract"; + KeyCode[KeyCode["NumpadDecimal"] = 112] = "NumpadDecimal"; + KeyCode[KeyCode["NumpadDivide"] = 113] = "NumpadDivide"; + /** + * Cover all key codes when IME is processing input. + */ + KeyCode[KeyCode["KEY_IN_COMPOSITION"] = 114] = "KEY_IN_COMPOSITION"; + KeyCode[KeyCode["ABNT_C1"] = 115] = "ABNT_C1"; + KeyCode[KeyCode["ABNT_C2"] = 116] = "ABNT_C2"; + KeyCode[KeyCode["AudioVolumeMute"] = 117] = "AudioVolumeMute"; + KeyCode[KeyCode["AudioVolumeUp"] = 118] = "AudioVolumeUp"; + KeyCode[KeyCode["AudioVolumeDown"] = 119] = "AudioVolumeDown"; + KeyCode[KeyCode["BrowserSearch"] = 120] = "BrowserSearch"; + KeyCode[KeyCode["BrowserHome"] = 121] = "BrowserHome"; + KeyCode[KeyCode["BrowserBack"] = 122] = "BrowserBack"; + KeyCode[KeyCode["BrowserForward"] = 123] = "BrowserForward"; + KeyCode[KeyCode["MediaTrackNext"] = 124] = "MediaTrackNext"; + KeyCode[KeyCode["MediaTrackPrevious"] = 125] = "MediaTrackPrevious"; + KeyCode[KeyCode["MediaStop"] = 126] = "MediaStop"; + KeyCode[KeyCode["MediaPlayPause"] = 127] = "MediaPlayPause"; + KeyCode[KeyCode["LaunchMediaPlayer"] = 128] = "LaunchMediaPlayer"; + KeyCode[KeyCode["LaunchMail"] = 129] = "LaunchMail"; + KeyCode[KeyCode["LaunchApp2"] = 130] = "LaunchApp2"; + /** + * VK_CLEAR, 0x0C, CLEAR key + */ + KeyCode[KeyCode["Clear"] = 131] = "Clear"; + /** + * Placed last to cover the length of the enum. + * Please do not depend on this value! + */ + KeyCode[KeyCode["MAX_VALUE"] = 132] = "MAX_VALUE"; +})(KeyCode || (KeyCode = {})); +var MarkerSeverity; +(function (MarkerSeverity) { + MarkerSeverity[MarkerSeverity["Hint"] = 1] = "Hint"; + MarkerSeverity[MarkerSeverity["Info"] = 2] = "Info"; + MarkerSeverity[MarkerSeverity["Warning"] = 4] = "Warning"; + MarkerSeverity[MarkerSeverity["Error"] = 8] = "Error"; +})(MarkerSeverity || (MarkerSeverity = {})); +var MarkerTag; +(function (MarkerTag) { + MarkerTag[MarkerTag["Unnecessary"] = 1] = "Unnecessary"; + MarkerTag[MarkerTag["Deprecated"] = 2] = "Deprecated"; +})(MarkerTag || (MarkerTag = {})); +/** + * Position in the minimap to render the decoration. + */ +var MinimapPosition; +(function (MinimapPosition) { + MinimapPosition[MinimapPosition["Inline"] = 1] = "Inline"; + MinimapPosition[MinimapPosition["Gutter"] = 2] = "Gutter"; +})(MinimapPosition || (MinimapPosition = {})); +/** + * Type of hit element with the mouse in the editor. + */ +var MouseTargetType; +(function (MouseTargetType) { + /** + * Mouse is on top of an unknown element. + */ + MouseTargetType[MouseTargetType["UNKNOWN"] = 0] = "UNKNOWN"; + /** + * Mouse is on top of the textarea used for input. + */ + MouseTargetType[MouseTargetType["TEXTAREA"] = 1] = "TEXTAREA"; + /** + * Mouse is on top of the glyph margin + */ + MouseTargetType[MouseTargetType["GUTTER_GLYPH_MARGIN"] = 2] = "GUTTER_GLYPH_MARGIN"; + /** + * Mouse is on top of the line numbers + */ + MouseTargetType[MouseTargetType["GUTTER_LINE_NUMBERS"] = 3] = "GUTTER_LINE_NUMBERS"; + /** + * Mouse is on top of the line decorations + */ + MouseTargetType[MouseTargetType["GUTTER_LINE_DECORATIONS"] = 4] = "GUTTER_LINE_DECORATIONS"; + /** + * Mouse is on top of the whitespace left in the gutter by a view zone. + */ + MouseTargetType[MouseTargetType["GUTTER_VIEW_ZONE"] = 5] = "GUTTER_VIEW_ZONE"; + /** + * Mouse is on top of text in the content. + */ + MouseTargetType[MouseTargetType["CONTENT_TEXT"] = 6] = "CONTENT_TEXT"; + /** + * Mouse is on top of empty space in the content (e.g. after line text or below last line) + */ + MouseTargetType[MouseTargetType["CONTENT_EMPTY"] = 7] = "CONTENT_EMPTY"; + /** + * Mouse is on top of a view zone in the content. + */ + MouseTargetType[MouseTargetType["CONTENT_VIEW_ZONE"] = 8] = "CONTENT_VIEW_ZONE"; + /** + * Mouse is on top of a content widget. + */ + MouseTargetType[MouseTargetType["CONTENT_WIDGET"] = 9] = "CONTENT_WIDGET"; + /** + * Mouse is on top of the decorations overview ruler. + */ + MouseTargetType[MouseTargetType["OVERVIEW_RULER"] = 10] = "OVERVIEW_RULER"; + /** + * Mouse is on top of a scrollbar. + */ + MouseTargetType[MouseTargetType["SCROLLBAR"] = 11] = "SCROLLBAR"; + /** + * Mouse is on top of an overlay widget. + */ + MouseTargetType[MouseTargetType["OVERLAY_WIDGET"] = 12] = "OVERLAY_WIDGET"; + /** + * Mouse is outside of the editor. + */ + MouseTargetType[MouseTargetType["OUTSIDE_EDITOR"] = 13] = "OUTSIDE_EDITOR"; +})(MouseTargetType || (MouseTargetType = {})); +/** + * A positioning preference for rendering overlay widgets. + */ +var OverlayWidgetPositionPreference; +(function (OverlayWidgetPositionPreference) { + /** + * Position the overlay widget in the top right corner + */ + OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_RIGHT_CORNER"] = 0] = "TOP_RIGHT_CORNER"; + /** + * Position the overlay widget in the bottom right corner + */ + OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["BOTTOM_RIGHT_CORNER"] = 1] = "BOTTOM_RIGHT_CORNER"; + /** + * Position the overlay widget in the top center + */ + OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_CENTER"] = 2] = "TOP_CENTER"; +})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {})); +/** + * Vertical Lane in the overview ruler of the editor. + */ +var OverviewRulerLane; +(function (OverviewRulerLane) { + OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left"; + OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center"; + OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right"; + OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full"; +})(OverviewRulerLane || (OverviewRulerLane = {})); +var PositionAffinity; +(function (PositionAffinity) { + /** + * Prefers the left most position. + */ + PositionAffinity[PositionAffinity["Left"] = 0] = "Left"; + /** + * Prefers the right most position. + */ + PositionAffinity[PositionAffinity["Right"] = 1] = "Right"; + /** + * No preference. + */ + PositionAffinity[PositionAffinity["None"] = 2] = "None"; + /** + * If the given position is on injected text, prefers the position left of it. + */ + PositionAffinity[PositionAffinity["LeftOfInjectedText"] = 3] = "LeftOfInjectedText"; + /** + * If the given position is on injected text, prefers the position right of it. + */ + PositionAffinity[PositionAffinity["RightOfInjectedText"] = 4] = "RightOfInjectedText"; +})(PositionAffinity || (PositionAffinity = {})); +var RenderLineNumbersType; +(function (RenderLineNumbersType) { + RenderLineNumbersType[RenderLineNumbersType["Off"] = 0] = "Off"; + RenderLineNumbersType[RenderLineNumbersType["On"] = 1] = "On"; + RenderLineNumbersType[RenderLineNumbersType["Relative"] = 2] = "Relative"; + RenderLineNumbersType[RenderLineNumbersType["Interval"] = 3] = "Interval"; + RenderLineNumbersType[RenderLineNumbersType["Custom"] = 4] = "Custom"; +})(RenderLineNumbersType || (RenderLineNumbersType = {})); +var RenderMinimap; +(function (RenderMinimap) { + RenderMinimap[RenderMinimap["None"] = 0] = "None"; + RenderMinimap[RenderMinimap["Text"] = 1] = "Text"; + RenderMinimap[RenderMinimap["Blocks"] = 2] = "Blocks"; +})(RenderMinimap || (RenderMinimap = {})); +var ScrollType; +(function (ScrollType) { + ScrollType[ScrollType["Smooth"] = 0] = "Smooth"; + ScrollType[ScrollType["Immediate"] = 1] = "Immediate"; +})(ScrollType || (ScrollType = {})); +var ScrollbarVisibility; +(function (ScrollbarVisibility) { + ScrollbarVisibility[ScrollbarVisibility["Auto"] = 1] = "Auto"; + ScrollbarVisibility[ScrollbarVisibility["Hidden"] = 2] = "Hidden"; + ScrollbarVisibility[ScrollbarVisibility["Visible"] = 3] = "Visible"; +})(ScrollbarVisibility || (ScrollbarVisibility = {})); +/** + * The direction of a selection. + */ +var SelectionDirection; +(function (SelectionDirection) { + /** + * The selection starts above where it ends. + */ + SelectionDirection[SelectionDirection["LTR"] = 0] = "LTR"; + /** + * The selection starts below where it ends. + */ + SelectionDirection[SelectionDirection["RTL"] = 1] = "RTL"; +})(SelectionDirection || (SelectionDirection = {})); +var ShowAiIconMode; +(function (ShowAiIconMode) { + ShowAiIconMode["Off"] = "off"; + ShowAiIconMode["OnCode"] = "onCode"; + ShowAiIconMode["On"] = "on"; +})(ShowAiIconMode || (ShowAiIconMode = {})); +var SignatureHelpTriggerKind; +(function (SignatureHelpTriggerKind) { + SignatureHelpTriggerKind[SignatureHelpTriggerKind["Invoke"] = 1] = "Invoke"; + SignatureHelpTriggerKind[SignatureHelpTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter"; + SignatureHelpTriggerKind[SignatureHelpTriggerKind["ContentChange"] = 3] = "ContentChange"; +})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {})); +/** + * A symbol kind. + */ +var SymbolKind; +(function (SymbolKind) { + SymbolKind[SymbolKind["File"] = 0] = "File"; + SymbolKind[SymbolKind["Module"] = 1] = "Module"; + SymbolKind[SymbolKind["Namespace"] = 2] = "Namespace"; + SymbolKind[SymbolKind["Package"] = 3] = "Package"; + SymbolKind[SymbolKind["Class"] = 4] = "Class"; + SymbolKind[SymbolKind["Method"] = 5] = "Method"; + SymbolKind[SymbolKind["Property"] = 6] = "Property"; + SymbolKind[SymbolKind["Field"] = 7] = "Field"; + SymbolKind[SymbolKind["Constructor"] = 8] = "Constructor"; + SymbolKind[SymbolKind["Enum"] = 9] = "Enum"; + SymbolKind[SymbolKind["Interface"] = 10] = "Interface"; + SymbolKind[SymbolKind["Function"] = 11] = "Function"; + SymbolKind[SymbolKind["Variable"] = 12] = "Variable"; + SymbolKind[SymbolKind["Constant"] = 13] = "Constant"; + SymbolKind[SymbolKind["String"] = 14] = "String"; + SymbolKind[SymbolKind["Number"] = 15] = "Number"; + SymbolKind[SymbolKind["Boolean"] = 16] = "Boolean"; + SymbolKind[SymbolKind["Array"] = 17] = "Array"; + SymbolKind[SymbolKind["Object"] = 18] = "Object"; + SymbolKind[SymbolKind["Key"] = 19] = "Key"; + SymbolKind[SymbolKind["Null"] = 20] = "Null"; + SymbolKind[SymbolKind["EnumMember"] = 21] = "EnumMember"; + SymbolKind[SymbolKind["Struct"] = 22] = "Struct"; + SymbolKind[SymbolKind["Event"] = 23] = "Event"; + SymbolKind[SymbolKind["Operator"] = 24] = "Operator"; + SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter"; +})(SymbolKind || (SymbolKind = {})); +var SymbolTag; +(function (SymbolTag) { + SymbolTag[SymbolTag["Deprecated"] = 1] = "Deprecated"; +})(SymbolTag || (SymbolTag = {})); +/** + * The kind of animation in which the editor's cursor should be rendered. + */ +var TextEditorCursorBlinkingStyle; +(function (TextEditorCursorBlinkingStyle) { + /** + * Hidden + */ + TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Hidden"] = 0] = "Hidden"; + /** + * Blinking + */ + TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Blink"] = 1] = "Blink"; + /** + * Blinking with smooth fading + */ + TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Smooth"] = 2] = "Smooth"; + /** + * Blinking with prolonged filled state and smooth fading + */ + TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Phase"] = 3] = "Phase"; + /** + * Expand collapse animation on the y axis + */ + TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Expand"] = 4] = "Expand"; + /** + * No-Blinking + */ + TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Solid"] = 5] = "Solid"; +})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {})); +/** + * The style in which the editor's cursor should be rendered. + */ +var TextEditorCursorStyle; +(function (TextEditorCursorStyle) { + /** + * As a vertical line (sitting between two characters). + */ + TextEditorCursorStyle[TextEditorCursorStyle["Line"] = 1] = "Line"; + /** + * As a block (sitting on top of a character). + */ + TextEditorCursorStyle[TextEditorCursorStyle["Block"] = 2] = "Block"; + /** + * As a horizontal line (sitting under a character). + */ + TextEditorCursorStyle[TextEditorCursorStyle["Underline"] = 3] = "Underline"; + /** + * As a thin vertical line (sitting between two characters). + */ + TextEditorCursorStyle[TextEditorCursorStyle["LineThin"] = 4] = "LineThin"; + /** + * As an outlined block (sitting on top of a character). + */ + TextEditorCursorStyle[TextEditorCursorStyle["BlockOutline"] = 5] = "BlockOutline"; + /** + * As a thin horizontal line (sitting under a character). + */ + TextEditorCursorStyle[TextEditorCursorStyle["UnderlineThin"] = 6] = "UnderlineThin"; +})(TextEditorCursorStyle || (TextEditorCursorStyle = {})); +/** + * Describes the behavior of decorations when typing/editing near their edges. + * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior` + */ +var TrackedRangeStickiness; +(function (TrackedRangeStickiness) { + TrackedRangeStickiness[TrackedRangeStickiness["AlwaysGrowsWhenTypingAtEdges"] = 0] = "AlwaysGrowsWhenTypingAtEdges"; + TrackedRangeStickiness[TrackedRangeStickiness["NeverGrowsWhenTypingAtEdges"] = 1] = "NeverGrowsWhenTypingAtEdges"; + TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingBefore"] = 2] = "GrowsOnlyWhenTypingBefore"; + TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingAfter"] = 3] = "GrowsOnlyWhenTypingAfter"; +})(TrackedRangeStickiness || (TrackedRangeStickiness = {})); +/** + * Describes how to indent wrapped lines. + */ +var WrappingIndent; +(function (WrappingIndent) { + /** + * No indentation => wrapped lines begin at column 1. + */ + WrappingIndent[WrappingIndent["None"] = 0] = "None"; + /** + * Same => wrapped lines get the same indentation as the parent. + */ + WrappingIndent[WrappingIndent["Same"] = 1] = "Same"; + /** + * Indent => wrapped lines get +1 indentation toward the parent. + */ + WrappingIndent[WrappingIndent["Indent"] = 2] = "Indent"; + /** + * DeepIndent => wrapped lines get +2 indentation toward the parent. + */ + WrappingIndent[WrappingIndent["DeepIndent"] = 3] = "DeepIndent"; +})(WrappingIndent || (WrappingIndent = {})); + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/editor/common/tokenizationRegistry.js": +/*!*********************************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/common/tokenizationRegistry.js ***! + \*********************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ TokenizationRegistry: () => (/* binding */ TokenizationRegistry) +/* harmony export */ }); +/* harmony import */ var _base_common_event_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../base/common/event.js */ "./node_modules/monaco-editor/esm/vs/base/common/event.js"); +/* harmony import */ var _base_common_lifecycle_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../base/common/lifecycle.js */ "./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +class TokenizationRegistry { + constructor() { + this._tokenizationSupports = new Map(); + this._factories = new Map(); + this._onDidChange = new _base_common_event_js__WEBPACK_IMPORTED_MODULE_0__.Emitter(); + this.onDidChange = this._onDidChange.event; + this._colorMap = null; + } + handleChange(languageIds) { + this._onDidChange.fire({ + changedLanguages: languageIds, + changedColorMap: false + }); + } + register(languageId, support) { + this._tokenizationSupports.set(languageId, support); + this.handleChange([languageId]); + return (0,_base_common_lifecycle_js__WEBPACK_IMPORTED_MODULE_1__.toDisposable)(() => { + if (this._tokenizationSupports.get(languageId) !== support) { + return; + } + this._tokenizationSupports.delete(languageId); + this.handleChange([languageId]); + }); + } + get(languageId) { + return this._tokenizationSupports.get(languageId) || null; + } + registerFactory(languageId, factory) { + var _a; + (_a = this._factories.get(languageId)) === null || _a === void 0 ? void 0 : _a.dispose(); + const myData = new TokenizationSupportFactoryData(this, languageId, factory); + this._factories.set(languageId, myData); + return (0,_base_common_lifecycle_js__WEBPACK_IMPORTED_MODULE_1__.toDisposable)(() => { + const v = this._factories.get(languageId); + if (!v || v !== myData) { + return; + } + this._factories.delete(languageId); + v.dispose(); + }); + } + async getOrCreate(languageId) { + // check first if the support is already set + const tokenizationSupport = this.get(languageId); + if (tokenizationSupport) { + return tokenizationSupport; + } + const factory = this._factories.get(languageId); + if (!factory || factory.isResolved) { + // no factory or factory.resolve already finished + return null; + } + await factory.resolve(); + return this.get(languageId); + } + isResolved(languageId) { + const tokenizationSupport = this.get(languageId); + if (tokenizationSupport) { + return true; + } + const factory = this._factories.get(languageId); + if (!factory || factory.isResolved) { + return true; + } + return false; + } + setColorMap(colorMap) { + this._colorMap = colorMap; + this._onDidChange.fire({ + changedLanguages: Array.from(this._tokenizationSupports.keys()), + changedColorMap: true + }); + } + getColorMap() { + return this._colorMap; + } + getDefaultBackground() { + if (this._colorMap && this._colorMap.length > 2 /* ColorId.DefaultBackground */) { + return this._colorMap[2 /* ColorId.DefaultBackground */]; + } + return null; + } +} +class TokenizationSupportFactoryData extends _base_common_lifecycle_js__WEBPACK_IMPORTED_MODULE_1__.Disposable { + get isResolved() { + return this._isResolved; + } + constructor(_registry, _languageId, _factory) { + super(); + this._registry = _registry; + this._languageId = _languageId; + this._factory = _factory; + this._isDisposed = false; + this._resolvePromise = null; + this._isResolved = false; + } + dispose() { + this._isDisposed = true; + super.dispose(); + } + async resolve() { + if (!this._resolvePromise) { + this._resolvePromise = this._create(); + } + return this._resolvePromise; + } + async _create() { + const value = await this._factory.tokenizationSupport; + this._isResolved = true; + if (value && !this._isDisposed) { + this._register(this._registry.register(this._languageId, value)); + } + } +} + + +/***/ }), + +/***/ "./node_modules/monaco-editor/esm/vs/nls.js": +/*!**************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/nls.js ***! + \**************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ create: () => (/* binding */ create), +/* harmony export */ getConfiguredDefaultLocale: () => (/* binding */ getConfiguredDefaultLocale), +/* harmony export */ load: () => (/* binding */ load), +/* harmony export */ localize: () => (/* binding */ localize), +/* harmony export */ localize2: () => (/* binding */ localize2), +/* harmony export */ setPseudoTranslation: () => (/* binding */ setPseudoTranslation) +/* harmony export */ }); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +let isPseudo = (typeof document !== 'undefined' && document.location && document.location.hash.indexOf('pseudo=true') >= 0); +const DEFAULT_TAG = 'i-default'; +function _format(message, args) { + let result; + if (args.length === 0) { + result = message; + } + else { + result = message.replace(/\{(\d+)\}/g, (match, rest) => { + const index = rest[0]; + const arg = args[index]; + let result = match; + if (typeof arg === 'string') { + result = arg; + } + else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) { + result = String(arg); + } + return result; + }); + } + if (isPseudo) { + // FF3B and FF3D is the Unicode zenkaku representation for [ and ] + result = '\uFF3B' + result.replace(/[aouei]/g, '$&$&') + '\uFF3D'; + } + return result; +} +function findLanguageForModule(config, name) { + let result = config[name]; + if (result) { + return result; + } + result = config['*']; + if (result) { + return result; + } + return null; +} +function endWithSlash(path) { + if (path.charAt(path.length - 1) === '/') { + return path; + } + return path + '/'; +} +async function getMessagesFromTranslationsService(translationServiceUrl, language, name) { + const url = endWithSlash(translationServiceUrl) + endWithSlash(language) + 'vscode/' + endWithSlash(name); + const res = await fetch(url); + if (res.ok) { + const messages = await res.json(); + return messages; + } + throw new Error(`${res.status} - ${res.statusText}`); +} +function createScopedLocalize(scope) { + return function (idx, defaultValue) { + const restArgs = Array.prototype.slice.call(arguments, 2); + return _format(scope[idx], restArgs); + }; +} +function createScopedLocalize2(scope) { + return (idx, defaultValue, ...args) => ({ + value: _format(scope[idx], args), + original: _format(defaultValue, args) + }); +} +/** + * @skipMangle + */ +function localize(data, message, ...args) { + return _format(message, args); +} +/** + * @skipMangle + */ +function localize2(data, message, ...args) { + const original = _format(message, args); + return { + value: original, + original + }; +} +/** + * @skipMangle + */ +function getConfiguredDefaultLocale(_) { + // This returns undefined because this implementation isn't used and is overwritten by the loader + // when loaded. + return undefined; +} +/** + * @skipMangle + */ +function setPseudoTranslation(value) { + isPseudo = value; +} +/** + * Invoked in a built product at run-time + * @skipMangle + */ +function create(key, data) { + var _a; + return { + localize: createScopedLocalize(data[key]), + localize2: createScopedLocalize2(data[key]), + getConfiguredDefaultLocale: (_a = data.getConfiguredDefaultLocale) !== null && _a !== void 0 ? _a : ((_) => undefined) + }; +} +/** + * Invoked by the loader at run-time + * @skipMangle + */ +function load(name, req, load, config) { + var _a; + const pluginConfig = (_a = config['vs/nls']) !== null && _a !== void 0 ? _a : {}; + if (!name || name.length === 0) { + // TODO: We need to give back the mangled names here + return load({ + localize: localize, + localize2: localize2, + getConfiguredDefaultLocale: () => { var _a; return (_a = pluginConfig.availableLanguages) === null || _a === void 0 ? void 0 : _a['*']; } + }); + } + const language = pluginConfig.availableLanguages ? findLanguageForModule(pluginConfig.availableLanguages, name) : null; + const useDefaultLanguage = language === null || language === DEFAULT_TAG; + let suffix = '.nls'; + if (!useDefaultLanguage) { + suffix = suffix + '.' + language; + } + const messagesLoaded = (messages) => { + if (Array.isArray(messages)) { + messages.localize = createScopedLocalize(messages); + messages.localize2 = createScopedLocalize2(messages); + } + else { + messages.localize = createScopedLocalize(messages[name]); + messages.localize2 = createScopedLocalize2(messages[name]); + } + messages.getConfiguredDefaultLocale = () => { var _a; return (_a = pluginConfig.availableLanguages) === null || _a === void 0 ? void 0 : _a['*']; }; + load(messages); + }; + if (typeof pluginConfig.loadBundle === 'function') { + pluginConfig.loadBundle(name, language, (err, messages) => { + // We have an error. Load the English default strings to not fail + if (err) { + req([name + '.nls'], messagesLoaded); + } + else { + messagesLoaded(messages); + } + }); + } + else if (pluginConfig.translationServiceUrl && !useDefaultLanguage) { + (async () => { + var _a; + try { + const messages = await getMessagesFromTranslationsService(pluginConfig.translationServiceUrl, language, name); + return messagesLoaded(messages); + } + catch (err) { + // Language is already as generic as it gets, so require default messages + if (!language.includes('-')) { + console.error(err); + return req([name + '.nls'], messagesLoaded); + } + try { + // Since there is a dash, the language configured is a specific sub-language of the same generic language. + // Since we were unable to load the specific language, try to load the generic language. Ex. we failed to find a + // Swiss German (de-CH), so try to load the generic German (de) messages instead. + const genericLanguage = language.split('-')[0]; + const messages = await getMessagesFromTranslationsService(pluginConfig.translationServiceUrl, genericLanguage, name); + // We got some messages, so we configure the configuration to use the generic language for this session. + (_a = pluginConfig.availableLanguages) !== null && _a !== void 0 ? _a : (pluginConfig.availableLanguages = {}); + pluginConfig.availableLanguages['*'] = genericLanguage; + return messagesLoaded(messages); + } + catch (err) { + console.error(err); + return req([name + '.nls'], messagesLoaded); + } + } + })(); + } + else { + req([name + suffix], messagesLoaded, (err) => { + if (suffix === '.nls') { + console.error('Failed trying to load default language strings', err); + return; + } + console.error(`Failed to load message bundle for language ${language}. Falling back to the default language:`, err); + req([name + '.nls'], messagesLoaded); + }); + } +} + + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/define property getters */ +/******/ (() => { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = (exports, definition) => { +/******/ for(var key in definition) { +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ })(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ (() => { +/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) +/******/ })(); +/******/ +/******/ /* webpack/runtime/make namespace object */ +/******/ (() => { +/******/ // define __esModule on exports +/******/ __webpack_require__.r = (exports) => { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ })(); +/******/ +/************************************************************************/ +var __webpack_exports__ = {}; +// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk. +(() => { +/*!*******************************************************************!*\ + !*** ./node_modules/monaco-editor/esm/vs/editor/editor.worker.js ***! + \*******************************************************************/ +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ initialize: () => (/* binding */ initialize) +/* harmony export */ }); +/* harmony import */ var _base_common_worker_simpleWorker_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../base/common/worker/simpleWorker.js */ "./node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.js"); +/* harmony import */ var _common_services_editorSimpleWorker_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./common/services/editorSimpleWorker.js */ "./node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js"); +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +let initialized = false; +function initialize(foreignModule) { + if (initialized) { + return; + } + initialized = true; + const simpleWorker = new _base_common_worker_simpleWorker_js__WEBPACK_IMPORTED_MODULE_0__.SimpleWorkerServer((msg) => { + globalThis.postMessage(msg); + }, (host) => new _common_services_editorSimpleWorker_js__WEBPACK_IMPORTED_MODULE_1__.EditorSimpleWorker(host, foreignModule)); + globalThis.onmessage = (e) => { + simpleWorker.onmessage(e.data); + }; +} +globalThis.onmessage = (e) => { + // Ignore first message in this case and initialize if not yet initialized + if (!initialized) { + initialize(null); + } +}; + +})(); + +/******/ })() +; +//# sourceMappingURL=editor.worker.js.map \ No newline at end of file diff --git a/dist/editor.worker.js.map b/dist/editor.worker.js.map new file mode 100644 index 00000000..4a95c72c --- /dev/null +++ b/dist/editor.worker.js.map @@ -0,0 +1 @@ +{"version":3,"file":"editor.worker.js","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,SAAS;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACO;AACP,oBAAoB,gBAAgB;AACpC;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,QAAQ;AACnC;AACA;AACA;AACA;AACA,2BAA2B,QAAQ;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,qCAAqC,eAAe;AACpD;AACA;AACA,oBAAoB,oBAAoB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sCAAsC;AAChC;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACA;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,kCAAkC;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,iCAAiC;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,mBAAmB,cAAc;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;ACrd9D;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP,4BAA4B,QAAQ;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;AC9KA;AACA;AACA;AACA;AACoE;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA,uDAAuD,QAAQ;AAC/D;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,QAAQ,6DAAiB,KAAK,0DAAkB;AAChD;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AClDA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACvCA;AACA;AACA;AACA;AAC4C;AAC5C;AACA;AACA,aAAa,YAAY;AACzB,CAAC;AACM;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,4CAAK;AACtC,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL,CAAC,8CAA8C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,8CAAO;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC5GsC;AACtC;AACA;AACA,QAAQ,mDAAQ;AAChB;AACA;AACA,+BAA+B,IAAI,iCAAiC,cAAc;AAClF;AACA;AACA;AACA;AACA,aAAa;AACb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kBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,aAAa,IAAI,aAAa,IAAI,aAAa;AACjF;AACA;AACA;AACA;AACA;AACA,+BAA+B,aAAa,IAAI,aAAa,IAAI,aAAa,IAAI,2BAA2B;AAC7G;AACA;AACA;AACA;AACA,kCAAkC,aAAa,IAAI,gCAAgC,KAAK,gCAAgC;AACxH;AACA;AACA;AACA;AACA;AACA,+BAA+B,aAAa,IAAI,gCAAgC,KAAK,gCAAgC,KAAK,wBAAwB;AAClJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,6BAA6B,EAAE,6BAA6B,EAAE,6BAA6B;AACtH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,6BAA6B,EAAE,6BAA6B,EAAE,6BAA6B,EAAE,+CAA+C;AACvK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,sCAAsC;AAC/C,KAAK,6CAA6C;AAClD,CAAC,sBAAsB;;;;;;;;;;;;;;;;;;;AC7cvB;AACA;AACA;AACA;AAC6C;AACL;AACjC;AACP;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,SAAS;AACtD;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,YAAY;AACpC;AACA;AACA;AACA;AACA,wBAAwB,YAAY;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,sDAAU;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,SAAS;AAC5D,4BAA4B,oDAAU;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sDAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sDAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sDAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,sDAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA,wDAAwD;AACxD;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,sDAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E;AAC7E;AACA;AACA;AACA,4DAA4D;AAC5D;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,4CAA4C;AACjF;AACA;AACA;AACA;AACA;AACA,sDAAsD,gCAAgC;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,sDAAU;AACtC;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,gCAAgC;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,oBAAoB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,QAAQ;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,SAAS;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,iBAAiB;AACrD,wCAAwC,iBAAiB;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,YAAY;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,sDAAU;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACl4BA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA,gBAAgB,gBAAgB;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,mDAAmD;AACvE;AACO;AACP;AACA;AACA;AACA;AACO;AACP;AACA,8CAA8C,KAAK;AACnD;AACA;AACA;AACA;AACA;AACO;AACP;AACA,2CAA2C,KAAK;AAChD;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrJgD;AACW;AACoC;AAClD;AACF;AAC3C;AACA;AACA;AACA;AACA,wDAAwD;AACxD;AACA;AACA;AACA;AACA;AACO;AACP;AACA,uBAAuB,qDAAU;AACjC;AACA;AACA,oBAAoB,uCAAuC;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS,6BAA6B;AACvH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,iEAAkB;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,aAAa;AACb;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,sBAAsB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,aAAa;AAChC;AACA;AACA;AACA;AACA;AACA,qCAAqC,2FAA2F;AAChI;AACA;AACA;AACA;AACA,mBAAmB,aAAa;AAChC;AACA;AACA;AACA;AACA;AACA,qCAAqC,2FAA2F;AAChI;AACA;AACA;AACA;AACA,qDAAqD,kBAAkB;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,uBAAuB;AAC/B;AACA;AACA;AACA;AACA;AACA,wBAAwB,0DAAe;AACvC;AACA;AACA;AACA;AACA,eAAe,2DAAY;AAC3B;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,0DAAe;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sBAAsB;AAChB;AACP;AACA;AACA;AACA;AACA;AACA,uBAAuB,KAAK,GAAG,yBAAyB;AACxD;AACA;AACA;AACA,8BAA8B,oDAAS;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,UAAU,6CAA6C,eAAe,6CAA6C,SAAS;AACzJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sBAAsB;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E;AAC3E,mEAAmE,KAAK,GAAG;AAC3E;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,QAAQ,wEAAwE;AAC1I,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,sBAAsB;AACvD,uBAAuB,qDAAU;AACjC;AACA;AACA;AACA,uBAAuB,qDAAU;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,2DAAY,SAAS,+EAA+E,kCAAkC;AACjK,uCAAuC,0DAAe;AACtD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,sBAAsB;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+GAA+G,yDAAiB;AAChI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,+BAA+B,sDAAU;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,cAAc;AACxE;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA,IAAI;AACJ;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,2DAAY,CAAC,wEAAwB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,IAAI;AACJ;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,kCAAkC,qDAAU;AAC5C;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AChqCA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;AC7BA;AACA;AACA;AACA;AACwC;AACxC;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,iEAAiE;AACjE;AACA;AACA;AACA;AACO;AACP;AACA,uCAAuC,YAAY;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,wDAAuB;AACvC;AACA;AACA,wBAAwB,uDAAsB;AAC9C;AACA,oCAAoC,yDAAwB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,uDAAsB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,mBAAmB;AAC3C;AACA;AACA,yBAAyB,oBAAoB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,QAAQ;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D;;;;;;;;;;;;;;;ACjQ7D;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,QAAQ;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,YAAY;AACpC;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,sBAAsB,oBAAoB;AACtE;AACA;AACA,CAAC,4BAA4B;;;;;;;;;;;;;;;;;;;;ACnI7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACO;AACP,gBAAgB,mCAAmC;AACnD;AACA;AACA,gBAAgB,kCAAkC;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oFAAoF,sBAAsB;AAC1G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,SAAS,mBAAmB,YAAY;AACtH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACM;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,oCAAoC;AAC9B;AACP;AACA;AACA;;;;;;;;;;;;;;;ACnXA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpC2D;AAClB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACO;AACP;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,wBAAwB,6BAA6B;AACrD;AACO;AACP;AACA;AACO;AACP,QAAQ,kDAAQ;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,kBAAkB;AACvE;AACO;AACP;AACA;AACA;AACA;AACA;AACA,oDAAoD,kBAAkB;AACtE;AACA;AACA;AACO;AACP;AACA,iBAAiB,wEAAwB;AACzC;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,8BAA8B;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,8BAA8B;AAC5D;AACA,mBAAmB,qBAAqB;AACxC;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,eAAe;AACjD;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACtWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;AC3HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;AC7hBA;AACA;AACA;AACA;AACuE;AAChE;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,uDAAY;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,QAAQ,4DAAiB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,mDAAQ;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,SAAS,mDAAQ;AACjB;AACA;AACA,QAAQ,mDAAQ;AAChB;AACA;AACA;AACA,wBAAwB,mDAAQ,sBAAsB,mDAAQ;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,gBAAgB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,oBAAoB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;AClLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACwC;AACxC,6BAA6B;AAC7B,6BAA6B;AAC7B,6BAA6B;AAC7B,8BAA8B;AAC9B,qBAAqB;AACrB,+BAA+B;AAC/B,gCAAgC;AAChC,uBAAuB;AACvB,+BAA+B;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,KAAK,IAAI,MAAM,EAAE,YAAY,UAAU,SAAS;AAC1E,kCAAkC,cAAc;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,iDAAgB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,UAAU;AACzD;AACA;AACA;AACA;AACA;AACA,8BAA8B,UAAU,EAAE,6BAA6B;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,sBAAsB,EAAE,qBAAqB;AACxD;AACA;AACA;AACA,wCAAwC,IAAI,EAAE,KAAK,OAAO,IAAI,EAAE,IAAI,EAAE,KAAK;AAC3E;AACO;AACP;AACA;AACA;AACA;AACA;AACA,8CAA8C,SAAS;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,4CAAW;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,4CAAW,KAAK,eAAe,MAAM,4CAAW;AACvE;AACA;AACA;AACA;AACA;AACA,8BAA8B,eAAe;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,UAAU,IAAI,oBAAoB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,oBAAoB,IAAI,aAAa;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,eAAe,IAAI,aAAa;AAC/C,eAAe,eAAe,EAAE,aAAa;AAC7C,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,UAAU,IAAI,iBAAiB;AACzE;AACA;AACA;AACA,4CAA4C,UAAU,IAAI,oBAAoB;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,KAAK;AAC1C;AACA,+BAA+B,OAAO,IAAI,KAAK,OAAO,OAAO,EAAE,KAAK;AACpE,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,IAAI;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,yBAAyB;AACvD;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA;AACA,iDAAiD;AACjD;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,cAAc;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,IAAI,EAAE,6BAA6B;AACzD;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,sBAAsB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,aAAa;AAC1C;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,aAAa;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,YAAY;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,YAAY;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,YAAY;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,cAAc;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,4CAAW;AACnC;AACA;AACA;AACA;AACA,iBAAiB,4CAAW;AAC5B,CAAC;AACM;AACP;AACA;AACA;AACA;AACA,8CAA8C,8BAA8B;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,KAAK,GAAG,aAAa;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,aAAa;AACpC;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,KAAK;AACrC,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,IAAI;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,cAAc;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,IAAI,EAAE,kCAAkC;AAC1D,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,QAAQ;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,QAAQ;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,QAAQ;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,QAAQ;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACh3CP;AACA;AACA;AACA;AACA;AACoC;AAC7B;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,+DAA8B;AAC3D;AACA;AACA;AACA;AACA,IAAI,6CAAY,GAAG,+CAA+C,OAAO,IAAI;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACP;AACA;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,sDAAsD,SAAS;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,sCAAsC,+BAA+B;AACrE;AACA;AACA;AACA,CAAC;AACM;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACjKP;AACA;AACA;AACA;AACuD;AACvD;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,iCAAiC;AAC1D,qBAAqB,6BAA6B;AAClD,oBAAoB,4BAA4B;AAChD,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA,yBAAyB,0BAA0B;AACnD,qBAAqB,sBAAsB;AAC3C,oBAAoB,qBAAqB;AACzC,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,OAAO,mDAAS,aAAa,qDAAW,wBAAwB;AACzF,qBAAqB,kBAAkB,gCAAgC;AACvE;AACA,oBAAoB,YAAY;AAChC,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACO;AACP;AACA;AACA;AACA;AACO;;;;;;;;;;;;;;;ACzDP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvBA;AACA;AACA;AACA;AACA;AAC+C;AACd;AAC1B;AACP;AACA;AACA;AACA;AACA;AACA,wBAAwB,MAAM;AAC9B;AACA;AACA,8BAA8B,GAAG;AACjC;AACA,iCAAiC,EAAE;AACnC;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,kCAAkC;AAClC,kCAAkC;AAClC,mCAAmC;AACnC;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACO;AACP,+BAA+B,EAAE;AACjC;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,mCAAmC,EAAE;AACrC;AACO;AACP;AACA;AACO,yDAAyD;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP,sCAAsC,SAAS;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,wBAAwB,SAAS;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,6BAA6B,QAAQ;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,WAAW,gCAAgC;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP,WAAW,gCAAgC;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACO;AACP;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO,mDAAmD;AAC1D;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,sBAAsB;AACtB;AACA;AACA,kBAAkB,uBAAuB,iBAAiB;AAC1D;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,0CAAI;AACrD;AACA;AACA,wBAAwB,qxmBAAqxmB;AAC7ymB,CAAC;AACD,gCAAgC,wDAAiB;AACjD;AACA;AACA,wBAAwB,gBAAgB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,mCAAmC,0CAAI;AAChC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/yBA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA,6DAA6D,KAAK;AAClE;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA,oBAAoB,SAAS;AAC7B;AACA;AACA;AACO;AACP;AACA;AACA,0EAA0E,WAAW;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACtHA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACmC;AACO;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,0BAA0B,cAAc,YAAY,SAAS,aAAa,UAAU,gBAAgB,aAAa,EAAE;AAC5K;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,YAAY;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,2CAA2C;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,mDAAS;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,mDAAS;AACrB,+BAA+B,2CAAW;AAC1C;AACA;AACA,sBAAsB,2CAAW;AACjC;AACA,0BAA0B,eAAe;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mDAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,2BAA2B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,mBAAmB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,qBAAqB,cAAc,EAAE,SAAS;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,mDAAS;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,2CAA2C;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,+BAA+B,GAAG,eAAe,GAAG;AAC/E;AACA;AACA;AACA;AACA;AACA,0BAA0B,+BAA+B,GAAG,eAAe,GAAG;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;AC1lBA;AACA;AACA;AACA;AAC8D;AACxB;AACO;AACK;AACX;AACE;AACzC;AACA;AACO;AACP,SAAS,+CAAK;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,4BAA4B,8CAAO;AACnC;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,2BAA2B,0EAA8B;AACzD;AACA,wEAAwE,0EAA8B;AACtG,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iCAAiC,qDAAU;AAClD;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,iEAAiE,WAAW;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE;AACA;AACA;AACA,wDAAwD,UAAU;AAClE;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,8DAAiB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,2DAA0B;AAC3E;AACA;AACA;AACA,sCAAsC,2DAA0B;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,WAAW;AAC5D;AACA;AACA;AACA,gDAAgD,UAAU;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,8DAAiB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,8DAAiB;AACzC,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;;;;;;;;;;;;;;;;;ACxbA;AACA;AACA;AACA;AACuD;AACvD;AACA;AACA;AACO;AACP;AACA,6BAA6B,6DAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,6DAAO;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;ACvDA;AACA;AACA;AACA;AACoE;AACrB;AACZ;AAC4F;AAC/H;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,uBAAuB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,sEAAkB,oBAAoB,iBAAiB,yCAAyC,uBAAuB;AAC7I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,qBAAqB,GAAG,4BAA4B;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,4CAAK;AACxB;AACA;AACA,mBAAmB,4CAAK;AACxB;AACA;AACA;AACA,oDAAoD,0CAA0C;AAC9F;AACA;AACA;AACA;AACA;AACA,oDAAoD,0CAA0C;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,wDAAW;AAC9B;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,0FAA8B;AAChE,kCAAkC;AAClC,yCAAyC,iFAAqB;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,8EAAkB;AAC3D;AACA;AACA;AACA,yCAAyC,8EAAkB;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,0FAA8B;AAChE,kCAAkC;AAClC,yCAAyC,iFAAqB;AAC9D;AACA;AACA;AACA;AACA;AACA,wCAAwC,8BAA8B;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACnSA;AACA;AACA;AACA;AACoE;AACpE;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,sEAAkB,mBAAmB,gBAAgB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,WAAW,IAAI,kBAAkB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,sEAAkB,4BAA4B,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,sEAAkB,4BAA4B,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,uBAAuB;AACxD;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC9LA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC3IA;AACA;AACA;AACA;AACyC;AACzC;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,kDAAQ;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,kDAAQ;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC/YA;AACA;AACA;AACA;AACyC;AACN;AACnC;AACA;AACA;AACA;AACO,wBAAwB,4CAAK;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,kDAAQ;AAC3B;AACA;AACA;AACA;AACA;AACA,mBAAmB,kDAAQ;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC7IA;AACA;AACA;AACA;AAC+D;AACxD,sCAAsC,wEAAmB;AAChE;AACA;AACA,qDAAqD,SAAS;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACO;;;;;;;;;;;;;;;;;;;;ACxBP;AACA;AACA;AACA;AAC4D;AACI;AACzD,gDAAgD,EAAE,IAAI;AAC7D;AACA;AACA;AACA;AACA;AACA,wDAAwD,IAAI,MAAM;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,kEAAU;AACrC;AACA;AACA;AACA;AACA,CAAC;AACM;AACP;AACA;AACA;AACA,iBAAiB,8DAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;AC3HA;AACA;AACA;AACA;AACuE;AACG;AACf;AACpD;AACP;AACA,yDAAyD,6DAAW,wBAAwB,6DAAW;AACvG;AACA;AACA,yDAAyD,6DAAW,wBAAwB,6DAAW;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,QAAQ,uEAAe;AACvB;AACA,SAAS;AACT;AACA;AACA;AACA,oCAAoC,6DAAW,2CAA2C,6DAAW;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,gBAAgB,MAAM,eAAe;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,kBAAkB,cAAc,MAAM,aAAa;AACnD;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,sBAAsB,sEAAkB;AACxC;AACA;AACA,yCAAyC,eAAe;AACxD;AACA;AACA;AACA,gCAAgC;AAChC;AACA,sBAAsB;AACtB;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACrHA;AACA;AACA;AACA;AAC2D;AAC6B;AAClD;AACtC;AACA;AACA;AACA;AACO;AACP,4CAA4C,8DAAe;AAC3D;AACA,mBAAmB,kEAAmB;AACtC;AACA;AACA;AACA;AACA,+BAA+B,8CAAO;AACtC,+BAA+B,8CAAO;AACtC,4BAA4B,8CAAO;AACnC;AACA,yBAAyB,uBAAuB;AAChD,6BAA6B,uBAAuB;AACpD;AACA,2BAA2B,kEAAmB;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,2DAAY,KAAK,6DAAW,iCAAiC,6DAAW;AACxG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,kEAAmB;AACtC;AACA;;;;;;;;;;;;;;;;;ACjGA;AACA;AACA;AACA;AAC2D;AAC6B;AACxF;AACA;AACA;AACO;AACP,kCAAkC,8DAAe;AACjD;AACA;AACA;AACA,mBAAmB,kEAAmB;AACtC;AACA,2BAA2B;AAC3B,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,kEAAmB;AAC1C;AACA,2CAA2C,QAAQ;AACnD;AACA;AACA,iCAAiC,iBAAiB;AAClD;AACA;AACA,6EAA6E;AAC7E,kFAAkF;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,2DAAY,KAAK,6DAAW,+BAA+B,6DAAW;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,kEAAmB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;AC9JA;AACA;AACA;AACA;AAC6D;AACP;AACkD;AACZ;AACpC;AACU;AACV;AACa;AACb;AACgB;AACjE;AACP,UAAU,yBAAyB;AACnC;AACA;AACA;AACA;AACA;AACA,IAAI,gEAAQ;AACZ;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,wDAAiB;AACvC;AACA;AACA,sBAAsB,wDAAiB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,8DAAgB;AAC3C;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,oCAAoC,uDAAM;AAC1C;AACA,sDAAsD,gDAAgD;AACtG,2BAA2B,2BAA2B,GAAG,+BAA+B,GAAG,+BAA+B;AAC1H,2CAA2C,WAAW,yDAAS,YAAY;AAC3E;AACA;AACA;AACA,iBAAiB,iEAAS,kCAAkC,oEAAgB;AAC5E;AACA;AACA,sDAAsD,gDAAgD;AACtG,2BAA2B,2BAA2B,GAAG,+BAA+B,GAAG,+BAA+B;AAC1H,6CAA6C,yDAAS;AACtD;AACA,gDAAgD,OAAO;AACvD;AACA;AACA;AACA;AACA,4DAA4D,yDAAS;AACrE,4DAA4D,yDAAS;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,oEAAY,CAAC,iEAAS,kCAAkC,oEAAgB;AAClG,4BAA4B,4DAAY;AACxC,4BAA4B,4DAAY;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,8DAAgB;AAC3C;AACA;AACA;AACA;AACA,eAAe,iEAAS,kCAAkC,oEAAgB;AAC1E,kCAAkC,uEAAe;AACjD,oBAAoB,kBAAkB;AACtC;AACA;AACA,uCAAuC,8EAAkB;AACzD;AACA;AACA,sCAAsC,8EAAkB;AACxD;AACA;AACA,8BAA8B,0BAA0B;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,yDAAS;AAC9C,qCAAqC,yDAAS;AAC9C;AACA;AACA,iCAAiC,6BAA6B;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,yDAAS;AAC9C,qCAAqC,yDAAS;AAC9C;AACA;AACA,2BAA2B,8DAAgB,KAAK,yDAAS,0GAA0G,yDAAS;AAC5K;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,iFAAkB;AACxD,qDAAqD,8EAAsB,cAAc,6DAAW,oBAAoB,8EAAsB,cAAc,6DAAW;AACvK;AACA,qBAAqB,sEAAY;AACjC;AACA;AACA,iBAAiB,kDAAO;AACxB;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C,iBAAiB,kDAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,iEAAS,kCAAkC,oEAAgB;AAC1E;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,uEAAe;AACjD;AACA;AACA,mBAAmB,8DAAgB,KAAK,yDAAS,YAAY,yDAAS;AACtE,4CAA4C,8EAAkB;AAC9D;AACA;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrPA;AACA;AACA;AACA;AAC4E;AACK;AAC7B;AACI;AACZ;AAC+C;AACL;AACd;AACb;AACkK;AAC9J;AACa;AACP;AACpB;AAC1C;AACP;AACA,6CAA6C,+FAAyB;AACtE,yCAAyC,iFAAkB;AAC3D;AACA;AACA,yCAAyC,8DAAM;AAC/C,uBAAuB,6DAAS;AAChC;AACA;AACA,uBAAuB,6DAAS;AAChC,oBAAoB,uEAAwB,KAAK,yDAAS,mCAAmC,yDAAS;AACtG,wBAAwB,2DAAY,KAAK,iDAAK,+DAA+D,iDAAK;AAClH;AACA;AACA;AACA,6DAA6D,yEAAe,gBAAgB,qEAAW;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,2DAAY;AAC1C,8BAA8B,2DAAY;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,yBAAyB,yFAAqB;AAC9C,yBAAyB,4GAAwC;AACjE;AACA;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA;AACA,6FAA6F,sEAAY,KAAK,6DAAW,kCAAkC,6DAAW;AACtK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,gEAAQ;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,gEAAQ;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,mBAAmB,6DAAS;AAC5B;AACA;AACA,sBAAsB,wEAAiB;AACvC;AACA,kFAAkF,sEAAY;AAC9F;AACA,uBAAuB,6DAAS;AAChC,SAAS;AACT;AACA;AACA;AACA,2BAA2B,+EAAsB;AACjD,2BAA2B,+EAAsB;AACjD;AACA;AACA;AACA;AACA,gBAAgB,yFAAqB;AACrC,gBAAgB,wGAAoC;AACpD,gBAAgB,sFAAkB;AAClC,gBAAgB,+GAA2C;AAC3D,4CAA4C,2DAAY;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA,oBAAoB,uEAAe;AACnC;AACA;AACA;AACA,yBAAyB,uEAAwB;AACjD;AACA,IAAI,gEAAQ;AACZ;AACA;AACA;AACA;AACA;AACA,eAAe,0EAAkB;AACjC;AACA;AACA;AACA,KAAK;AACL;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,yDAAS;AAC3C,kCAAkC,yDAAS;AAC3C,eAAe,uEAAwB;AACvC;;;;;;;;;;;;;;;;;;;;;;AC3NA;AACA;AACA;AACA;AACyE;AACjB;AACiB;AAClE;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,WAAW;AACvB;AACA;AACA;AACA,YAAY,gBAAgB;AAC5B;AACA,qBAAqB,kBAAkB,GAAG;AAC1C,oBAAoB,sBAAsB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,0BAA0B;AAC9C;AACA;AACA;AACA;AACA;AACA,wBAAwB,aAAa;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,sEAAY,KAAK,6DAAW,uEAAuE,6DAAW;AAC9J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;AACA,wBAAwB,YAAY;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,sEAAY,KAAK,6DAAW,uEAAuE,6DAAW;AAClJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,OAAO;AACnB,YAAY,eAAe;AAC3B;AACA,YAAY,eAAe;AAC3B,YAAY,6CAA6C;AACzD,YAAY,oEAAoE;AAChF;AACA,YAAY,oEAAoE;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,0BAA0B;AAC9C;AACA;AACA;AACA,mCAAmC,6DAAW;AAC9C,mCAAmC,6DAAW;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,qBAAqB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,sEAAY;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,sEAAY;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,6DAAW;AAC/C,oCAAoC,6DAAW;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA,2CAA2C,6DAAW;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA,2CAA2C,6DAAW;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,IAAI,4EAAoB;AACxB;AACA;AACA;AACA;AACA;AACA,6CAA6C,6DAAW;AACxD;AACA;AACA;AACA,6CAA6C,6DAAW;AACxD;AACA;AACA;AACA,+BAA+B,sEAAY,kDAAkD,oEAAU,iCAAiC,oEAAU;AAClJ;AACA;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;;;AC/WA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;ACjCA;AACA;AACA;AACA;AACuH;AAC/D;AACN;AACN;AACP;AAC9B;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,6DAAW;AACvC;AACA;AACA;AACA;AACA,2CAA2C,iCAAiC;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,iBAAiB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,UAAU;AACpC;AACA;AACA,gCAAgC,6DAAW;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,uDAAQ;AAC/B;AACA,kBAAkB,iFAAqB;AACvC,mBAAmB,uDAAQ;AAC3B;AACA;AACA,eAAe,iDAAK;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,6DAAW;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,8EAAkB;AAC9C,0BAA0B,+EAAmB;AAC7C,mBAAmB,6DAAW;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,kDAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACrLA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,sCAAsC;AACtF;AACA,4BAA4B,iBAAiB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,eAAe;AACvC;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;AC5DA;AACA;AACA;AACA;AAC4D;AACT;AACwB;AAChB;AAClB;AACqC;AAC7B;AACjD;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,yDAAS;AAC7C;AACA;AACA,oCAAoC,yDAAS;AAC7C;AACA;AACA;AACA;AACA,oCAAoC,yDAAS;AAC7C;AACA;AACA,oCAAoC,yDAAS;AAC7C;AACA,6BAA6B,sEAAwB,yGAAyG,0DAAY,KAAK,iDAAK,sGAAsG,iDAAK;AAC/R;AACA;AACA;AACA;AACA,iCAAiC,sEAAwB;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,gEAAQ;AAChB,mBAAmB,0EAAkB;AACrC;AACA;AACA;AACA,SAAS;AACT,mBAAmB,4DAAS;AAC5B;AACA;AACA;AACA,yBAAyB,8DAAO;AAChC;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,YAAY;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,SAAS;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,mBAAmB;AACxD;AACA;AACA;AACA,wCAAwC,iBAAiB;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iIAAiI,uBAAuB,GAAG,mBAAmB;AAC9K;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,SAAS;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,YAAY;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gJAAgJ;AAChJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,YAAY;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,SAAS;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,4EAA+B;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,2EAA8B;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACjdA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC1BA;AACA;AACA;AACA;AACuE;AAC2B;AAC3F;AACP,yBAAyB,gFAAuB;AAChD,0BAA0B,2GAAwB;AAClD;;;;;;;;;;;;;;;;;;ACTA;AACA;AACA;AACA;AACiD;AACjD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,uDAAuD,yDAAS,6DAA6D,yDAAS;AACtI;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,yDAAS,wDAAwD,yDAAS;AAC7H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,EAAE,yBAAyB,IAAI,0BAA0B;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,iBAAiB,EAAE,8BAA8B,IAAI,+BAA+B;AACpF;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrEwD;AACT;AACP;AACqD;AACrD;AACjC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,kDAAkD,6DAAO;AACzD,oDAAoD,6DAAO;AAC3D,uDAAuD,6DAAO;AAC9D,iDAAiD,6DAAO;AACxD,oDAAoD,6DAAO;AAC3D,iDAAiD,6DAAO;AACxD,kDAAkD,6DAAO;AACzD,qDAAqD,6DAAO;AAC5D,kDAAkD,6DAAO;AACzD,oDAAoD,6DAAO;AAC3D,kDAAkD,6DAAO;AACzD,qDAAqD,6DAAO;AAC5D,iDAAiD,6DAAO;AACxD,kDAAkD,6DAAO;AACzD,iDAAiD,6DAAO;AACxD,qDAAqD,6DAAO;AAC5D,iDAAiD,6DAAO;AACxD,uDAAuD,6DAAO;AAC9D,oDAAoD,6DAAO;AAC3D,oDAAoD,6DAAO;AAC3D,iDAAiD,6DAAO;AACxD,kDAAkD,6DAAO;AACzD,iDAAiD,6DAAO;AACxD,sDAAsD,6DAAO;AAC7D,wDAAwD,6DAAO;AAC/D,mDAAmD,6DAAO;AAC1D,0DAA0D,6DAAO;AACjE,iDAAiD,6DAAO;AACxD,kDAAkD,6DAAO;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,6DAAO;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,kDAAkD;AACnD;AACA,WAAW,4DAA4D;AACvE;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,kEAAkE;AAC5D;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,iDAAK;AACpB;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,CAAC,4DAA4D;AAC7D;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sDAAsD;AACvD;AACA;AACA;AACO;AACP;AACA,WAAW,oDAAG;AACd,WAAW,iDAAK;AAChB,YAAY,iDAAK,yCAAyC,iDAAK;AAC/D;AACA;AACA;AACA;AACO;AACP,iCAAiC,iDAAQ;AACzC,mCAAmC,iDAAQ;AAC3C,gCAAgC,iDAAQ;AACxC,oCAAoC,iDAAQ;AAC5C,sCAAsC,iDAAQ;AAC9C,+BAA+B,iDAAQ;AACvC,sCAAsC,iDAAQ;AAC9C,iCAAiC,iDAAQ;AACzC,gCAAgC,iDAAQ;AACxC,+BAA+B,iDAAQ;AACvC,oCAAoC,iDAAQ;AAC5C,qCAAqC,iDAAQ;AAC7C,+BAA+B,iDAAQ;AACvC,iCAAiC,iDAAQ;AACzC,iCAAiC,iDAAQ;AACzC,oCAAoC,iDAAQ;AAC5C,gCAAgC,iDAAQ;AACxC,kCAAkC,iDAAQ;AAC1C,kCAAkC,iDAAQ;AAC1C,oCAAoC,iDAAQ;AAC5C,kCAAkC,iDAAQ;AAC1C,mCAAmC,iDAAQ;AAC3C,kCAAkC,iDAAQ;AAC1C,kCAAkC,iDAAQ;AAC1C,yCAAyC,iDAAQ;AACjD,oCAAoC,iDAAQ;AAC5C;AACA;AACA;AACA;AACO;AACP,WAAW,iDAAQ,sBAAsB,GAAG,EAAE,EAAE;AAChD;AACA;AACA;AACA;AACO;AACP;AACA;AACA,wCAAwC,6DAAO;AAC/C,0CAA0C,6DAAO;AACjD,6CAA6C,6DAAO;AACpD,2CAA2C,6DAAO;AAClD,yCAAyC,6DAAO;AAChD,0CAA0C,6DAAO;AACjD,4CAA4C,6DAAO;AACnD,yCAAyC,6DAAO;AAChD,+CAA+C,6DAAO;AACtD,wCAAwC,6DAAO;AAC/C,8CAA8C,6DAAO;AACrD,6CAA6C,6DAAO;AACpD,6CAA6C,6DAAO;AACpD,6CAA6C,6DAAO;AACpD,2CAA2C,6DAAO;AAClD,2CAA2C,6DAAO;AAClD,4CAA4C,6DAAO;AACnD,0CAA0C,6DAAO;AACjD,2CAA2C,6DAAO;AAClD,wCAAwC,6DAAO;AAC/C,yCAAyC,6DAAO;AAChD,+CAA+C,6DAAO;AACtD,2CAA2C,6DAAO;AAClD,0CAA0C,6DAAO;AACjD,6CAA6C,6DAAO;AACpD,kDAAkD,6DAAO;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,6DAAO;AAC1B;AACA;AACA;AACA;AACA,CAAC,kCAAkC;AACnC;AACO;AACP;AACO;AACP;AACA,kBAAkB,wBAAwB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,uBAAuB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,0BAA0B;AACpB;AACP;AACA;AACA;AACA,CAAC,sCAAsC;AACvC;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iCAAiC,0EAAwB;;;;;;;;;;;;;;;;AC9WhE;AACA;AACA;AACA;AAC4D;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,wDAAK;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,wDAAK,KAAK,uDAAI;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4FAA4F,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE;AAChK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,EAAE,qDAAqD,EAAE,qDAAqD,EAAE;AAC3L;AACA;AACA;AACA,2EAA2E,EAAE,qDAAqD,EAAE,qDAAqD,EAAE;AAC3L;AACA;AACA;AACA,4GAA4G,IAAI,UAAU,IAAI,iBAAiB,IAAI,UAAU,IAAI;AACjK;AACA;AACA;AACA,4GAA4G,IAAI,UAAU,IAAI,iBAAiB,IAAI,UAAU,IAAI;AACjK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACtIA;AACA;AACA;AACA;AACqE;AACrE;AACA;AACA;AACA,2CAA2C,SAAS;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,4CAA4C,SAAS;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,SAAS;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,6EAAmB;AAC7C;AACA;AACA,wBAAwB,yCAAyC;AACjE;AACA;AACA,+CAA+C;AAC/C,wBAAwB,uCAAuC;AAC/D;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,KAAK;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,gBAAgB;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC7QA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,uBAAuB;AACvB,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,4BAA4B;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;ACpFA;AACA;AACA;AACA;AACsD;AACtD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,CAAC,8CAA8C;AAC/C;AACA;AACA;AACO;AACP;AACA;AACA;AACA,CAAC,0CAA0C;AAC3C;AACA;AACA;AACO;AACP;AACA;AACA;AACA,CAAC,0CAA0C;AACpC;AACP;AACA;AACA;AACA;AACA;AACA,CAAC,0DAA0D;AACpD;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,+DAAM;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;;;;;;;;;;;;;;;;;;AC3IA;AACA;AACA;AACA;AAC6D;AACd;AACY;AACpD;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,uDAAQ;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,iBAAiB;AAC7C;AACA;AACA,mCAAmC,oEAAiB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,mEAAU;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,wBAAwB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;ACjHA;AACA;AACA;AACA;AAC6D;AACL;AACjD;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,8DAAQ;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,8DAAQ;AACxB,gBAAgB,8DAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,8DAAQ;AAC7B,gBAAgB,8DAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,8DAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,YAAY;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,kBAAkB;AACtB;AACA,KAAK,oCAAoC;AACzC;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mEAAW;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE,SAAS;AAClF;AACA;AACA;AACA,4BAA4B,WAAW;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;AC9NA;AACA;AACA;AACA;AAC2D;AACkB;AAC9B;AACN;AACW;AACpD;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,iEAAoB;AACxC;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,iDAAU,8BAA8B,yFAAuB;AAClF;AACA;AACO;AACP;AACA;AACA;AACA,+CAA+C,SAAS;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA,mBAAmB,gDAAS;AAC5B;AACA;AACA,6CAA6C,SAAS;AACtD;AACA;AACA,eAAe,gDAAS;AACxB;AACA;AACA;AACA;AACA;AACA,+CAA+C,aAAa;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,iDAAK;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,wEAAwE;AACvI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,gDAAS,KAAK,iDAAK;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,iDAAK;AAC/D;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,uDAAQ;AAC5C;AACA;AACA;AACA;AACA;AACA,+CAA+C,iDAAK;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,uDAAQ;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,gBAAgB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,iDAAK;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,iDAAK;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,uDAAQ;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,gBAAgB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,iDAAK;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,qEAAwB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;ACncA;AACA;AACA;AACA;AAC+E;AACvB;AACI;AACV;AACH;AACN;AACQ;AACT;AAC4B;AAC7D;AACP;AACA,eAAe,kEAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,iCAAiC,iFAAuB;AACxD,iBAAiB,0DAAO;AACxB,iBAAiB,mEAAuB;AACxC;AACA,kBAAkB,uDAAQ;AAC1B,eAAe,iDAAK;AACpB,mBAAmB,yDAAS;AAC5B,4BAA4B,8EAAkC;AAC9D,wBAAwB,0EAA8B;AACtD,mBAAmB,qEAAyB;AAC5C,aAAa,oDAAG;AAChB,eAAe,gDAAK;AACpB;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvCA;AACA;AACA;AACA;AAC+D;AACb;AACH;AACN;AACwC;AACA;AACrB;AACyB;AAC5B;AACK;AACiB;AACZ;AACoB;AACM;AAC7F;AACA;AACA;AACA,0BAA0B,sEAAe;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,wBAAwB;AAChD;AACA,kDAAkD,uDAAQ;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,kEAAa,kBAAkB,8EAAyB;AACnF;AACA,uBAAuB,iDAAK;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA,0BAA0B,wDAAwD;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,kBAAkB;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,8DAA8D;AAC7G,6CAA6C,0DAA0D;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,uDAAQ;AACrB;AACA;AACA,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,oDAAG;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA,eAAe,yFAA2B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,4EAAkB,gBAAgB,4EAAkB;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,2BAA2B;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,iDAAK;AAC5B;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,gCAAgC,0BAA0B;AAC1D,gBAAgB,iDAAK,gDAAgD,iDAAK;AAC1E,0CAA0C,iDAAK,eAAe,iDAAK,4CAA4C,iDAAK;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,mBAAmB;AACtC;AACA;AACA;AACA,gBAAgB,iDAAK;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,aAAa;AAC3C;AACA;AACA;AACA,4BAA4B,qEAAU;AACtC,8CAA8C,iDAAK;AACnD;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,iCAAiC,sEAAsE;AACjI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,wEAAY;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,0GAA4B;AAC3C;AACA;AACA,uBAAuB,gEAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,4BAA4B;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,8DAA8D;AAClH;AACA;AACA;AACA;AACA,uBAAuB,6FAAmB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,2EAAiB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,2EAAiB;AACpD;AACA;AACA;AACA,oDAAoD,+BAA+B;AACnF;AACA;AACA;AACA;AACA,eAAe;AACf,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,wBAAwB,sEAAmB;AAC3C;;;;;;;;;;;;;;;;;;;;AC1gBA;AACA;AACA;AACA;AACyC;AACc;AACI;AACE;AACc;AACpE;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,iDAAiD;AACnF;AACA,6BAA6B,+DAAQ;AACrC;AACA;AACA;AACA;AACA;AACA;AACA,uEAAuE,yBAAyB;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,oEAAuB;AACnD;AACA;AACA;AACA;AACA;AACA,4BAA4B,oEAAuB;AACnD;AACA;AACA;AACA;AACA,+BAA+B,kEAAa,iBAAiB,oEAAmB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,mEAAW;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,iDAAK;AAC7C;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA,8CAA8C,wEAA2B,6BAA6B,wEAA2B;AACjI,yBAAyB;AACzB;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,oBAAoB,2EAA8B,0DAA0D;AAC5G;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,wEAA2B;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,wEAA2B;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,iEAAoB;AACzD;AACA;AACA;AACA,qBAAqB,wEAA2B;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,wEAA2B;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxLA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,oDAAoD;AAC9C;AACP;AACA;AACA;AACA,CAAC,sDAAsD;AAChD;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,oEAAoE;AAC9D;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,gDAAgD;AAC1C;AACP;AACA;AACA,CAAC,8CAA8C;AAC/C;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,CAAC,sDAAsD;AACvD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,0EAA0E;AAC3E;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,gDAAgD;AACjD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,4CAA4C;AAC7C;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sDAAsD;AACvD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,4DAA4D;AACtD;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,oCAAoC;AACrC;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,kDAAkD;AACnD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,8CAA8C;AAC/C;AACA;AACA;AACO;AACP;AACA;AACA;AACA,CAAC,0CAA0C;AAC3C;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,oCAAoC;AAC9B;AACP;AACA;AACA;AACA;AACA;AACA,CAAC,0DAA0D;AACpD;AACP;AACA;AACA;AACA,CAAC,sCAAsC;AACvC;AACA,WAAW,4DAA4D;AACvE;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,kEAAkE;AACnE;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C;AAC1C,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA,0CAA0C;AAC1C,4CAA4C;AAC5C;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA,0CAA0C;AAC1C,4CAA4C;AAC5C;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,0BAA0B;AACpB;AACP;AACA;AACA;AACA;AACA;AACA,CAAC,wCAAwC;AAClC;AACP;AACA;AACA;AACA,CAAC,8BAA8B;AAC/B;AACA;AACA;AACO;AACP;AACA;AACA;AACA,CAAC,0CAA0C;AAC3C;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,0CAA0C;AAC3C;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,0EAA0E;AAC3E;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,CAAC,8CAA8C;AACxC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,4CAA4C;AACtC;AACP;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sDAAsD;AAChD;AACP;AACA;AACA;AACA;AACA,CAAC,sCAAsC;AAChC;AACP;AACA;AACA;AACA,CAAC,gCAAgC;AAC1B;AACP;AACA;AACA;AACA;AACA,CAAC,kDAAkD;AACnD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,gDAAgD;AAC1C;AACP;AACA;AACA;AACA;AACA,CAAC,wCAAwC;AAClC;AACP;AACA;AACA;AACA;AACA,CAAC,4DAA4D;AAC7D;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,gCAAgC;AAC1B;AACP;AACA;AACA,CAAC,8BAA8B;AAC/B;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sEAAsE;AACvE;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sDAAsD;AACvD;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,CAAC,wDAAwD;AACzD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,wCAAwC;;;;;;;;;;;;;;;;;ACn6BzC;AACA;AACA;AACA;AACqD;AACqB;AACnE;AACP;AACA;AACA;AACA,gCAAgC,0DAAO;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,eAAe,uEAAY;AAC3B;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,uEAAY;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,iEAAU;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;ACxHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,OAAO;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,YAAY,IAAI,eAAe;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,QAAQ;AACxD,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,QAAQ;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iIAAiI;AACjI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,SAAS;AACjF;AACA,SAAS;AACT;AACA;;;;;;;UCpMA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCtBA;WACA;WACA;WACA;WACA,yCAAyC,wCAAwC;WACjF;WACA;WACA;;;;;WCPA;;;;;WCAA;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;;;;;;;;;;;;ACNA;AACA;AACA;AACA;AAC2E;AACE;AAC7E;AACO;AACP;AACA;AACA;AACA;AACA,6BAA6B,mFAAkB;AAC/C;AACA,KAAK,gBAAgB,sFAAkB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sources":["webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/arrays.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/arraysFind.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/assert.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/cache.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/cancellation.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/codicons.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/color.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/diff/diff.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/errors.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/event.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/functional.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/hash.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/iterator.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/keyCodes.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/lazy.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/linkedList.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/map.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/objects.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/path.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/platform.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/process.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/stopwatch.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/strings.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/types.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/uint.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/uri.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/position.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/range.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/selection.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/wordCharacterClassifier.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/core/wordHelper.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/computeMovedLines.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/lineSequence.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/defaultLinesDiffComputer/utils.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/legacyLinesDiffComputer.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputer.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/linesDiffComputers.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/diff/rangeMapping.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/languages.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/languages/defaultDocumentColorsComputer.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/languages/linkComputer.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/languages/supports/inplaceReplaceSupport.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/model.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/model/textModelSearch.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/services/editorBaseApi.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/services/unicodeTextModelHighlighter.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/common/tokenizationRegistry.js","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/nls.js","webpack://fausteditorweb/webpack/bootstrap","webpack://fausteditorweb/webpack/runtime/define property getters","webpack://fausteditorweb/webpack/runtime/hasOwnProperty shorthand","webpack://fausteditorweb/webpack/runtime/make namespace object","webpack://fausteditorweb/./node_modules/monaco-editor/esm/vs/editor/editor.worker.js"],"sourcesContent":["/**\n * Returns the last element of an array.\n * @param array The array.\n * @param n Which element from the end (default is zero).\n */\nexport function tail(array, n = 0) {\n return array[array.length - (1 + n)];\n}\nexport function tail2(arr) {\n if (arr.length === 0) {\n throw new Error('Invalid tail call');\n }\n return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];\n}\nexport function equals(one, other, itemEquals = (a, b) => a === b) {\n if (one === other) {\n return true;\n }\n if (!one || !other) {\n return false;\n }\n if (one.length !== other.length) {\n return false;\n }\n for (let i = 0, len = one.length; i < len; i++) {\n if (!itemEquals(one[i], other[i])) {\n return false;\n }\n }\n return true;\n}\n/**\n * Remove the element at `index` by replacing it with the last element. This is faster than `splice`\n * but changes the order of the array\n */\nexport function removeFastWithoutKeepingOrder(array, index) {\n const last = array.length - 1;\n if (index < last) {\n array[index] = array[last];\n }\n array.pop();\n}\n/**\n * Performs a binary search algorithm over a sorted array.\n *\n * @param array The array being searched.\n * @param key The value we search for.\n * @param comparator A function that takes two array elements and returns zero\n * if they are equal, a negative number if the first element precedes the\n * second one in the sorting order, or a positive number if the second element\n * precedes the first one.\n * @return See {@link binarySearch2}\n */\nexport function binarySearch(array, key, comparator) {\n return binarySearch2(array.length, i => comparator(array[i], key));\n}\n/**\n * Performs a binary search algorithm over a sorted collection. Useful for cases\n * when we need to perform a binary search over something that isn't actually an\n * array, and converting data to an array would defeat the use of binary search\n * in the first place.\n *\n * @param length The collection length.\n * @param compareToKey A function that takes an index of an element in the\n * collection and returns zero if the value at this index is equal to the\n * search key, a negative number if the value precedes the search key in the\n * sorting order, or a positive number if the search key precedes the value.\n * @return A non-negative index of an element, if found. If not found, the\n * result is -(n+1) (or ~n, using bitwise notation), where n is the index\n * where the key should be inserted to maintain the sorting order.\n */\nexport function binarySearch2(length, compareToKey) {\n let low = 0, high = length - 1;\n while (low <= high) {\n const mid = ((low + high) / 2) | 0;\n const comp = compareToKey(mid);\n if (comp < 0) {\n low = mid + 1;\n }\n else if (comp > 0) {\n high = mid - 1;\n }\n else {\n return mid;\n }\n }\n return -(low + 1);\n}\nexport function quickSelect(nth, data, compare) {\n nth = nth | 0;\n if (nth >= data.length) {\n throw new TypeError('invalid index');\n }\n const pivotValue = data[Math.floor(data.length * Math.random())];\n const lower = [];\n const higher = [];\n const pivots = [];\n for (const value of data) {\n const val = compare(value, pivotValue);\n if (val < 0) {\n lower.push(value);\n }\n else if (val > 0) {\n higher.push(value);\n }\n else {\n pivots.push(value);\n }\n }\n if (nth < lower.length) {\n return quickSelect(nth, lower, compare);\n }\n else if (nth < lower.length + pivots.length) {\n return pivots[0];\n }\n else {\n return quickSelect(nth - (lower.length + pivots.length), higher, compare);\n }\n}\nexport function groupBy(data, compare) {\n const result = [];\n let currentGroup = undefined;\n for (const element of data.slice(0).sort(compare)) {\n if (!currentGroup || compare(currentGroup[0], element) !== 0) {\n currentGroup = [element];\n result.push(currentGroup);\n }\n else {\n currentGroup.push(element);\n }\n }\n return result;\n}\n/**\n * Splits the given items into a list of (non-empty) groups.\n * `shouldBeGrouped` is used to decide if two consecutive items should be in the same group.\n * The order of the items is preserved.\n */\nexport function* groupAdjacentBy(items, shouldBeGrouped) {\n let currentGroup;\n let last;\n for (const item of items) {\n if (last !== undefined && shouldBeGrouped(last, item)) {\n currentGroup.push(item);\n }\n else {\n if (currentGroup) {\n yield currentGroup;\n }\n currentGroup = [item];\n }\n last = item;\n }\n if (currentGroup) {\n yield currentGroup;\n }\n}\nexport function forEachAdjacent(arr, f) {\n for (let i = 0; i <= arr.length; i++) {\n f(i === 0 ? undefined : arr[i - 1], i === arr.length ? undefined : arr[i]);\n }\n}\nexport function forEachWithNeighbors(arr, f) {\n for (let i = 0; i < arr.length; i++) {\n f(i === 0 ? undefined : arr[i - 1], arr[i], i + 1 === arr.length ? undefined : arr[i + 1]);\n }\n}\n/**\n * @returns New array with all falsy values removed. The original array IS NOT modified.\n */\nexport function coalesce(array) {\n return array.filter(e => !!e);\n}\n/**\n * Remove all falsy values from `array`. The original array IS modified.\n */\nexport function coalesceInPlace(array) {\n let to = 0;\n for (let i = 0; i < array.length; i++) {\n if (!!array[i]) {\n array[to] = array[i];\n to += 1;\n }\n }\n array.length = to;\n}\n/**\n * @returns false if the provided object is an array and not empty.\n */\nexport function isFalsyOrEmpty(obj) {\n return !Array.isArray(obj) || obj.length === 0;\n}\nexport function isNonEmptyArray(obj) {\n return Array.isArray(obj) && obj.length > 0;\n}\n/**\n * Removes duplicates from the given array. The optional keyFn allows to specify\n * how elements are checked for equality by returning an alternate value for each.\n */\nexport function distinct(array, keyFn = value => value) {\n const seen = new Set();\n return array.filter(element => {\n const key = keyFn(element);\n if (seen.has(key)) {\n return false;\n }\n seen.add(key);\n return true;\n });\n}\nexport function firstOrDefault(array, notFoundValue) {\n return array.length > 0 ? array[0] : notFoundValue;\n}\nexport function range(arg, to) {\n let from = typeof to === 'number' ? arg : 0;\n if (typeof to === 'number') {\n from = arg;\n }\n else {\n from = 0;\n to = arg;\n }\n const result = [];\n if (from <= to) {\n for (let i = from; i < to; i++) {\n result.push(i);\n }\n }\n else {\n for (let i = from; i > to; i--) {\n result.push(i);\n }\n }\n return result;\n}\n/**\n * Insert `insertArr` inside `target` at `insertIndex`.\n * Please don't touch unless you understand https://jsperf.com/inserting-an-array-within-an-array\n */\nexport function arrayInsert(target, insertIndex, insertArr) {\n const before = target.slice(0, insertIndex);\n const after = target.slice(insertIndex);\n return before.concat(insertArr, after);\n}\n/**\n * Pushes an element to the start of the array, if found.\n */\nexport function pushToStart(arr, value) {\n const index = arr.indexOf(value);\n if (index > -1) {\n arr.splice(index, 1);\n arr.unshift(value);\n }\n}\n/**\n * Pushes an element to the end of the array, if found.\n */\nexport function pushToEnd(arr, value) {\n const index = arr.indexOf(value);\n if (index > -1) {\n arr.splice(index, 1);\n arr.push(value);\n }\n}\nexport function pushMany(arr, items) {\n for (const item of items) {\n arr.push(item);\n }\n}\nexport function asArray(x) {\n return Array.isArray(x) ? x : [x];\n}\n/**\n * Insert the new items in the array.\n * @param array The original array.\n * @param start The zero-based location in the array from which to start inserting elements.\n * @param newItems The items to be inserted\n */\nexport function insertInto(array, start, newItems) {\n const startIdx = getActualStartIndex(array, start);\n const originalLength = array.length;\n const newItemsLength = newItems.length;\n array.length = originalLength + newItemsLength;\n // Move the items after the start index, start from the end so that we don't overwrite any value.\n for (let i = originalLength - 1; i >= startIdx; i--) {\n array[i + newItemsLength] = array[i];\n }\n for (let i = 0; i < newItemsLength; i++) {\n array[i + startIdx] = newItems[i];\n }\n}\n/**\n * Removes elements from an array and inserts new elements in their place, returning the deleted elements. Alternative to the native Array.splice method, it\n * can only support limited number of items due to the maximum call stack size limit.\n * @param array The original array.\n * @param start The zero-based location in the array from which to start removing elements.\n * @param deleteCount The number of elements to remove.\n * @returns An array containing the elements that were deleted.\n */\nexport function splice(array, start, deleteCount, newItems) {\n const index = getActualStartIndex(array, start);\n let result = array.splice(index, deleteCount);\n if (result === undefined) {\n // see https://bugs.webkit.org/show_bug.cgi?id=261140\n result = [];\n }\n insertInto(array, index, newItems);\n return result;\n}\n/**\n * Determine the actual start index (same logic as the native splice() or slice())\n * If greater than the length of the array, start will be set to the length of the array. In this case, no element will be deleted but the method will behave as an adding function, adding as many element as item[n*] provided.\n * If negative, it will begin that many elements from the end of the array. (In this case, the origin -1, meaning -n is the index of the nth last element, and is therefore equivalent to the index of array.length - n.) If array.length + start is less than 0, it will begin from index 0.\n * @param array The target array.\n * @param start The operation index.\n */\nfunction getActualStartIndex(array, start) {\n return start < 0 ? Math.max(start + array.length, 0) : Math.min(start, array.length);\n}\nexport var CompareResult;\n(function (CompareResult) {\n function isLessThan(result) {\n return result < 0;\n }\n CompareResult.isLessThan = isLessThan;\n function isLessThanOrEqual(result) {\n return result <= 0;\n }\n CompareResult.isLessThanOrEqual = isLessThanOrEqual;\n function isGreaterThan(result) {\n return result > 0;\n }\n CompareResult.isGreaterThan = isGreaterThan;\n function isNeitherLessOrGreaterThan(result) {\n return result === 0;\n }\n CompareResult.isNeitherLessOrGreaterThan = isNeitherLessOrGreaterThan;\n CompareResult.greaterThan = 1;\n CompareResult.lessThan = -1;\n CompareResult.neitherLessOrGreaterThan = 0;\n})(CompareResult || (CompareResult = {}));\nexport function compareBy(selector, comparator) {\n return (a, b) => comparator(selector(a), selector(b));\n}\nexport function tieBreakComparators(...comparators) {\n return (item1, item2) => {\n for (const comparator of comparators) {\n const result = comparator(item1, item2);\n if (!CompareResult.isNeitherLessOrGreaterThan(result)) {\n return result;\n }\n }\n return CompareResult.neitherLessOrGreaterThan;\n };\n}\n/**\n * The natural order on numbers.\n*/\nexport const numberComparator = (a, b) => a - b;\nexport const booleanComparator = (a, b) => numberComparator(a ? 1 : 0, b ? 1 : 0);\nexport function reverseOrder(comparator) {\n return (a, b) => -comparator(a, b);\n}\nexport class ArrayQueue {\n /**\n * Constructs a queue that is backed by the given array. Runtime is O(1).\n */\n constructor(items) {\n this.items = items;\n this.firstIdx = 0;\n this.lastIdx = this.items.length - 1;\n }\n get length() {\n return this.lastIdx - this.firstIdx + 1;\n }\n /**\n * Consumes elements from the beginning of the queue as long as the predicate returns true.\n * If no elements were consumed, `null` is returned. Has a runtime of O(result.length).\n */\n takeWhile(predicate) {\n // P(k) := k <= this.lastIdx && predicate(this.items[k])\n // Find s := min { k | k >= this.firstIdx && !P(k) } and return this.data[this.firstIdx...s)\n let startIdx = this.firstIdx;\n while (startIdx < this.items.length && predicate(this.items[startIdx])) {\n startIdx++;\n }\n const result = startIdx === this.firstIdx ? null : this.items.slice(this.firstIdx, startIdx);\n this.firstIdx = startIdx;\n return result;\n }\n /**\n * Consumes elements from the end of the queue as long as the predicate returns true.\n * If no elements were consumed, `null` is returned.\n * The result has the same order as the underlying array!\n */\n takeFromEndWhile(predicate) {\n // P(k) := this.firstIdx >= k && predicate(this.items[k])\n // Find s := max { k | k <= this.lastIdx && !P(k) } and return this.data(s...this.lastIdx]\n let endIdx = this.lastIdx;\n while (endIdx >= 0 && predicate(this.items[endIdx])) {\n endIdx--;\n }\n const result = endIdx === this.lastIdx ? null : this.items.slice(endIdx + 1, this.lastIdx + 1);\n this.lastIdx = endIdx;\n return result;\n }\n peek() {\n if (this.length === 0) {\n return undefined;\n }\n return this.items[this.firstIdx];\n }\n dequeue() {\n const result = this.items[this.firstIdx];\n this.firstIdx++;\n return result;\n }\n takeCount(count) {\n const result = this.items.slice(this.firstIdx, this.firstIdx + count);\n this.firstIdx += count;\n return result;\n }\n}\n/**\n * This class is faster than an iterator and array for lazy computed data.\n*/\nexport class CallbackIterable {\n constructor(\n /**\n * Calls the callback for every item.\n * Stops when the callback returns false.\n */\n iterate) {\n this.iterate = iterate;\n }\n toArray() {\n const result = [];\n this.iterate(item => { result.push(item); return true; });\n return result;\n }\n filter(predicate) {\n return new CallbackIterable(cb => this.iterate(item => predicate(item) ? cb(item) : true));\n }\n map(mapFn) {\n return new CallbackIterable(cb => this.iterate(item => cb(mapFn(item))));\n }\n findLast(predicate) {\n let result;\n this.iterate(item => {\n if (predicate(item)) {\n result = item;\n }\n return true;\n });\n return result;\n }\n findLastMaxBy(comparator) {\n let result;\n let first = true;\n this.iterate(item => {\n if (first || CompareResult.isGreaterThan(comparator(item, result))) {\n first = false;\n result = item;\n }\n return true;\n });\n return result;\n }\n}\nCallbackIterable.empty = new CallbackIterable(_callback => { });\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function findLast(array, predicate, fromIdx) {\n const idx = findLastIdx(array, predicate);\n if (idx === -1) {\n return undefined;\n }\n return array[idx];\n}\nexport function findLastIdx(array, predicate, fromIndex = array.length - 1) {\n for (let i = fromIndex; i >= 0; i--) {\n const element = array[i];\n if (predicate(element)) {\n return i;\n }\n }\n return -1;\n}\n/**\n * Finds the last item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!\n *\n * @returns `undefined` if no item matches, otherwise the last item that matches the predicate.\n */\nexport function findLastMonotonous(array, predicate) {\n const idx = findLastIdxMonotonous(array, predicate);\n return idx === -1 ? undefined : array[idx];\n}\n/**\n * Finds the last item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!\n *\n * @returns `startIdx - 1` if predicate is false for all items, otherwise the index of the last item that matches the predicate.\n */\nexport function findLastIdxMonotonous(array, predicate, startIdx = 0, endIdxEx = array.length) {\n let i = startIdx;\n let j = endIdxEx;\n while (i < j) {\n const k = Math.floor((i + j) / 2);\n if (predicate(array[k])) {\n i = k + 1;\n }\n else {\n j = k;\n }\n }\n return i - 1;\n}\n/**\n * Finds the first item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!\n *\n * @returns `undefined` if no item matches, otherwise the first item that matches the predicate.\n */\nexport function findFirstMonotonous(array, predicate) {\n const idx = findFirstIdxMonotonousOrArrLen(array, predicate);\n return idx === array.length ? undefined : array[idx];\n}\n/**\n * Finds the first item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!\n *\n * @returns `endIdxEx` if predicate is false for all items, otherwise the index of the first item that matches the predicate.\n */\nexport function findFirstIdxMonotonousOrArrLen(array, predicate, startIdx = 0, endIdxEx = array.length) {\n let i = startIdx;\n let j = endIdxEx;\n while (i < j) {\n const k = Math.floor((i + j) / 2);\n if (predicate(array[k])) {\n j = k;\n }\n else {\n i = k + 1;\n }\n }\n return i;\n}\n/**\n * Use this when\n * * You have a sorted array\n * * You query this array with a monotonous predicate to find the last item that has a certain property.\n * * You query this array multiple times with monotonous predicates that get weaker and weaker.\n */\nexport class MonotonousArray {\n constructor(_array) {\n this._array = _array;\n this._findLastMonotonousLastIdx = 0;\n }\n /**\n * The predicate must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!\n * For subsequent calls, current predicate must be weaker than (or equal to) the previous predicate, i.e. more entries must be `true`.\n */\n findLastMonotonous(predicate) {\n if (MonotonousArray.assertInvariants) {\n if (this._prevFindLastPredicate) {\n for (const item of this._array) {\n if (this._prevFindLastPredicate(item) && !predicate(item)) {\n throw new Error('MonotonousArray: current predicate must be weaker than (or equal to) the previous predicate.');\n }\n }\n }\n this._prevFindLastPredicate = predicate;\n }\n const idx = findLastIdxMonotonous(this._array, predicate, this._findLastMonotonousLastIdx);\n this._findLastMonotonousLastIdx = idx + 1;\n return idx === -1 ? undefined : this._array[idx];\n }\n}\nMonotonousArray.assertInvariants = false;\n/**\n * Returns the first item that is equal to or greater than every other item.\n*/\nexport function findFirstMaxBy(array, comparator) {\n if (array.length === 0) {\n return undefined;\n }\n let max = array[0];\n for (let i = 1; i < array.length; i++) {\n const item = array[i];\n if (comparator(item, max) > 0) {\n max = item;\n }\n }\n return max;\n}\n/**\n * Returns the last item that is equal to or greater than every other item.\n*/\nexport function findLastMaxBy(array, comparator) {\n if (array.length === 0) {\n return undefined;\n }\n let max = array[0];\n for (let i = 1; i < array.length; i++) {\n const item = array[i];\n if (comparator(item, max) >= 0) {\n max = item;\n }\n }\n return max;\n}\n/**\n * Returns the first item that is equal to or less than every other item.\n*/\nexport function findFirstMinBy(array, comparator) {\n return findFirstMaxBy(array, (a, b) => -comparator(a, b));\n}\nexport function findMaxIdxBy(array, comparator) {\n if (array.length === 0) {\n return -1;\n }\n let maxIdx = 0;\n for (let i = 1; i < array.length; i++) {\n const item = array[i];\n if (comparator(item, array[maxIdx]) > 0) {\n maxIdx = i;\n }\n }\n return maxIdx;\n}\n/**\n * Returns the first mapped value of the array which is not undefined.\n */\nexport function mapFindFirst(items, mapFn) {\n for (const value of items) {\n const mapped = mapFn(value);\n if (mapped !== undefined) {\n return mapped;\n }\n }\n return undefined;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError, onUnexpectedError } from './errors.js';\n/**\n * Throws an error with the provided message if the provided value does not evaluate to a true Javascript value.\n *\n * @deprecated Use `assert(...)` instead.\n * This method is usually used like this:\n * ```ts\n * import * as assert from 'vs/base/common/assert';\n * assert.ok(...);\n * ```\n *\n * However, `assert` in that example is a user chosen name.\n * There is no tooling for generating such an import statement.\n * Thus, the `assert(...)` function should be used instead.\n */\nexport function ok(value, message) {\n if (!value) {\n throw new Error(message ? `Assertion failed (${message})` : 'Assertion Failed');\n }\n}\nexport function assertNever(value, message = 'Unreachable') {\n throw new Error(message);\n}\n/**\n * condition must be side-effect free!\n */\nexport function assertFn(condition) {\n if (!condition()) {\n // eslint-disable-next-line no-debugger\n debugger;\n // Reevaluate `condition` again to make debugging easier\n condition();\n onUnexpectedError(new BugIndicatingError('Assertion Failed'));\n }\n}\nexport function checkAdjacentItems(items, predicate) {\n let i = 0;\n while (i < items.length - 1) {\n const a = items[i];\n const b = items[i + 1];\n if (!predicate(a, b)) {\n return false;\n }\n i++;\n }\n return true;\n}\n","/**\n * Uses a LRU cache to make a given parametrized function cached.\n * Caches just the last value.\n * The key must be JSON serializable.\n*/\nexport class LRUCachedFunction {\n constructor(fn) {\n this.fn = fn;\n this.lastCache = undefined;\n this.lastArgKey = undefined;\n }\n get(arg) {\n const key = JSON.stringify(arg);\n if (this.lastArgKey !== key) {\n this.lastArgKey = key;\n this.lastCache = this.fn(arg);\n }\n return this.lastCache;\n }\n}\n/**\n * Uses an unbounded cache (referential equality) to memoize the results of the given function.\n*/\nexport class CachedFunction {\n get cachedValues() {\n return this._map;\n }\n constructor(fn) {\n this.fn = fn;\n this._map = new Map();\n }\n get(arg) {\n if (this._map.has(arg)) {\n return this._map.get(arg);\n }\n const value = this.fn(arg);\n this._map.set(arg, value);\n return value;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter, Event } from './event.js';\nconst shortcutEvent = Object.freeze(function (callback, context) {\n const handle = setTimeout(callback.bind(context), 0);\n return { dispose() { clearTimeout(handle); } };\n});\nexport var CancellationToken;\n(function (CancellationToken) {\n function isCancellationToken(thing) {\n if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {\n return true;\n }\n if (thing instanceof MutableToken) {\n return true;\n }\n if (!thing || typeof thing !== 'object') {\n return false;\n }\n return typeof thing.isCancellationRequested === 'boolean'\n && typeof thing.onCancellationRequested === 'function';\n }\n CancellationToken.isCancellationToken = isCancellationToken;\n CancellationToken.None = Object.freeze({\n isCancellationRequested: false,\n onCancellationRequested: Event.None\n });\n CancellationToken.Cancelled = Object.freeze({\n isCancellationRequested: true,\n onCancellationRequested: shortcutEvent\n });\n})(CancellationToken || (CancellationToken = {}));\nclass MutableToken {\n constructor() {\n this._isCancelled = false;\n this._emitter = null;\n }\n cancel() {\n if (!this._isCancelled) {\n this._isCancelled = true;\n if (this._emitter) {\n this._emitter.fire(undefined);\n this.dispose();\n }\n }\n }\n get isCancellationRequested() {\n return this._isCancelled;\n }\n get onCancellationRequested() {\n if (this._isCancelled) {\n return shortcutEvent;\n }\n if (!this._emitter) {\n this._emitter = new Emitter();\n }\n return this._emitter.event;\n }\n dispose() {\n if (this._emitter) {\n this._emitter.dispose();\n this._emitter = null;\n }\n }\n}\nexport class CancellationTokenSource {\n constructor(parent) {\n this._token = undefined;\n this._parentListener = undefined;\n this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);\n }\n get token() {\n if (!this._token) {\n // be lazy and create the token only when\n // actually needed\n this._token = new MutableToken();\n }\n return this._token;\n }\n cancel() {\n if (!this._token) {\n // save an object by returning the default\n // cancelled token when cancellation happens\n // before someone asks for the token\n this._token = CancellationToken.Cancelled;\n }\n else if (this._token instanceof MutableToken) {\n // actually cancel\n this._token.cancel();\n }\n }\n dispose(cancel = false) {\n var _a;\n if (cancel) {\n this.cancel();\n }\n (_a = this._parentListener) === null || _a === void 0 ? void 0 : _a.dispose();\n if (!this._token) {\n // ensure to initialize with an empty token if we had none\n this._token = CancellationToken.None;\n }\n else if (this._token instanceof MutableToken) {\n // actually dispose\n this._token.dispose();\n }\n }\n}\n","import { isString } from './types.js';\nconst _codiconFontCharacters = Object.create(null);\nfunction register(id, fontCharacter) {\n if (isString(fontCharacter)) {\n const val = _codiconFontCharacters[fontCharacter];\n if (val === undefined) {\n throw new Error(`${id} references an unknown codicon: ${fontCharacter}`);\n }\n fontCharacter = val;\n }\n _codiconFontCharacters[id] = fontCharacter;\n return { id };\n}\n/**\n * Only to be used by the iconRegistry.\n */\nexport function getCodiconFontCharacters() {\n return _codiconFontCharacters;\n}\n/**\n * The Codicon library is a set of default icons that are built-in in VS Code.\n *\n * In the product (outside of base) Codicons should only be used as defaults. In order to have all icons in VS Code\n * themeable, component should define new, UI component specific icons using `iconRegistry.registerIcon`.\n * In that call a Codicon can be named as default.\n */\nexport const Codicon = {\n // built-in icons, with image name\n add: register('add', 0xea60),\n plus: register('plus', 0xea60),\n gistNew: register('gist-new', 0xea60),\n repoCreate: register('repo-create', 0xea60),\n lightbulb: register('lightbulb', 0xea61),\n lightBulb: register('light-bulb', 0xea61),\n repo: register('repo', 0xea62),\n repoDelete: register('repo-delete', 0xea62),\n gistFork: register('gist-fork', 0xea63),\n repoForked: register('repo-forked', 0xea63),\n gitPullRequest: register('git-pull-request', 0xea64),\n gitPullRequestAbandoned: register('git-pull-request-abandoned', 0xea64),\n recordKeys: register('record-keys', 0xea65),\n keyboard: register('keyboard', 0xea65),\n tag: register('tag', 0xea66),\n tagAdd: register('tag-add', 0xea66),\n tagRemove: register('tag-remove', 0xea66),\n gitPullRequestLabel: register('git-pull-request-label', 0xea66),\n person: register('person', 0xea67),\n personFollow: register('person-follow', 0xea67),\n personOutline: register('person-outline', 0xea67),\n personFilled: register('person-filled', 0xea67),\n gitBranch: register('git-branch', 0xea68),\n gitBranchCreate: register('git-branch-create', 0xea68),\n gitBranchDelete: register('git-branch-delete', 0xea68),\n sourceControl: register('source-control', 0xea68),\n mirror: register('mirror', 0xea69),\n mirrorPublic: register('mirror-public', 0xea69),\n star: register('star', 0xea6a),\n starAdd: register('star-add', 0xea6a),\n starDelete: register('star-delete', 0xea6a),\n starEmpty: register('star-empty', 0xea6a),\n comment: register('comment', 0xea6b),\n commentAdd: register('comment-add', 0xea6b),\n alert: register('alert', 0xea6c),\n warning: register('warning', 0xea6c),\n search: register('search', 0xea6d),\n searchSave: register('search-save', 0xea6d),\n logOut: register('log-out', 0xea6e),\n signOut: register('sign-out', 0xea6e),\n logIn: register('log-in', 0xea6f),\n signIn: register('sign-in', 0xea6f),\n eye: register('eye', 0xea70),\n eyeUnwatch: register('eye-unwatch', 0xea70),\n eyeWatch: register('eye-watch', 0xea70),\n circleFilled: register('circle-filled', 0xea71),\n primitiveDot: register('primitive-dot', 0xea71),\n closeDirty: register('close-dirty', 0xea71),\n debugBreakpoint: register('debug-breakpoint', 0xea71),\n debugBreakpointDisabled: register('debug-breakpoint-disabled', 0xea71),\n debugHint: register('debug-hint', 0xea71),\n primitiveSquare: register('primitive-square', 0xea72),\n edit: register('edit', 0xea73),\n pencil: register('pencil', 0xea73),\n info: register('info', 0xea74),\n issueOpened: register('issue-opened', 0xea74),\n gistPrivate: register('gist-private', 0xea75),\n gitForkPrivate: register('git-fork-private', 0xea75),\n lock: register('lock', 0xea75),\n mirrorPrivate: register('mirror-private', 0xea75),\n close: register('close', 0xea76),\n removeClose: register('remove-close', 0xea76),\n x: register('x', 0xea76),\n repoSync: register('repo-sync', 0xea77),\n sync: register('sync', 0xea77),\n clone: register('clone', 0xea78),\n desktopDownload: register('desktop-download', 0xea78),\n beaker: register('beaker', 0xea79),\n microscope: register('microscope', 0xea79),\n vm: register('vm', 0xea7a),\n deviceDesktop: register('device-desktop', 0xea7a),\n file: register('file', 0xea7b),\n fileText: register('file-text', 0xea7b),\n more: register('more', 0xea7c),\n ellipsis: register('ellipsis', 0xea7c),\n kebabHorizontal: register('kebab-horizontal', 0xea7c),\n mailReply: register('mail-reply', 0xea7d),\n reply: register('reply', 0xea7d),\n organization: register('organization', 0xea7e),\n organizationFilled: register('organization-filled', 0xea7e),\n organizationOutline: register('organization-outline', 0xea7e),\n newFile: register('new-file', 0xea7f),\n fileAdd: register('file-add', 0xea7f),\n newFolder: register('new-folder', 0xea80),\n fileDirectoryCreate: register('file-directory-create', 0xea80),\n trash: register('trash', 0xea81),\n trashcan: register('trashcan', 0xea81),\n history: register('history', 0xea82),\n clock: register('clock', 0xea82),\n folder: register('folder', 0xea83),\n fileDirectory: register('file-directory', 0xea83),\n symbolFolder: register('symbol-folder', 0xea83),\n logoGithub: register('logo-github', 0xea84),\n markGithub: register('mark-github', 0xea84),\n github: register('github', 0xea84),\n terminal: register('terminal', 0xea85),\n console: register('console', 0xea85),\n repl: register('repl', 0xea85),\n zap: register('zap', 0xea86),\n symbolEvent: register('symbol-event', 0xea86),\n error: register('error', 0xea87),\n stop: register('stop', 0xea87),\n variable: register('variable', 0xea88),\n symbolVariable: register('symbol-variable', 0xea88),\n array: register('array', 0xea8a),\n symbolArray: register('symbol-array', 0xea8a),\n symbolModule: register('symbol-module', 0xea8b),\n symbolPackage: register('symbol-package', 0xea8b),\n symbolNamespace: register('symbol-namespace', 0xea8b),\n symbolObject: register('symbol-object', 0xea8b),\n symbolMethod: register('symbol-method', 0xea8c),\n symbolFunction: register('symbol-function', 0xea8c),\n symbolConstructor: register('symbol-constructor', 0xea8c),\n symbolBoolean: register('symbol-boolean', 0xea8f),\n symbolNull: register('symbol-null', 0xea8f),\n symbolNumeric: register('symbol-numeric', 0xea90),\n symbolNumber: register('symbol-number', 0xea90),\n symbolStructure: register('symbol-structure', 0xea91),\n symbolStruct: register('symbol-struct', 0xea91),\n symbolParameter: register('symbol-parameter', 0xea92),\n symbolTypeParameter: register('symbol-type-parameter', 0xea92),\n symbolKey: register('symbol-key', 0xea93),\n symbolText: register('symbol-text', 0xea93),\n symbolReference: register('symbol-reference', 0xea94),\n goToFile: register('go-to-file', 0xea94),\n symbolEnum: register('symbol-enum', 0xea95),\n symbolValue: register('symbol-value', 0xea95),\n symbolRuler: register('symbol-ruler', 0xea96),\n symbolUnit: register('symbol-unit', 0xea96),\n activateBreakpoints: register('activate-breakpoints', 0xea97),\n archive: register('archive', 0xea98),\n arrowBoth: register('arrow-both', 0xea99),\n arrowDown: register('arrow-down', 0xea9a),\n arrowLeft: register('arrow-left', 0xea9b),\n arrowRight: register('arrow-right', 0xea9c),\n arrowSmallDown: register('arrow-small-down', 0xea9d),\n arrowSmallLeft: register('arrow-small-left', 0xea9e),\n arrowSmallRight: register('arrow-small-right', 0xea9f),\n arrowSmallUp: register('arrow-small-up', 0xeaa0),\n arrowUp: register('arrow-up', 0xeaa1),\n bell: register('bell', 0xeaa2),\n bold: register('bold', 0xeaa3),\n book: register('book', 0xeaa4),\n bookmark: register('bookmark', 0xeaa5),\n debugBreakpointConditionalUnverified: register('debug-breakpoint-conditional-unverified', 0xeaa6),\n debugBreakpointConditional: register('debug-breakpoint-conditional', 0xeaa7),\n debugBreakpointConditionalDisabled: register('debug-breakpoint-conditional-disabled', 0xeaa7),\n debugBreakpointDataUnverified: register('debug-breakpoint-data-unverified', 0xeaa8),\n debugBreakpointData: register('debug-breakpoint-data', 0xeaa9),\n debugBreakpointDataDisabled: register('debug-breakpoint-data-disabled', 0xeaa9),\n debugBreakpointLogUnverified: register('debug-breakpoint-log-unverified', 0xeaaa),\n debugBreakpointLog: register('debug-breakpoint-log', 0xeaab),\n debugBreakpointLogDisabled: register('debug-breakpoint-log-disabled', 0xeaab),\n briefcase: register('briefcase', 0xeaac),\n broadcast: register('broadcast', 0xeaad),\n browser: register('browser', 0xeaae),\n bug: register('bug', 0xeaaf),\n calendar: register('calendar', 0xeab0),\n caseSensitive: register('case-sensitive', 0xeab1),\n check: register('check', 0xeab2),\n checklist: register('checklist', 0xeab3),\n chevronDown: register('chevron-down', 0xeab4),\n dropDownButton: register('drop-down-button', 0xeab4),\n chevronLeft: register('chevron-left', 0xeab5),\n chevronRight: register('chevron-right', 0xeab6),\n chevronUp: register('chevron-up', 0xeab7),\n chromeClose: register('chrome-close', 0xeab8),\n chromeMaximize: register('chrome-maximize', 0xeab9),\n chromeMinimize: register('chrome-minimize', 0xeaba),\n chromeRestore: register('chrome-restore', 0xeabb),\n circle: register('circle', 0xeabc),\n circleOutline: register('circle-outline', 0xeabc),\n debugBreakpointUnverified: register('debug-breakpoint-unverified', 0xeabc),\n circleSlash: register('circle-slash', 0xeabd),\n circuitBoard: register('circuit-board', 0xeabe),\n clearAll: register('clear-all', 0xeabf),\n clippy: register('clippy', 0xeac0),\n closeAll: register('close-all', 0xeac1),\n cloudDownload: register('cloud-download', 0xeac2),\n cloudUpload: register('cloud-upload', 0xeac3),\n code: register('code', 0xeac4),\n collapseAll: register('collapse-all', 0xeac5),\n colorMode: register('color-mode', 0xeac6),\n commentDiscussion: register('comment-discussion', 0xeac7),\n compareChanges: register('compare-changes', 0xeafd),\n creditCard: register('credit-card', 0xeac9),\n dash: register('dash', 0xeacc),\n dashboard: register('dashboard', 0xeacd),\n database: register('database', 0xeace),\n debugContinue: register('debug-continue', 0xeacf),\n debugDisconnect: register('debug-disconnect', 0xead0),\n debugPause: register('debug-pause', 0xead1),\n debugRestart: register('debug-restart', 0xead2),\n debugStart: register('debug-start', 0xead3),\n debugStepInto: register('debug-step-into', 0xead4),\n debugStepOut: register('debug-step-out', 0xead5),\n debugStepOver: register('debug-step-over', 0xead6),\n debugStop: register('debug-stop', 0xead7),\n debug: register('debug', 0xead8),\n deviceCameraVideo: register('device-camera-video', 0xead9),\n deviceCamera: register('device-camera', 0xeada),\n deviceMobile: register('device-mobile', 0xeadb),\n diffAdded: register('diff-added', 0xeadc),\n diffIgnored: register('diff-ignored', 0xeadd),\n diffModified: register('diff-modified', 0xeade),\n diffRemoved: register('diff-removed', 0xeadf),\n diffRenamed: register('diff-renamed', 0xeae0),\n diff: register('diff', 0xeae1),\n discard: register('discard', 0xeae2),\n editorLayout: register('editor-layout', 0xeae3),\n emptyWindow: register('empty-window', 0xeae4),\n exclude: register('exclude', 0xeae5),\n extensions: register('extensions', 0xeae6),\n eyeClosed: register('eye-closed', 0xeae7),\n fileBinary: register('file-binary', 0xeae8),\n fileCode: register('file-code', 0xeae9),\n fileMedia: register('file-media', 0xeaea),\n filePdf: register('file-pdf', 0xeaeb),\n fileSubmodule: register('file-submodule', 0xeaec),\n fileSymlinkDirectory: register('file-symlink-directory', 0xeaed),\n fileSymlinkFile: register('file-symlink-file', 0xeaee),\n fileZip: register('file-zip', 0xeaef),\n files: register('files', 0xeaf0),\n filter: register('filter', 0xeaf1),\n flame: register('flame', 0xeaf2),\n foldDown: register('fold-down', 0xeaf3),\n foldUp: register('fold-up', 0xeaf4),\n fold: register('fold', 0xeaf5),\n folderActive: register('folder-active', 0xeaf6),\n folderOpened: register('folder-opened', 0xeaf7),\n gear: register('gear', 0xeaf8),\n gift: register('gift', 0xeaf9),\n gistSecret: register('gist-secret', 0xeafa),\n gist: register('gist', 0xeafb),\n gitCommit: register('git-commit', 0xeafc),\n gitCompare: register('git-compare', 0xeafd),\n gitMerge: register('git-merge', 0xeafe),\n githubAction: register('github-action', 0xeaff),\n githubAlt: register('github-alt', 0xeb00),\n globe: register('globe', 0xeb01),\n grabber: register('grabber', 0xeb02),\n graph: register('graph', 0xeb03),\n gripper: register('gripper', 0xeb04),\n heart: register('heart', 0xeb05),\n home: register('home', 0xeb06),\n horizontalRule: register('horizontal-rule', 0xeb07),\n hubot: register('hubot', 0xeb08),\n inbox: register('inbox', 0xeb09),\n issueClosed: register('issue-closed', 0xeba4),\n issueReopened: register('issue-reopened', 0xeb0b),\n issues: register('issues', 0xeb0c),\n italic: register('italic', 0xeb0d),\n jersey: register('jersey', 0xeb0e),\n json: register('json', 0xeb0f),\n bracket: register('bracket', 0xeb0f),\n kebabVertical: register('kebab-vertical', 0xeb10),\n key: register('key', 0xeb11),\n law: register('law', 0xeb12),\n lightbulbAutofix: register('lightbulb-autofix', 0xeb13),\n linkExternal: register('link-external', 0xeb14),\n link: register('link', 0xeb15),\n listOrdered: register('list-ordered', 0xeb16),\n listUnordered: register('list-unordered', 0xeb17),\n liveShare: register('live-share', 0xeb18),\n loading: register('loading', 0xeb19),\n location: register('location', 0xeb1a),\n mailRead: register('mail-read', 0xeb1b),\n mail: register('mail', 0xeb1c),\n markdown: register('markdown', 0xeb1d),\n megaphone: register('megaphone', 0xeb1e),\n mention: register('mention', 0xeb1f),\n milestone: register('milestone', 0xeb20),\n gitPullRequestMilestone: register('git-pull-request-milestone', 0xeb20),\n mortarBoard: register('mortar-board', 0xeb21),\n move: register('move', 0xeb22),\n multipleWindows: register('multiple-windows', 0xeb23),\n mute: register('mute', 0xeb24),\n noNewline: register('no-newline', 0xeb25),\n note: register('note', 0xeb26),\n octoface: register('octoface', 0xeb27),\n openPreview: register('open-preview', 0xeb28),\n package: register('package', 0xeb29),\n paintcan: register('paintcan', 0xeb2a),\n pin: register('pin', 0xeb2b),\n play: register('play', 0xeb2c),\n run: register('run', 0xeb2c),\n plug: register('plug', 0xeb2d),\n preserveCase: register('preserve-case', 0xeb2e),\n preview: register('preview', 0xeb2f),\n project: register('project', 0xeb30),\n pulse: register('pulse', 0xeb31),\n question: register('question', 0xeb32),\n quote: register('quote', 0xeb33),\n radioTower: register('radio-tower', 0xeb34),\n reactions: register('reactions', 0xeb35),\n references: register('references', 0xeb36),\n refresh: register('refresh', 0xeb37),\n regex: register('regex', 0xeb38),\n remoteExplorer: register('remote-explorer', 0xeb39),\n remote: register('remote', 0xeb3a),\n remove: register('remove', 0xeb3b),\n replaceAll: register('replace-all', 0xeb3c),\n replace: register('replace', 0xeb3d),\n repoClone: register('repo-clone', 0xeb3e),\n repoForcePush: register('repo-force-push', 0xeb3f),\n repoPull: register('repo-pull', 0xeb40),\n repoPush: register('repo-push', 0xeb41),\n report: register('report', 0xeb42),\n requestChanges: register('request-changes', 0xeb43),\n rocket: register('rocket', 0xeb44),\n rootFolderOpened: register('root-folder-opened', 0xeb45),\n rootFolder: register('root-folder', 0xeb46),\n rss: register('rss', 0xeb47),\n ruby: register('ruby', 0xeb48),\n saveAll: register('save-all', 0xeb49),\n saveAs: register('save-as', 0xeb4a),\n save: register('save', 0xeb4b),\n screenFull: register('screen-full', 0xeb4c),\n screenNormal: register('screen-normal', 0xeb4d),\n searchStop: register('search-stop', 0xeb4e),\n server: register('server', 0xeb50),\n settingsGear: register('settings-gear', 0xeb51),\n settings: register('settings', 0xeb52),\n shield: register('shield', 0xeb53),\n smiley: register('smiley', 0xeb54),\n sortPrecedence: register('sort-precedence', 0xeb55),\n splitHorizontal: register('split-horizontal', 0xeb56),\n splitVertical: register('split-vertical', 0xeb57),\n squirrel: register('squirrel', 0xeb58),\n starFull: register('star-full', 0xeb59),\n starHalf: register('star-half', 0xeb5a),\n symbolClass: register('symbol-class', 0xeb5b),\n symbolColor: register('symbol-color', 0xeb5c),\n symbolCustomColor: register('symbol-customcolor', 0xeb5c),\n symbolConstant: register('symbol-constant', 0xeb5d),\n symbolEnumMember: register('symbol-enum-member', 0xeb5e),\n symbolField: register('symbol-field', 0xeb5f),\n symbolFile: register('symbol-file', 0xeb60),\n symbolInterface: register('symbol-interface', 0xeb61),\n symbolKeyword: register('symbol-keyword', 0xeb62),\n symbolMisc: register('symbol-misc', 0xeb63),\n symbolOperator: register('symbol-operator', 0xeb64),\n symbolProperty: register('symbol-property', 0xeb65),\n wrench: register('wrench', 0xeb65),\n wrenchSubaction: register('wrench-subaction', 0xeb65),\n symbolSnippet: register('symbol-snippet', 0xeb66),\n tasklist: register('tasklist', 0xeb67),\n telescope: register('telescope', 0xeb68),\n textSize: register('text-size', 0xeb69),\n threeBars: register('three-bars', 0xeb6a),\n thumbsdown: register('thumbsdown', 0xeb6b),\n thumbsup: register('thumbsup', 0xeb6c),\n tools: register('tools', 0xeb6d),\n triangleDown: register('triangle-down', 0xeb6e),\n triangleLeft: register('triangle-left', 0xeb6f),\n triangleRight: register('triangle-right', 0xeb70),\n triangleUp: register('triangle-up', 0xeb71),\n twitter: register('twitter', 0xeb72),\n unfold: register('unfold', 0xeb73),\n unlock: register('unlock', 0xeb74),\n unmute: register('unmute', 0xeb75),\n unverified: register('unverified', 0xeb76),\n verified: register('verified', 0xeb77),\n versions: register('versions', 0xeb78),\n vmActive: register('vm-active', 0xeb79),\n vmOutline: register('vm-outline', 0xeb7a),\n vmRunning: register('vm-running', 0xeb7b),\n watch: register('watch', 0xeb7c),\n whitespace: register('whitespace', 0xeb7d),\n wholeWord: register('whole-word', 0xeb7e),\n window: register('window', 0xeb7f),\n wordWrap: register('word-wrap', 0xeb80),\n zoomIn: register('zoom-in', 0xeb81),\n zoomOut: register('zoom-out', 0xeb82),\n listFilter: register('list-filter', 0xeb83),\n listFlat: register('list-flat', 0xeb84),\n listSelection: register('list-selection', 0xeb85),\n selection: register('selection', 0xeb85),\n listTree: register('list-tree', 0xeb86),\n debugBreakpointFunctionUnverified: register('debug-breakpoint-function-unverified', 0xeb87),\n debugBreakpointFunction: register('debug-breakpoint-function', 0xeb88),\n debugBreakpointFunctionDisabled: register('debug-breakpoint-function-disabled', 0xeb88),\n debugStackframeActive: register('debug-stackframe-active', 0xeb89),\n circleSmallFilled: register('circle-small-filled', 0xeb8a),\n debugStackframeDot: register('debug-stackframe-dot', 0xeb8a),\n debugStackframe: register('debug-stackframe', 0xeb8b),\n debugStackframeFocused: register('debug-stackframe-focused', 0xeb8b),\n debugBreakpointUnsupported: register('debug-breakpoint-unsupported', 0xeb8c),\n symbolString: register('symbol-string', 0xeb8d),\n debugReverseContinue: register('debug-reverse-continue', 0xeb8e),\n debugStepBack: register('debug-step-back', 0xeb8f),\n debugRestartFrame: register('debug-restart-frame', 0xeb90),\n callIncoming: register('call-incoming', 0xeb92),\n callOutgoing: register('call-outgoing', 0xeb93),\n menu: register('menu', 0xeb94),\n expandAll: register('expand-all', 0xeb95),\n feedback: register('feedback', 0xeb96),\n gitPullRequestReviewer: register('git-pull-request-reviewer', 0xeb96),\n groupByRefType: register('group-by-ref-type', 0xeb97),\n ungroupByRefType: register('ungroup-by-ref-type', 0xeb98),\n account: register('account', 0xeb99),\n gitPullRequestAssignee: register('git-pull-request-assignee', 0xeb99),\n bellDot: register('bell-dot', 0xeb9a),\n debugConsole: register('debug-console', 0xeb9b),\n library: register('library', 0xeb9c),\n output: register('output', 0xeb9d),\n runAll: register('run-all', 0xeb9e),\n syncIgnored: register('sync-ignored', 0xeb9f),\n pinned: register('pinned', 0xeba0),\n githubInverted: register('github-inverted', 0xeba1),\n debugAlt: register('debug-alt', 0xeb91),\n serverProcess: register('server-process', 0xeba2),\n serverEnvironment: register('server-environment', 0xeba3),\n pass: register('pass', 0xeba4),\n stopCircle: register('stop-circle', 0xeba5),\n playCircle: register('play-circle', 0xeba6),\n record: register('record', 0xeba7),\n debugAltSmall: register('debug-alt-small', 0xeba8),\n vmConnect: register('vm-connect', 0xeba9),\n cloud: register('cloud', 0xebaa),\n merge: register('merge', 0xebab),\n exportIcon: register('export', 0xebac),\n graphLeft: register('graph-left', 0xebad),\n magnet: register('magnet', 0xebae),\n notebook: register('notebook', 0xebaf),\n redo: register('redo', 0xebb0),\n checkAll: register('check-all', 0xebb1),\n pinnedDirty: register('pinned-dirty', 0xebb2),\n passFilled: register('pass-filled', 0xebb3),\n circleLargeFilled: register('circle-large-filled', 0xebb4),\n circleLarge: register('circle-large', 0xebb5),\n circleLargeOutline: register('circle-large-outline', 0xebb5),\n combine: register('combine', 0xebb6),\n gather: register('gather', 0xebb6),\n table: register('table', 0xebb7),\n variableGroup: register('variable-group', 0xebb8),\n typeHierarchy: register('type-hierarchy', 0xebb9),\n typeHierarchySub: register('type-hierarchy-sub', 0xebba),\n typeHierarchySuper: register('type-hierarchy-super', 0xebbb),\n gitPullRequestCreate: register('git-pull-request-create', 0xebbc),\n runAbove: register('run-above', 0xebbd),\n runBelow: register('run-below', 0xebbe),\n notebookTemplate: register('notebook-template', 0xebbf),\n debugRerun: register('debug-rerun', 0xebc0),\n workspaceTrusted: register('workspace-trusted', 0xebc1),\n workspaceUntrusted: register('workspace-untrusted', 0xebc2),\n workspaceUnspecified: register('workspace-unspecified', 0xebc3),\n terminalCmd: register('terminal-cmd', 0xebc4),\n terminalDebian: register('terminal-debian', 0xebc5),\n terminalLinux: register('terminal-linux', 0xebc6),\n terminalPowershell: register('terminal-powershell', 0xebc7),\n terminalTmux: register('terminal-tmux', 0xebc8),\n terminalUbuntu: register('terminal-ubuntu', 0xebc9),\n terminalBash: register('terminal-bash', 0xebca),\n arrowSwap: register('arrow-swap', 0xebcb),\n copy: register('copy', 0xebcc),\n personAdd: register('person-add', 0xebcd),\n filterFilled: register('filter-filled', 0xebce),\n wand: register('wand', 0xebcf),\n debugLineByLine: register('debug-line-by-line', 0xebd0),\n inspect: register('inspect', 0xebd1),\n layers: register('layers', 0xebd2),\n layersDot: register('layers-dot', 0xebd3),\n layersActive: register('layers-active', 0xebd4),\n compass: register('compass', 0xebd5),\n compassDot: register('compass-dot', 0xebd6),\n compassActive: register('compass-active', 0xebd7),\n azure: register('azure', 0xebd8),\n issueDraft: register('issue-draft', 0xebd9),\n gitPullRequestClosed: register('git-pull-request-closed', 0xebda),\n gitPullRequestDraft: register('git-pull-request-draft', 0xebdb),\n debugAll: register('debug-all', 0xebdc),\n debugCoverage: register('debug-coverage', 0xebdd),\n runErrors: register('run-errors', 0xebde),\n folderLibrary: register('folder-library', 0xebdf),\n debugContinueSmall: register('debug-continue-small', 0xebe0),\n beakerStop: register('beaker-stop', 0xebe1),\n graphLine: register('graph-line', 0xebe2),\n graphScatter: register('graph-scatter', 0xebe3),\n pieChart: register('pie-chart', 0xebe4),\n bracketDot: register('bracket-dot', 0xebe5),\n bracketError: register('bracket-error', 0xebe6),\n lockSmall: register('lock-small', 0xebe7),\n azureDevops: register('azure-devops', 0xebe8),\n verifiedFilled: register('verified-filled', 0xebe9),\n newLine: register('newline', 0xebea),\n layout: register('layout', 0xebeb),\n layoutActivitybarLeft: register('layout-activitybar-left', 0xebec),\n layoutActivitybarRight: register('layout-activitybar-right', 0xebed),\n layoutPanelLeft: register('layout-panel-left', 0xebee),\n layoutPanelCenter: register('layout-panel-center', 0xebef),\n layoutPanelJustify: register('layout-panel-justify', 0xebf0),\n layoutPanelRight: register('layout-panel-right', 0xebf1),\n layoutPanel: register('layout-panel', 0xebf2),\n layoutSidebarLeft: register('layout-sidebar-left', 0xebf3),\n layoutSidebarRight: register('layout-sidebar-right', 0xebf4),\n layoutStatusbar: register('layout-statusbar', 0xebf5),\n layoutMenubar: register('layout-menubar', 0xebf6),\n layoutCentered: register('layout-centered', 0xebf7),\n layoutSidebarRightOff: register('layout-sidebar-right-off', 0xec00),\n layoutPanelOff: register('layout-panel-off', 0xec01),\n layoutSidebarLeftOff: register('layout-sidebar-left-off', 0xec02),\n target: register('target', 0xebf8),\n indent: register('indent', 0xebf9),\n recordSmall: register('record-small', 0xebfa),\n errorSmall: register('error-small', 0xebfb),\n arrowCircleDown: register('arrow-circle-down', 0xebfc),\n arrowCircleLeft: register('arrow-circle-left', 0xebfd),\n arrowCircleRight: register('arrow-circle-right', 0xebfe),\n arrowCircleUp: register('arrow-circle-up', 0xebff),\n heartFilled: register('heart-filled', 0xec04),\n map: register('map', 0xec05),\n mapFilled: register('map-filled', 0xec06),\n circleSmall: register('circle-small', 0xec07),\n bellSlash: register('bell-slash', 0xec08),\n bellSlashDot: register('bell-slash-dot', 0xec09),\n commentUnresolved: register('comment-unresolved', 0xec0a),\n gitPullRequestGoToChanges: register('git-pull-request-go-to-changes', 0xec0b),\n gitPullRequestNewChanges: register('git-pull-request-new-changes', 0xec0c),\n searchFuzzy: register('search-fuzzy', 0xec0d),\n commentDraft: register('comment-draft', 0xec0e),\n send: register('send', 0xec0f),\n sparkle: register('sparkle', 0xec10),\n insert: register('insert', 0xec11),\n mic: register('mic', 0xec12),\n thumbsDownFilled: register('thumbsdown-filled', 0xec13),\n thumbsUpFilled: register('thumbsup-filled', 0xec14),\n coffee: register('coffee', 0xec15),\n snake: register('snake', 0xec16),\n game: register('game', 0xec17),\n vr: register('vr', 0xec18),\n chip: register('chip', 0xec19),\n piano: register('piano', 0xec1a),\n music: register('music', 0xec1b),\n micFilled: register('mic-filled', 0xec1c),\n gitFetch: register('git-fetch', 0xec1d),\n copilot: register('copilot', 0xec1e),\n lightbulbSparkle: register('lightbulb-sparkle', 0xec1f),\n lightbulbSparkleAutofix: register('lightbulb-sparkle-autofix', 0xec1f),\n robot: register('robot', 0xec20),\n sparkleFilled: register('sparkle-filled', 0xec21),\n diffSingle: register('diff-single', 0xec22),\n diffMultiple: register('diff-multiple', 0xec23),\n // derived icons, that could become separate icons\n dialogError: register('dialog-error', 'error'),\n dialogWarning: register('dialog-warning', 'warning'),\n dialogInfo: register('dialog-info', 'info'),\n dialogClose: register('dialog-close', 'close'),\n treeItemExpanded: register('tree-item-expanded', 'chevron-down'), // collapsed is done with rotation\n treeFilterOnTypeOn: register('tree-filter-on-type-on', 'list-filter'),\n treeFilterOnTypeOff: register('tree-filter-on-type-off', 'list-selection'),\n treeFilterClear: register('tree-filter-clear', 'close'),\n treeItemLoading: register('tree-item-loading', 'loading'),\n menuSelection: register('menu-selection', 'check'),\n menuSubmenu: register('menu-submenu', 'chevron-right'),\n menuBarMore: register('menubar-more', 'more'),\n scrollbarButtonLeft: register('scrollbar-button-left', 'triangle-left'),\n scrollbarButtonRight: register('scrollbar-button-right', 'triangle-right'),\n scrollbarButtonUp: register('scrollbar-button-up', 'triangle-up'),\n scrollbarButtonDown: register('scrollbar-button-down', 'triangle-down'),\n toolBarMore: register('toolbar-more', 'more'),\n quickInputBack: register('quick-input-back', 'arrow-left')\n};\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nfunction roundFloat(number, decimalPoints) {\n const decimal = Math.pow(10, decimalPoints);\n return Math.round(number * decimal) / decimal;\n}\nexport class RGBA {\n constructor(r, g, b, a = 1) {\n this._rgbaBrand = undefined;\n this.r = Math.min(255, Math.max(0, r)) | 0;\n this.g = Math.min(255, Math.max(0, g)) | 0;\n this.b = Math.min(255, Math.max(0, b)) | 0;\n this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);\n }\n static equals(a, b) {\n return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;\n }\n}\nexport class HSLA {\n constructor(h, s, l, a) {\n this._hslaBrand = undefined;\n this.h = Math.max(Math.min(360, h), 0) | 0;\n this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);\n this.l = roundFloat(Math.max(Math.min(1, l), 0), 3);\n this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);\n }\n static equals(a, b) {\n return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a;\n }\n /**\n * Converts an RGB color value to HSL. Conversion formula\n * adapted from http://en.wikipedia.org/wiki/HSL_color_space.\n * Assumes r, g, and b are contained in the set [0, 255] and\n * returns h in the set [0, 360], s, and l in the set [0, 1].\n */\n static fromRGBA(rgba) {\n const r = rgba.r / 255;\n const g = rgba.g / 255;\n const b = rgba.b / 255;\n const a = rgba.a;\n const max = Math.max(r, g, b);\n const min = Math.min(r, g, b);\n let h = 0;\n let s = 0;\n const l = (min + max) / 2;\n const chroma = max - min;\n if (chroma > 0) {\n s = Math.min((l <= 0.5 ? chroma / (2 * l) : chroma / (2 - (2 * l))), 1);\n switch (max) {\n case r:\n h = (g - b) / chroma + (g < b ? 6 : 0);\n break;\n case g:\n h = (b - r) / chroma + 2;\n break;\n case b:\n h = (r - g) / chroma + 4;\n break;\n }\n h *= 60;\n h = Math.round(h);\n }\n return new HSLA(h, s, l, a);\n }\n static _hue2rgb(p, q, t) {\n if (t < 0) {\n t += 1;\n }\n if (t > 1) {\n t -= 1;\n }\n if (t < 1 / 6) {\n return p + (q - p) * 6 * t;\n }\n if (t < 1 / 2) {\n return q;\n }\n if (t < 2 / 3) {\n return p + (q - p) * (2 / 3 - t) * 6;\n }\n return p;\n }\n /**\n * Converts an HSL color value to RGB. Conversion formula\n * adapted from http://en.wikipedia.org/wiki/HSL_color_space.\n * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and\n * returns r, g, and b in the set [0, 255].\n */\n static toRGBA(hsla) {\n const h = hsla.h / 360;\n const { s, l, a } = hsla;\n let r, g, b;\n if (s === 0) {\n r = g = b = l; // achromatic\n }\n else {\n const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n const p = 2 * l - q;\n r = HSLA._hue2rgb(p, q, h + 1 / 3);\n g = HSLA._hue2rgb(p, q, h);\n b = HSLA._hue2rgb(p, q, h - 1 / 3);\n }\n return new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);\n }\n}\nexport class HSVA {\n constructor(h, s, v, a) {\n this._hsvaBrand = undefined;\n this.h = Math.max(Math.min(360, h), 0) | 0;\n this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);\n this.v = roundFloat(Math.max(Math.min(1, v), 0), 3);\n this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);\n }\n static equals(a, b) {\n return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a;\n }\n // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm\n static fromRGBA(rgba) {\n const r = rgba.r / 255;\n const g = rgba.g / 255;\n const b = rgba.b / 255;\n const cmax = Math.max(r, g, b);\n const cmin = Math.min(r, g, b);\n const delta = cmax - cmin;\n const s = cmax === 0 ? 0 : (delta / cmax);\n let m;\n if (delta === 0) {\n m = 0;\n }\n else if (cmax === r) {\n m = ((((g - b) / delta) % 6) + 6) % 6;\n }\n else if (cmax === g) {\n m = ((b - r) / delta) + 2;\n }\n else {\n m = ((r - g) / delta) + 4;\n }\n return new HSVA(Math.round(m * 60), s, cmax, rgba.a);\n }\n // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm\n static toRGBA(hsva) {\n const { h, s, v, a } = hsva;\n const c = v * s;\n const x = c * (1 - Math.abs((h / 60) % 2 - 1));\n const m = v - c;\n let [r, g, b] = [0, 0, 0];\n if (h < 60) {\n r = c;\n g = x;\n }\n else if (h < 120) {\n r = x;\n g = c;\n }\n else if (h < 180) {\n g = c;\n b = x;\n }\n else if (h < 240) {\n g = x;\n b = c;\n }\n else if (h < 300) {\n r = x;\n b = c;\n }\n else if (h <= 360) {\n r = c;\n b = x;\n }\n r = Math.round((r + m) * 255);\n g = Math.round((g + m) * 255);\n b = Math.round((b + m) * 255);\n return new RGBA(r, g, b, a);\n }\n}\nexport class Color {\n static fromHex(hex) {\n return Color.Format.CSS.parseHex(hex) || Color.red;\n }\n static equals(a, b) {\n if (!a && !b) {\n return true;\n }\n if (!a || !b) {\n return false;\n }\n return a.equals(b);\n }\n get hsla() {\n if (this._hsla) {\n return this._hsla;\n }\n else {\n return HSLA.fromRGBA(this.rgba);\n }\n }\n get hsva() {\n if (this._hsva) {\n return this._hsva;\n }\n return HSVA.fromRGBA(this.rgba);\n }\n constructor(arg) {\n if (!arg) {\n throw new Error('Color needs a value');\n }\n else if (arg instanceof RGBA) {\n this.rgba = arg;\n }\n else if (arg instanceof HSLA) {\n this._hsla = arg;\n this.rgba = HSLA.toRGBA(arg);\n }\n else if (arg instanceof HSVA) {\n this._hsva = arg;\n this.rgba = HSVA.toRGBA(arg);\n }\n else {\n throw new Error('Invalid color ctor argument');\n }\n }\n equals(other) {\n return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);\n }\n /**\n * http://www.w3.org/TR/WCAG20/#relativeluminancedef\n * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.\n */\n getRelativeLuminance() {\n const R = Color._relativeLuminanceForComponent(this.rgba.r);\n const G = Color._relativeLuminanceForComponent(this.rgba.g);\n const B = Color._relativeLuminanceForComponent(this.rgba.b);\n const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B;\n return roundFloat(luminance, 4);\n }\n static _relativeLuminanceForComponent(color) {\n const c = color / 255;\n return (c <= 0.03928) ? c / 12.92 : Math.pow(((c + 0.055) / 1.055), 2.4);\n }\n /**\n *\thttp://24ways.org/2010/calculating-color-contrast\n * Return 'true' if lighter color otherwise 'false'\n */\n isLighter() {\n const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;\n return yiq >= 128;\n }\n isLighterThan(another) {\n const lum1 = this.getRelativeLuminance();\n const lum2 = another.getRelativeLuminance();\n return lum1 > lum2;\n }\n isDarkerThan(another) {\n const lum1 = this.getRelativeLuminance();\n const lum2 = another.getRelativeLuminance();\n return lum1 < lum2;\n }\n lighten(factor) {\n return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a));\n }\n darken(factor) {\n return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a));\n }\n transparent(factor) {\n const { r, g, b, a } = this.rgba;\n return new Color(new RGBA(r, g, b, a * factor));\n }\n isTransparent() {\n return this.rgba.a === 0;\n }\n isOpaque() {\n return this.rgba.a === 1;\n }\n opposite() {\n return new Color(new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a));\n }\n makeOpaque(opaqueBackground) {\n if (this.isOpaque() || opaqueBackground.rgba.a !== 1) {\n // only allow to blend onto a non-opaque color onto a opaque color\n return this;\n }\n const { r, g, b, a } = this.rgba;\n // https://stackoverflow.com/questions/12228548/finding-equivalent-color-with-opacity\n return new Color(new RGBA(opaqueBackground.rgba.r - a * (opaqueBackground.rgba.r - r), opaqueBackground.rgba.g - a * (opaqueBackground.rgba.g - g), opaqueBackground.rgba.b - a * (opaqueBackground.rgba.b - b), 1));\n }\n toString() {\n if (!this._toString) {\n this._toString = Color.Format.CSS.format(this);\n }\n return this._toString;\n }\n static getLighterColor(of, relative, factor) {\n if (of.isLighterThan(relative)) {\n return of;\n }\n factor = factor ? factor : 0.5;\n const lum1 = of.getRelativeLuminance();\n const lum2 = relative.getRelativeLuminance();\n factor = factor * (lum2 - lum1) / lum2;\n return of.lighten(factor);\n }\n static getDarkerColor(of, relative, factor) {\n if (of.isDarkerThan(relative)) {\n return of;\n }\n factor = factor ? factor : 0.5;\n const lum1 = of.getRelativeLuminance();\n const lum2 = relative.getRelativeLuminance();\n factor = factor * (lum1 - lum2) / lum1;\n return of.darken(factor);\n }\n}\nColor.white = new Color(new RGBA(255, 255, 255, 1));\nColor.black = new Color(new RGBA(0, 0, 0, 1));\nColor.red = new Color(new RGBA(255, 0, 0, 1));\nColor.blue = new Color(new RGBA(0, 0, 255, 1));\nColor.green = new Color(new RGBA(0, 255, 0, 1));\nColor.cyan = new Color(new RGBA(0, 255, 255, 1));\nColor.lightgrey = new Color(new RGBA(211, 211, 211, 1));\nColor.transparent = new Color(new RGBA(0, 0, 0, 0));\n(function (Color) {\n let Format;\n (function (Format) {\n let CSS;\n (function (CSS) {\n function formatRGB(color) {\n if (color.rgba.a === 1) {\n return `rgb(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b})`;\n }\n return Color.Format.CSS.formatRGBA(color);\n }\n CSS.formatRGB = formatRGB;\n function formatRGBA(color) {\n return `rgba(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b}, ${+(color.rgba.a).toFixed(2)})`;\n }\n CSS.formatRGBA = formatRGBA;\n function formatHSL(color) {\n if (color.hsla.a === 1) {\n return `hsl(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%)`;\n }\n return Color.Format.CSS.formatHSLA(color);\n }\n CSS.formatHSL = formatHSL;\n function formatHSLA(color) {\n return `hsla(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%, ${color.hsla.a.toFixed(2)})`;\n }\n CSS.formatHSLA = formatHSLA;\n function _toTwoDigitHex(n) {\n const r = n.toString(16);\n return r.length !== 2 ? '0' + r : r;\n }\n /**\n * Formats the color as #RRGGBB\n */\n function formatHex(color) {\n return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}`;\n }\n CSS.formatHex = formatHex;\n /**\n * Formats the color as #RRGGBBAA\n * If 'compact' is set, colors without transparancy will be printed as #RRGGBB\n */\n function formatHexA(color, compact = false) {\n if (compact && color.rgba.a === 1) {\n return Color.Format.CSS.formatHex(color);\n }\n return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}${_toTwoDigitHex(Math.round(color.rgba.a * 255))}`;\n }\n CSS.formatHexA = formatHexA;\n /**\n * The default format will use HEX if opaque and RGBA otherwise.\n */\n function format(color) {\n if (color.isOpaque()) {\n return Color.Format.CSS.formatHex(color);\n }\n return Color.Format.CSS.formatRGBA(color);\n }\n CSS.format = format;\n /**\n * Converts an Hex color value to a Color.\n * returns r, g, and b are contained in the set [0, 255]\n * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).\n */\n function parseHex(hex) {\n const length = hex.length;\n if (length === 0) {\n // Invalid color\n return null;\n }\n if (hex.charCodeAt(0) !== 35 /* CharCode.Hash */) {\n // Does not begin with a #\n return null;\n }\n if (length === 7) {\n // #RRGGBB format\n const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));\n const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));\n const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));\n return new Color(new RGBA(r, g, b, 1));\n }\n if (length === 9) {\n // #RRGGBBAA format\n const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));\n const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));\n const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));\n const a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8));\n return new Color(new RGBA(r, g, b, a / 255));\n }\n if (length === 4) {\n // #RGB format\n const r = _parseHexDigit(hex.charCodeAt(1));\n const g = _parseHexDigit(hex.charCodeAt(2));\n const b = _parseHexDigit(hex.charCodeAt(3));\n return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b));\n }\n if (length === 5) {\n // #RGBA format\n const r = _parseHexDigit(hex.charCodeAt(1));\n const g = _parseHexDigit(hex.charCodeAt(2));\n const b = _parseHexDigit(hex.charCodeAt(3));\n const a = _parseHexDigit(hex.charCodeAt(4));\n return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255));\n }\n // Invalid color\n return null;\n }\n CSS.parseHex = parseHex;\n function _parseHexDigit(charCode) {\n switch (charCode) {\n case 48 /* CharCode.Digit0 */: return 0;\n case 49 /* CharCode.Digit1 */: return 1;\n case 50 /* CharCode.Digit2 */: return 2;\n case 51 /* CharCode.Digit3 */: return 3;\n case 52 /* CharCode.Digit4 */: return 4;\n case 53 /* CharCode.Digit5 */: return 5;\n case 54 /* CharCode.Digit6 */: return 6;\n case 55 /* CharCode.Digit7 */: return 7;\n case 56 /* CharCode.Digit8 */: return 8;\n case 57 /* CharCode.Digit9 */: return 9;\n case 97 /* CharCode.a */: return 10;\n case 65 /* CharCode.A */: return 10;\n case 98 /* CharCode.b */: return 11;\n case 66 /* CharCode.B */: return 11;\n case 99 /* CharCode.c */: return 12;\n case 67 /* CharCode.C */: return 12;\n case 100 /* CharCode.d */: return 13;\n case 68 /* CharCode.D */: return 13;\n case 101 /* CharCode.e */: return 14;\n case 69 /* CharCode.E */: return 14;\n case 102 /* CharCode.f */: return 15;\n case 70 /* CharCode.F */: return 15;\n }\n return 0;\n }\n })(CSS = Format.CSS || (Format.CSS = {}));\n })(Format = Color.Format || (Color.Format = {}));\n})(Color || (Color = {}));\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { DiffChange } from './diffChange.js';\nimport { stringHash } from '../hash.js';\nexport class StringDiffSequence {\n constructor(source) {\n this.source = source;\n }\n getElements() {\n const source = this.source;\n const characters = new Int32Array(source.length);\n for (let i = 0, len = source.length; i < len; i++) {\n characters[i] = source.charCodeAt(i);\n }\n return characters;\n }\n}\nexport function stringDiff(original, modified, pretty) {\n return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes;\n}\n//\n// The code below has been ported from a C# implementation in VS\n//\nclass Debug {\n static Assert(condition, message) {\n if (!condition) {\n throw new Error(message);\n }\n }\n}\nclass MyArray {\n /**\n * Copies a range of elements from an Array starting at the specified source index and pastes\n * them to another Array starting at the specified destination index. The length and the indexes\n * are specified as 64-bit integers.\n * sourceArray:\n *\t\tThe Array that contains the data to copy.\n * sourceIndex:\n *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\n * destinationArray:\n *\t\tThe Array that receives the data.\n * destinationIndex:\n *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\n * length:\n *\t\tA 64-bit integer that represents the number of elements to copy.\n */\n static Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n for (let i = 0; i < length; i++) {\n destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n }\n }\n static Copy2(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n for (let i = 0; i < length; i++) {\n destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n }\n }\n}\n/**\n * A utility class which helps to create the set of DiffChanges from\n * a difference operation. This class accepts original DiffElements and\n * modified DiffElements that are involved in a particular change. The\n * MarkNextChange() method can be called to mark the separation between\n * distinct changes. At the end, the Changes property can be called to retrieve\n * the constructed changes.\n */\nclass DiffChangeHelper {\n /**\n * Constructs a new DiffChangeHelper for the given DiffSequences.\n */\n constructor() {\n this.m_changes = [];\n this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n this.m_originalCount = 0;\n this.m_modifiedCount = 0;\n }\n /**\n * Marks the beginning of the next change in the set of differences.\n */\n MarkNextChange() {\n // Only add to the list if there is something to add\n if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n // Add the new change to our list\n this.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));\n }\n // Reset for the next change\n this.m_originalCount = 0;\n this.m_modifiedCount = 0;\n this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n }\n /**\n * Adds the original element at the given position to the elements\n * affected by the current change. The modified index gives context\n * to the change position with respect to the original sequence.\n * @param originalIndex The index of the original element to add.\n * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\n */\n AddOriginalElement(originalIndex, modifiedIndex) {\n // The 'true' start index is the smallest of the ones we've seen\n this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n this.m_originalCount++;\n }\n /**\n * Adds the modified element at the given position to the elements\n * affected by the current change. The original index gives context\n * to the change position with respect to the modified sequence.\n * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\n * @param modifiedIndex The index of the modified element to add.\n */\n AddModifiedElement(originalIndex, modifiedIndex) {\n // The 'true' start index is the smallest of the ones we've seen\n this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n this.m_modifiedCount++;\n }\n /**\n * Retrieves all of the changes marked by the class.\n */\n getChanges() {\n if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n // Finish up on whatever is left\n this.MarkNextChange();\n }\n return this.m_changes;\n }\n /**\n * Retrieves all of the changes marked by the class in the reverse order\n */\n getReverseChanges() {\n if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n // Finish up on whatever is left\n this.MarkNextChange();\n }\n this.m_changes.reverse();\n return this.m_changes;\n }\n}\n/**\n * An implementation of the difference algorithm described in\n * \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n */\nexport class LcsDiff {\n /**\n * Constructs the DiffFinder\n */\n constructor(originalSequence, modifiedSequence, continueProcessingPredicate = null) {\n this.ContinueProcessingPredicate = continueProcessingPredicate;\n this._originalSequence = originalSequence;\n this._modifiedSequence = modifiedSequence;\n const [originalStringElements, originalElementsOrHash, originalHasStrings] = LcsDiff._getElements(originalSequence);\n const [modifiedStringElements, modifiedElementsOrHash, modifiedHasStrings] = LcsDiff._getElements(modifiedSequence);\n this._hasStrings = (originalHasStrings && modifiedHasStrings);\n this._originalStringElements = originalStringElements;\n this._originalElementsOrHash = originalElementsOrHash;\n this._modifiedStringElements = modifiedStringElements;\n this._modifiedElementsOrHash = modifiedElementsOrHash;\n this.m_forwardHistory = [];\n this.m_reverseHistory = [];\n }\n static _isStringArray(arr) {\n return (arr.length > 0 && typeof arr[0] === 'string');\n }\n static _getElements(sequence) {\n const elements = sequence.getElements();\n if (LcsDiff._isStringArray(elements)) {\n const hashes = new Int32Array(elements.length);\n for (let i = 0, len = elements.length; i < len; i++) {\n hashes[i] = stringHash(elements[i], 0);\n }\n return [elements, hashes, true];\n }\n if (elements instanceof Int32Array) {\n return [[], elements, false];\n }\n return [[], new Int32Array(elements), false];\n }\n ElementsAreEqual(originalIndex, newIndex) {\n if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) {\n return false;\n }\n return (this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true);\n }\n ElementsAreStrictEqual(originalIndex, newIndex) {\n if (!this.ElementsAreEqual(originalIndex, newIndex)) {\n return false;\n }\n const originalElement = LcsDiff._getStrictElement(this._originalSequence, originalIndex);\n const modifiedElement = LcsDiff._getStrictElement(this._modifiedSequence, newIndex);\n return (originalElement === modifiedElement);\n }\n static _getStrictElement(sequence, index) {\n if (typeof sequence.getStrictElement === 'function') {\n return sequence.getStrictElement(index);\n }\n return null;\n }\n OriginalElementsAreEqual(index1, index2) {\n if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) {\n return false;\n }\n return (this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true);\n }\n ModifiedElementsAreEqual(index1, index2) {\n if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) {\n return false;\n }\n return (this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true);\n }\n ComputeDiff(pretty) {\n return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty);\n }\n /**\n * Computes the differences between the original and modified input\n * sequences on the bounded range.\n * @returns An array of the differences between the two input sequences.\n */\n _ComputeDiff(originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {\n const quitEarlyArr = [false];\n let changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\n if (pretty) {\n // We have to clean up the computed diff to be more intuitive\n // but it turns out this cannot be done correctly until the entire set\n // of diffs have been computed\n changes = this.PrettifyChanges(changes);\n }\n return {\n quitEarly: quitEarlyArr[0],\n changes: changes\n };\n }\n /**\n * Private helper method which computes the differences on the bounded range\n * recursively.\n * @returns An array of the differences between the two input sequences.\n */\n ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {\n quitEarlyArr[0] = false;\n // Find the start of the differences\n while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\n originalStart++;\n modifiedStart++;\n }\n // Find the end of the differences\n while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\n originalEnd--;\n modifiedEnd--;\n }\n // In the special case where we either have all insertions or all deletions or the sequences are identical\n if (originalStart > originalEnd || modifiedStart > modifiedEnd) {\n let changes;\n if (modifiedStart <= modifiedEnd) {\n Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n // All insertions\n changes = [\n new DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\n ];\n }\n else if (originalStart <= originalEnd) {\n Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n // All deletions\n changes = [\n new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\n ];\n }\n else {\n Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n // Identical sequences - No differences\n changes = [];\n }\n return changes;\n }\n // This problem can be solved using the Divide-And-Conquer technique.\n const midOriginalArr = [0];\n const midModifiedArr = [0];\n const result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\n const midOriginal = midOriginalArr[0];\n const midModified = midModifiedArr[0];\n if (result !== null) {\n // Result is not-null when there was enough memory to compute the changes while\n // searching for the recursion point\n return result;\n }\n else if (!quitEarlyArr[0]) {\n // We can break the problem down recursively by finding the changes in the\n // First Half: (originalStart, modifiedStart) to (midOriginal, midModified)\n // Second Half: (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\n // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\n const leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\n let rightChanges = [];\n if (!quitEarlyArr[0]) {\n rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\n }\n else {\n // We didn't have time to finish the first half, so we don't have time to compute this half.\n // Consider the entire rest of the sequence different.\n rightChanges = [\n new DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\n ];\n }\n return this.ConcatenateChanges(leftChanges, rightChanges);\n }\n // If we hit here, we quit early, and so can't return anything meaningful\n return [\n new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n ];\n }\n WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {\n let forwardChanges = null;\n let reverseChanges = null;\n // First, walk backward through the forward diagonals history\n let changeHelper = new DiffChangeHelper();\n let diagonalMin = diagonalForwardStart;\n let diagonalMax = diagonalForwardEnd;\n let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\n let lastOriginalIndex = -1073741824 /* Constants.MIN_SAFE_SMALL_INTEGER */;\n let historyIndex = this.m_forwardHistory.length - 1;\n do {\n // Get the diagonal index from the relative diagonal number\n const diagonal = diagonalRelative + diagonalForwardBase;\n // Figure out where we came from\n if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n // Vertical line (the element is an insert)\n originalIndex = forwardPoints[diagonal + 1];\n modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n if (originalIndex < lastOriginalIndex) {\n changeHelper.MarkNextChange();\n }\n lastOriginalIndex = originalIndex;\n changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\n diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\n }\n else {\n // Horizontal line (the element is a deletion)\n originalIndex = forwardPoints[diagonal - 1] + 1;\n modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n if (originalIndex < lastOriginalIndex) {\n changeHelper.MarkNextChange();\n }\n lastOriginalIndex = originalIndex - 1;\n changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\n diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\n }\n if (historyIndex >= 0) {\n forwardPoints = this.m_forwardHistory[historyIndex];\n diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\n diagonalMin = 1;\n diagonalMax = forwardPoints.length - 1;\n }\n } while (--historyIndex >= -1);\n // Ironically, we get the forward changes as the reverse of the\n // order we added them since we technically added them backwards\n forwardChanges = changeHelper.getReverseChanges();\n if (quitEarlyArr[0]) {\n // TODO: Calculate a partial from the reverse diagonals.\n // For now, just assume everything after the midOriginal/midModified point is a diff\n let originalStartPoint = midOriginalArr[0] + 1;\n let modifiedStartPoint = midModifiedArr[0] + 1;\n if (forwardChanges !== null && forwardChanges.length > 0) {\n const lastForwardChange = forwardChanges[forwardChanges.length - 1];\n originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\n modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\n }\n reverseChanges = [\n new DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\n ];\n }\n else {\n // Now walk backward through the reverse diagonals history\n changeHelper = new DiffChangeHelper();\n diagonalMin = diagonalReverseStart;\n diagonalMax = diagonalReverseEnd;\n diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\n lastOriginalIndex = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\n do {\n // Get the diagonal index from the relative diagonal number\n const diagonal = diagonalRelative + diagonalReverseBase;\n // Figure out where we came from\n if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n // Horizontal line (the element is a deletion))\n originalIndex = reversePoints[diagonal + 1] - 1;\n modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n if (originalIndex > lastOriginalIndex) {\n changeHelper.MarkNextChange();\n }\n lastOriginalIndex = originalIndex + 1;\n changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\n diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\n }\n else {\n // Vertical line (the element is an insertion)\n originalIndex = reversePoints[diagonal - 1];\n modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n if (originalIndex > lastOriginalIndex) {\n changeHelper.MarkNextChange();\n }\n lastOriginalIndex = originalIndex;\n changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\n diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\n }\n if (historyIndex >= 0) {\n reversePoints = this.m_reverseHistory[historyIndex];\n diagonalReverseBase = reversePoints[0]; //We stored this in the first spot\n diagonalMin = 1;\n diagonalMax = reversePoints.length - 1;\n }\n } while (--historyIndex >= -1);\n // There are cases where the reverse history will find diffs that\n // are correct, but not intuitive, so we need shift them.\n reverseChanges = changeHelper.getChanges();\n }\n return this.ConcatenateChanges(forwardChanges, reverseChanges);\n }\n /**\n * Given the range to compute the diff on, this method finds the point:\n * (midOriginal, midModified)\n * that exists in the middle of the LCS of the two sequences and\n * is the point at which the LCS problem may be broken down recursively.\n * This method will try to keep the LCS trace in memory. If the LCS recursion\n * point is calculated and the full trace is available in memory, then this method\n * will return the change list.\n * @param originalStart The start bound of the original sequence range\n * @param originalEnd The end bound of the original sequence range\n * @param modifiedStart The start bound of the modified sequence range\n * @param modifiedEnd The end bound of the modified sequence range\n * @param midOriginal The middle point of the original sequence range\n * @param midModified The middle point of the modified sequence range\n * @returns The diff changes, if available, otherwise null\n */\n ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {\n let originalIndex = 0, modifiedIndex = 0;\n let diagonalForwardStart = 0, diagonalForwardEnd = 0;\n let diagonalReverseStart = 0, diagonalReverseEnd = 0;\n // To traverse the edit graph and produce the proper LCS, our actual\n // start position is just outside the given boundary\n originalStart--;\n modifiedStart--;\n // We set these up to make the compiler happy, but they will\n // be replaced before we return with the actual recursion point\n midOriginalArr[0] = 0;\n midModifiedArr[0] = 0;\n // Clear out the history\n this.m_forwardHistory = [];\n this.m_reverseHistory = [];\n // Each cell in the two arrays corresponds to a diagonal in the edit graph.\n // The integer value in the cell represents the originalIndex of the furthest\n // reaching point found so far that ends in that diagonal.\n // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\n const maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\n const numDiagonals = maxDifferences + 1;\n const forwardPoints = new Int32Array(numDiagonals);\n const reversePoints = new Int32Array(numDiagonals);\n // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\n // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\n const diagonalForwardBase = (modifiedEnd - modifiedStart);\n const diagonalReverseBase = (originalEnd - originalStart);\n // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n // diagonal number (relative to diagonalForwardBase)\n // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n // diagonal number (relative to diagonalReverseBase)\n const diagonalForwardOffset = (originalStart - modifiedStart);\n const diagonalReverseOffset = (originalEnd - modifiedEnd);\n // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\n // relative to the start diagonal with diagonal numbers relative to the end diagonal.\n // The Even/Oddn-ness of this delta is important for determining when we should check for overlap\n const delta = diagonalReverseBase - diagonalForwardBase;\n const deltaIsEven = (delta % 2 === 0);\n // Here we set up the start and end points as the furthest points found so far\n // in both the forward and reverse directions, respectively\n forwardPoints[diagonalForwardBase] = originalStart;\n reversePoints[diagonalReverseBase] = originalEnd;\n // Remember if we quit early, and thus need to do a best-effort result instead of a real result.\n quitEarlyArr[0] = false;\n // A couple of points:\n // --With this method, we iterate on the number of differences between the two sequences.\n // The more differences there actually are, the longer this will take.\n // --Also, as the number of differences increases, we have to search on diagonals further\n // away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\n // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\n // is even and odd diagonals only when numDifferences is odd.\n for (let numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\n let furthestOriginalIndex = 0;\n let furthestModifiedIndex = 0;\n // Run the algorithm in the forward direction\n diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n for (let diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\n // STEP 1: We extend the furthest reaching point in the present diagonal\n // by looking at the diagonals above and below and picking the one whose point\n // is further away from the start point (originalStart, modifiedStart)\n if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n originalIndex = forwardPoints[diagonal + 1];\n }\n else {\n originalIndex = forwardPoints[diagonal - 1] + 1;\n }\n modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\n // Save the current originalIndex so we can test for false overlap in step 3\n const tempOriginalIndex = originalIndex;\n // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n // so long as the elements are equal.\n while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\n originalIndex++;\n modifiedIndex++;\n }\n forwardPoints[diagonal] = originalIndex;\n if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\n furthestOriginalIndex = originalIndex;\n furthestModifiedIndex = modifiedIndex;\n }\n // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\n // and diagonal is in the range of reverse diagonals computed for numDifferences-1\n // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\n // then check for overlap.\n if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\n if (originalIndex >= reversePoints[diagonal]) {\n midOriginalArr[0] = originalIndex;\n midModifiedArr[0] = modifiedIndex;\n if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {\n // BINGO! We overlapped, and we have the full trace in memory!\n return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n }\n else {\n // Either false overlap, or we didn't have enough memory for the full trace\n // Just return the recursion point\n return null;\n }\n }\n }\n }\n // Check to see if we should be quitting early, before moving on to the next iteration.\n const matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\n if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) {\n // We can't finish, so skip ahead to generating a result from what we have.\n quitEarlyArr[0] = true;\n // Use the furthest distance we got in the forward direction.\n midOriginalArr[0] = furthestOriginalIndex;\n midModifiedArr[0] = furthestModifiedIndex;\n if (matchLengthOfLongest > 0 && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {\n // Enough of the history is in memory to walk it backwards\n return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n }\n else {\n // We didn't actually remember enough of the history.\n //Since we are quitting the diff early, we need to shift back the originalStart and modified start\n //back into the boundary limits since we decremented their value above beyond the boundary limit.\n originalStart++;\n modifiedStart++;\n return [\n new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n ];\n }\n }\n // Run the algorithm in the reverse direction\n diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n for (let diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\n // STEP 1: We extend the furthest reaching point in the present diagonal\n // by looking at the diagonals above and below and picking the one whose point\n // is further away from the start point (originalEnd, modifiedEnd)\n if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n originalIndex = reversePoints[diagonal + 1] - 1;\n }\n else {\n originalIndex = reversePoints[diagonal - 1];\n }\n modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\n // Save the current originalIndex so we can test for false overlap\n const tempOriginalIndex = originalIndex;\n // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n // as long as the elements are equal.\n while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\n originalIndex--;\n modifiedIndex--;\n }\n reversePoints[diagonal] = originalIndex;\n // STEP 4: If delta is even (overlap first happens on reverse when delta is even)\n // and diagonal is in the range of forward diagonals computed for numDifferences\n // then check for overlap.\n if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\n if (originalIndex <= forwardPoints[diagonal]) {\n midOriginalArr[0] = originalIndex;\n midModifiedArr[0] = modifiedIndex;\n if (tempOriginalIndex >= forwardPoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {\n // BINGO! We overlapped, and we have the full trace in memory!\n return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n }\n else {\n // Either false overlap, or we didn't have enough memory for the full trace\n // Just return the recursion point\n return null;\n }\n }\n }\n }\n // Save current vectors to history before the next iteration\n if (numDifferences <= 1447 /* LocalConstants.MaxDifferencesHistory */) {\n // We are allocating space for one extra int, which we fill with\n // the index of the diagonal base index\n let temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2);\n temp[0] = diagonalForwardBase - diagonalForwardStart + 1;\n MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\n this.m_forwardHistory.push(temp);\n temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2);\n temp[0] = diagonalReverseBase - diagonalReverseStart + 1;\n MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\n this.m_reverseHistory.push(temp);\n }\n }\n // If we got here, then we have the full trace in history. We just have to convert it to a change list\n // NOTE: This part is a bit messy\n return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n }\n /**\n * Shifts the given changes to provide a more intuitive diff.\n * While the first element in a diff matches the first element after the diff,\n * we shift the diff down.\n *\n * @param changes The list of changes to shift\n * @returns The shifted changes\n */\n PrettifyChanges(changes) {\n // Shift all the changes down first\n for (let i = 0; i < changes.length; i++) {\n const change = changes[i];\n const originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this._originalElementsOrHash.length;\n const modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length;\n const checkOriginal = change.originalLength > 0;\n const checkModified = change.modifiedLength > 0;\n while (change.originalStart + change.originalLength < originalStop\n && change.modifiedStart + change.modifiedLength < modifiedStop\n && (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength))\n && (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\n const startStrictEqual = this.ElementsAreStrictEqual(change.originalStart, change.modifiedStart);\n const endStrictEqual = this.ElementsAreStrictEqual(change.originalStart + change.originalLength, change.modifiedStart + change.modifiedLength);\n if (endStrictEqual && !startStrictEqual) {\n // moving the change down would create an equal change, but the elements are not strict equal\n break;\n }\n change.originalStart++;\n change.modifiedStart++;\n }\n const mergedChangeArr = [null];\n if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\n changes[i] = mergedChangeArr[0];\n changes.splice(i + 1, 1);\n i--;\n continue;\n }\n }\n // Shift changes back up until we hit empty or whitespace-only lines\n for (let i = changes.length - 1; i >= 0; i--) {\n const change = changes[i];\n let originalStop = 0;\n let modifiedStop = 0;\n if (i > 0) {\n const prevChange = changes[i - 1];\n originalStop = prevChange.originalStart + prevChange.originalLength;\n modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\n }\n const checkOriginal = change.originalLength > 0;\n const checkModified = change.modifiedLength > 0;\n let bestDelta = 0;\n let bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\n for (let delta = 1;; delta++) {\n const originalStart = change.originalStart - delta;\n const modifiedStart = change.modifiedStart - delta;\n if (originalStart < originalStop || modifiedStart < modifiedStop) {\n break;\n }\n if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\n break;\n }\n if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\n break;\n }\n const touchingPreviousChange = (originalStart === originalStop && modifiedStart === modifiedStop);\n const score = ((touchingPreviousChange ? 5 : 0)\n + this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength));\n if (score > bestScore) {\n bestScore = score;\n bestDelta = delta;\n }\n }\n change.originalStart -= bestDelta;\n change.modifiedStart -= bestDelta;\n const mergedChangeArr = [null];\n if (i > 0 && this.ChangesOverlap(changes[i - 1], changes[i], mergedChangeArr)) {\n changes[i - 1] = mergedChangeArr[0];\n changes.splice(i, 1);\n i++;\n continue;\n }\n }\n // There could be multiple longest common substrings.\n // Give preference to the ones containing longer lines\n if (this._hasStrings) {\n for (let i = 1, len = changes.length; i < len; i++) {\n const aChange = changes[i - 1];\n const bChange = changes[i];\n const matchedLength = bChange.originalStart - aChange.originalStart - aChange.originalLength;\n const aOriginalStart = aChange.originalStart;\n const bOriginalEnd = bChange.originalStart + bChange.originalLength;\n const abOriginalLength = bOriginalEnd - aOriginalStart;\n const aModifiedStart = aChange.modifiedStart;\n const bModifiedEnd = bChange.modifiedStart + bChange.modifiedLength;\n const abModifiedLength = bModifiedEnd - aModifiedStart;\n // Avoid wasting a lot of time with these searches\n if (matchedLength < 5 && abOriginalLength < 20 && abModifiedLength < 20) {\n const t = this._findBetterContiguousSequence(aOriginalStart, abOriginalLength, aModifiedStart, abModifiedLength, matchedLength);\n if (t) {\n const [originalMatchStart, modifiedMatchStart] = t;\n if (originalMatchStart !== aChange.originalStart + aChange.originalLength || modifiedMatchStart !== aChange.modifiedStart + aChange.modifiedLength) {\n // switch to another sequence that has a better score\n aChange.originalLength = originalMatchStart - aChange.originalStart;\n aChange.modifiedLength = modifiedMatchStart - aChange.modifiedStart;\n bChange.originalStart = originalMatchStart + matchedLength;\n bChange.modifiedStart = modifiedMatchStart + matchedLength;\n bChange.originalLength = bOriginalEnd - bChange.originalStart;\n bChange.modifiedLength = bModifiedEnd - bChange.modifiedStart;\n }\n }\n }\n }\n }\n return changes;\n }\n _findBetterContiguousSequence(originalStart, originalLength, modifiedStart, modifiedLength, desiredLength) {\n if (originalLength < desiredLength || modifiedLength < desiredLength) {\n return null;\n }\n const originalMax = originalStart + originalLength - desiredLength + 1;\n const modifiedMax = modifiedStart + modifiedLength - desiredLength + 1;\n let bestScore = 0;\n let bestOriginalStart = 0;\n let bestModifiedStart = 0;\n for (let i = originalStart; i < originalMax; i++) {\n for (let j = modifiedStart; j < modifiedMax; j++) {\n const score = this._contiguousSequenceScore(i, j, desiredLength);\n if (score > 0 && score > bestScore) {\n bestScore = score;\n bestOriginalStart = i;\n bestModifiedStart = j;\n }\n }\n }\n if (bestScore > 0) {\n return [bestOriginalStart, bestModifiedStart];\n }\n return null;\n }\n _contiguousSequenceScore(originalStart, modifiedStart, length) {\n let score = 0;\n for (let l = 0; l < length; l++) {\n if (!this.ElementsAreEqual(originalStart + l, modifiedStart + l)) {\n return 0;\n }\n score += this._originalStringElements[originalStart + l].length;\n }\n return score;\n }\n _OriginalIsBoundary(index) {\n if (index <= 0 || index >= this._originalElementsOrHash.length - 1) {\n return true;\n }\n return (this._hasStrings && /^\\s*$/.test(this._originalStringElements[index]));\n }\n _OriginalRegionIsBoundary(originalStart, originalLength) {\n if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\n return true;\n }\n if (originalLength > 0) {\n const originalEnd = originalStart + originalLength;\n if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\n return true;\n }\n }\n return false;\n }\n _ModifiedIsBoundary(index) {\n if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) {\n return true;\n }\n return (this._hasStrings && /^\\s*$/.test(this._modifiedStringElements[index]));\n }\n _ModifiedRegionIsBoundary(modifiedStart, modifiedLength) {\n if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\n return true;\n }\n if (modifiedLength > 0) {\n const modifiedEnd = modifiedStart + modifiedLength;\n if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\n return true;\n }\n }\n return false;\n }\n _boundaryScore(originalStart, originalLength, modifiedStart, modifiedLength) {\n const originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\n const modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\n return (originalScore + modifiedScore);\n }\n /**\n * Concatenates the two input DiffChange lists and returns the resulting\n * list.\n * @param The left changes\n * @param The right changes\n * @returns The concatenated list\n */\n ConcatenateChanges(left, right) {\n const mergedChangeArr = [];\n if (left.length === 0 || right.length === 0) {\n return (right.length > 0) ? right : left;\n }\n else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\n // Since we break the problem down recursively, it is possible that we\n // might recurse in the middle of a change thereby splitting it into\n // two changes. Here in the combining stage, we detect and fuse those\n // changes back together\n const result = new Array(left.length + right.length - 1);\n MyArray.Copy(left, 0, result, 0, left.length - 1);\n result[left.length - 1] = mergedChangeArr[0];\n MyArray.Copy(right, 1, result, left.length, right.length - 1);\n return result;\n }\n else {\n const result = new Array(left.length + right.length);\n MyArray.Copy(left, 0, result, 0, left.length);\n MyArray.Copy(right, 0, result, left.length, right.length);\n return result;\n }\n }\n /**\n * Returns true if the two changes overlap and can be merged into a single\n * change\n * @param left The left change\n * @param right The right change\n * @param mergedChange The merged change if the two overlap, null otherwise\n * @returns True if the two changes overlap\n */\n ChangesOverlap(left, right, mergedChangeArr) {\n Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\n Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\n if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n const originalStart = left.originalStart;\n let originalLength = left.originalLength;\n const modifiedStart = left.modifiedStart;\n let modifiedLength = left.modifiedLength;\n if (left.originalStart + left.originalLength >= right.originalStart) {\n originalLength = right.originalStart + right.originalLength - left.originalStart;\n }\n if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\n }\n mergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);\n return true;\n }\n else {\n mergedChangeArr[0] = null;\n return false;\n }\n }\n /**\n * Helper method used to clip a diagonal index to the range of valid\n * diagonals. This also decides whether or not the diagonal index,\n * if it exceeds the boundary, should be clipped to the boundary or clipped\n * one inside the boundary depending on the Even/Odd status of the boundary\n * and numDifferences.\n * @param diagonal The index of the diagonal to clip.\n * @param numDifferences The current number of differences being iterated upon.\n * @param diagonalBaseIndex The base reference diagonal.\n * @param numDiagonals The total number of diagonals.\n * @returns The clipped diagonal index.\n */\n ClipDiagonalBound(diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {\n if (diagonal >= 0 && diagonal < numDiagonals) {\n // Nothing to clip, its in range\n return diagonal;\n }\n // diagonalsBelow: The number of diagonals below the reference diagonal\n // diagonalsAbove: The number of diagonals above the reference diagonal\n const diagonalsBelow = diagonalBaseIndex;\n const diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\n const diffEven = (numDifferences % 2 === 0);\n if (diagonal < 0) {\n const lowerBoundEven = (diagonalsBelow % 2 === 0);\n return (diffEven === lowerBoundEven) ? 0 : 1;\n }\n else {\n const upperBoundEven = (diagonalsAbove % 2 === 0);\n return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\n }\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Represents information about a specific difference between two sequences.\n */\nexport class DiffChange {\n /**\n * Constructs a new DiffChange with the given sequence information\n * and content.\n */\n constructor(originalStart, originalLength, modifiedStart, modifiedLength) {\n //Debug.Assert(originalLength > 0 || modifiedLength > 0, \"originalLength and modifiedLength cannot both be <= 0\");\n this.originalStart = originalStart;\n this.originalLength = originalLength;\n this.modifiedStart = modifiedStart;\n this.modifiedLength = modifiedLength;\n }\n /**\n * The end point (exclusive) of the change in the original sequence.\n */\n getOriginalEnd() {\n return this.originalStart + this.originalLength;\n }\n /**\n * The end point (exclusive) of the change in the modified sequence.\n */\n getModifiedEnd() {\n return this.modifiedStart + this.modifiedLength;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// Avoid circular dependency on EventEmitter by implementing a subset of the interface.\nexport class ErrorHandler {\n constructor() {\n this.listeners = [];\n this.unexpectedErrorHandler = function (e) {\n setTimeout(() => {\n if (e.stack) {\n if (ErrorNoTelemetry.isErrorNoTelemetry(e)) {\n throw new ErrorNoTelemetry(e.message + '\\n\\n' + e.stack);\n }\n throw new Error(e.message + '\\n\\n' + e.stack);\n }\n throw e;\n }, 0);\n };\n }\n emit(e) {\n this.listeners.forEach((listener) => {\n listener(e);\n });\n }\n onUnexpectedError(e) {\n this.unexpectedErrorHandler(e);\n this.emit(e);\n }\n // For external errors, we don't want the listeners to be called\n onUnexpectedExternalError(e) {\n this.unexpectedErrorHandler(e);\n }\n}\nexport const errorHandler = new ErrorHandler();\nexport function onUnexpectedError(e) {\n // ignore errors from cancelled promises\n if (!isCancellationError(e)) {\n errorHandler.onUnexpectedError(e);\n }\n return undefined;\n}\nexport function onUnexpectedExternalError(e) {\n // ignore errors from cancelled promises\n if (!isCancellationError(e)) {\n errorHandler.onUnexpectedExternalError(e);\n }\n return undefined;\n}\nexport function transformErrorForSerialization(error) {\n if (error instanceof Error) {\n const { name, message } = error;\n const stack = error.stacktrace || error.stack;\n return {\n $isError: true,\n name,\n message,\n stack,\n noTelemetry: ErrorNoTelemetry.isErrorNoTelemetry(error)\n };\n }\n // return as is\n return error;\n}\nconst canceledName = 'Canceled';\n/**\n * Checks if the given error is a promise in canceled state\n */\nexport function isCancellationError(error) {\n if (error instanceof CancellationError) {\n return true;\n }\n return error instanceof Error && error.name === canceledName && error.message === canceledName;\n}\n// !!!IMPORTANT!!!\n// Do NOT change this class because it is also used as an API-type.\nexport class CancellationError extends Error {\n constructor() {\n super(canceledName);\n this.name = this.message;\n }\n}\n/**\n * @deprecated use {@link CancellationError `new CancellationError()`} instead\n */\nexport function canceled() {\n const error = new Error(canceledName);\n error.name = error.message;\n return error;\n}\nexport function illegalArgument(name) {\n if (name) {\n return new Error(`Illegal argument: ${name}`);\n }\n else {\n return new Error('Illegal argument');\n }\n}\nexport function illegalState(name) {\n if (name) {\n return new Error(`Illegal state: ${name}`);\n }\n else {\n return new Error('Illegal state');\n }\n}\nexport class NotSupportedError extends Error {\n constructor(message) {\n super('NotSupported');\n if (message) {\n this.message = message;\n }\n }\n}\n/**\n * Error that when thrown won't be logged in telemetry as an unhandled error.\n */\nexport class ErrorNoTelemetry extends Error {\n constructor(msg) {\n super(msg);\n this.name = 'CodeExpectedError';\n }\n static fromError(err) {\n if (err instanceof ErrorNoTelemetry) {\n return err;\n }\n const result = new ErrorNoTelemetry();\n result.message = err.message;\n result.stack = err.stack;\n return result;\n }\n static isErrorNoTelemetry(err) {\n return err.name === 'CodeExpectedError';\n }\n}\n/**\n * This error indicates a bug.\n * Do not throw this for invalid user input.\n * Only catch this error to recover gracefully from bugs.\n */\nexport class BugIndicatingError extends Error {\n constructor(message) {\n super(message || 'An unexpected bug occurred.');\n Object.setPrototypeOf(this, BugIndicatingError.prototype);\n // Because we know for sure only buggy code throws this,\n // we definitely want to break here and fix the bug.\n // eslint-disable-next-line no-debugger\n // debugger;\n }\n}\n","import { onUnexpectedError } from './errors.js';\nimport { createSingleCallFunction } from './functional.js';\nimport { combinedDisposable, Disposable, DisposableStore, toDisposable } from './lifecycle.js';\nimport { LinkedList } from './linkedList.js';\nimport { StopWatch } from './stopwatch.js';\n// -----------------------------------------------------------------------------------------------------------------------\n// Uncomment the next line to print warnings whenever an emitter with listeners is disposed. That is a sign of code smell.\n// -----------------------------------------------------------------------------------------------------------------------\nconst _enableDisposeWithListenerWarning = false;\n// _enableDisposeWithListenerWarning = Boolean(\"TRUE\"); // causes a linter warning so that it cannot be pushed\n// -----------------------------------------------------------------------------------------------------------------------\n// Uncomment the next line to print warnings whenever a snapshotted event is used repeatedly without cleanup.\n// See https://github.com/microsoft/vscode/issues/142851\n// -----------------------------------------------------------------------------------------------------------------------\nconst _enableSnapshotPotentialLeakWarning = false;\nexport var Event;\n(function (Event) {\n Event.None = () => Disposable.None;\n function _addLeakageTraceLogic(options) {\n if (_enableSnapshotPotentialLeakWarning) {\n const { onDidAddListener: origListenerDidAdd } = options;\n const stack = Stacktrace.create();\n let count = 0;\n options.onDidAddListener = () => {\n if (++count === 2) {\n console.warn('snapshotted emitter LIKELY used public and SHOULD HAVE BEEN created with DisposableStore. snapshotted here');\n stack.print();\n }\n origListenerDidAdd === null || origListenerDidAdd === void 0 ? void 0 : origListenerDidAdd();\n };\n }\n }\n /**\n * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared\n * `setTimeout`. The event is converted into a signal (`Event`) to avoid additional object creation as a\n * result of merging events and to try prevent race conditions that could arise when using related deferred and\n * non-deferred events.\n *\n * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work\n * (eg. latency of keypress to text rendered).\n *\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n *\n * @param event The event source for the new event.\n * @param disposable A disposable store to add the new EventEmitter to.\n */\n function defer(event, disposable) {\n return debounce(event, () => void 0, 0, undefined, true, undefined, disposable);\n }\n Event.defer = defer;\n /**\n * Given an event, returns another event which only fires once.\n *\n * @param event The event source for the new event.\n */\n function once(event) {\n return (listener, thisArgs = null, disposables) => {\n // we need this, in case the event fires during the listener call\n let didFire = false;\n let result = undefined;\n result = event(e => {\n if (didFire) {\n return;\n }\n else if (result) {\n result.dispose();\n }\n else {\n didFire = true;\n }\n return listener.call(thisArgs, e);\n }, null, disposables);\n if (didFire) {\n result.dispose();\n }\n return result;\n };\n }\n Event.once = once;\n /**\n * Maps an event of one type into an event of another type using a mapping function, similar to how\n * `Array.prototype.map` works.\n *\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n *\n * @param event The event source for the new event.\n * @param map The mapping function.\n * @param disposable A disposable store to add the new EventEmitter to.\n */\n function map(event, map, disposable) {\n return snapshot((listener, thisArgs = null, disposables) => event(i => listener.call(thisArgs, map(i)), null, disposables), disposable);\n }\n Event.map = map;\n /**\n * Wraps an event in another event that performs some function on the event object before firing.\n *\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n *\n * @param event The event source for the new event.\n * @param each The function to perform on the event object.\n * @param disposable A disposable store to add the new EventEmitter to.\n */\n function forEach(event, each, disposable) {\n return snapshot((listener, thisArgs = null, disposables) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables), disposable);\n }\n Event.forEach = forEach;\n function filter(event, filter, disposable) {\n return snapshot((listener, thisArgs = null, disposables) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables), disposable);\n }\n Event.filter = filter;\n /**\n * Given an event, returns the same event but typed as `Event`.\n */\n function signal(event) {\n return event;\n }\n Event.signal = signal;\n function any(...events) {\n return (listener, thisArgs = null, disposables) => {\n const disposable = combinedDisposable(...events.map(event => event(e => listener.call(thisArgs, e))));\n return addAndReturnDisposable(disposable, disposables);\n };\n }\n Event.any = any;\n /**\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n */\n function reduce(event, merge, initial, disposable) {\n let output = initial;\n return map(event, e => {\n output = merge(output, e);\n return output;\n }, disposable);\n }\n Event.reduce = reduce;\n function snapshot(event, disposable) {\n let listener;\n const options = {\n onWillAddFirstListener() {\n listener = event(emitter.fire, emitter);\n },\n onDidRemoveLastListener() {\n listener === null || listener === void 0 ? void 0 : listener.dispose();\n }\n };\n if (!disposable) {\n _addLeakageTraceLogic(options);\n }\n const emitter = new Emitter(options);\n disposable === null || disposable === void 0 ? void 0 : disposable.add(emitter);\n return emitter.event;\n }\n /**\n * Adds the IDisposable to the store if it's set, and returns it. Useful to\n * Event function implementation.\n */\n function addAndReturnDisposable(d, store) {\n if (store instanceof Array) {\n store.push(d);\n }\n else if (store) {\n store.add(d);\n }\n return d;\n }\n function debounce(event, merge, delay = 100, leading = false, flushOnListenerRemove = false, leakWarningThreshold, disposable) {\n let subscription;\n let output = undefined;\n let handle = undefined;\n let numDebouncedCalls = 0;\n let doFire;\n const options = {\n leakWarningThreshold,\n onWillAddFirstListener() {\n subscription = event(cur => {\n numDebouncedCalls++;\n output = merge(output, cur);\n if (leading && !handle) {\n emitter.fire(output);\n output = undefined;\n }\n doFire = () => {\n const _output = output;\n output = undefined;\n handle = undefined;\n if (!leading || numDebouncedCalls > 1) {\n emitter.fire(_output);\n }\n numDebouncedCalls = 0;\n };\n if (typeof delay === 'number') {\n clearTimeout(handle);\n handle = setTimeout(doFire, delay);\n }\n else {\n if (handle === undefined) {\n handle = 0;\n queueMicrotask(doFire);\n }\n }\n });\n },\n onWillRemoveListener() {\n if (flushOnListenerRemove && numDebouncedCalls > 0) {\n doFire === null || doFire === void 0 ? void 0 : doFire();\n }\n },\n onDidRemoveLastListener() {\n doFire = undefined;\n subscription.dispose();\n }\n };\n if (!disposable) {\n _addLeakageTraceLogic(options);\n }\n const emitter = new Emitter(options);\n disposable === null || disposable === void 0 ? void 0 : disposable.add(emitter);\n return emitter.event;\n }\n Event.debounce = debounce;\n /**\n * Debounces an event, firing after some delay (default=0) with an array of all event original objects.\n *\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n */\n function accumulate(event, delay = 0, disposable) {\n return Event.debounce(event, (last, e) => {\n if (!last) {\n return [e];\n }\n last.push(e);\n return last;\n }, delay, undefined, true, undefined, disposable);\n }\n Event.accumulate = accumulate;\n /**\n * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate\n * event objects from different sources do not fire the same event object.\n *\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n *\n * @param event The event source for the new event.\n * @param equals The equality condition.\n * @param disposable A disposable store to add the new EventEmitter to.\n *\n * @example\n * ```\n * // Fire only one time when a single window is opened or focused\n * Event.latch(Event.any(onDidOpenWindow, onDidFocusWindow))\n * ```\n */\n function latch(event, equals = (a, b) => a === b, disposable) {\n let firstCall = true;\n let cache;\n return filter(event, value => {\n const shouldEmit = firstCall || !equals(value, cache);\n firstCall = false;\n cache = value;\n return shouldEmit;\n }, disposable);\n }\n Event.latch = latch;\n /**\n * Splits an event whose parameter is a union type into 2 separate events for each type in the union.\n *\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n *\n * @example\n * ```\n * const event = new EventEmitter().event;\n * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);\n * ```\n *\n * @param event The event source for the new event.\n * @param isT A function that determines what event is of the first type.\n * @param disposable A disposable store to add the new EventEmitter to.\n */\n function split(event, isT, disposable) {\n return [\n Event.filter(event, isT, disposable),\n Event.filter(event, e => !isT(e), disposable),\n ];\n }\n Event.split = split;\n /**\n * Buffers an event until it has a listener attached.\n *\n * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned\n * event is accessible to \"third parties\", e.g the event is a public property. Otherwise a leaked listener on the\n * returned event causes this utility to leak a listener on the original event.\n *\n * @param event The event source for the new event.\n * @param flushAfterTimeout Determines whether to flush the buffer after a timeout immediately or after a\n * `setTimeout` when the first event listener is added.\n * @param _buffer Internal: A source event array used for tests.\n *\n * @example\n * ```\n * // Start accumulating events, when the first listener is attached, flush\n * // the event after a timeout such that multiple listeners attached before\n * // the timeout would receive the event\n * this.onInstallExtension = Event.buffer(service.onInstallExtension, true);\n * ```\n */\n function buffer(event, flushAfterTimeout = false, _buffer = [], disposable) {\n let buffer = _buffer.slice();\n let listener = event(e => {\n if (buffer) {\n buffer.push(e);\n }\n else {\n emitter.fire(e);\n }\n });\n if (disposable) {\n disposable.add(listener);\n }\n const flush = () => {\n buffer === null || buffer === void 0 ? void 0 : buffer.forEach(e => emitter.fire(e));\n buffer = null;\n };\n const emitter = new Emitter({\n onWillAddFirstListener() {\n if (!listener) {\n listener = event(e => emitter.fire(e));\n if (disposable) {\n disposable.add(listener);\n }\n }\n },\n onDidAddFirstListener() {\n if (buffer) {\n if (flushAfterTimeout) {\n setTimeout(flush);\n }\n else {\n flush();\n }\n }\n },\n onDidRemoveLastListener() {\n if (listener) {\n listener.dispose();\n }\n listener = null;\n }\n });\n if (disposable) {\n disposable.add(emitter);\n }\n return emitter.event;\n }\n Event.buffer = buffer;\n /**\n * Wraps the event in an {@link IChainableEvent}, allowing a more functional programming style.\n *\n * @example\n * ```\n * // Normal\n * const onEnterPressNormal = Event.filter(\n * Event.map(onKeyPress.event, e => new StandardKeyboardEvent(e)),\n * e.keyCode === KeyCode.Enter\n * ).event;\n *\n * // Using chain\n * const onEnterPressChain = Event.chain(onKeyPress.event, $ => $\n * .map(e => new StandardKeyboardEvent(e))\n * .filter(e => e.keyCode === KeyCode.Enter)\n * );\n * ```\n */\n function chain(event, sythensize) {\n const fn = (listener, thisArgs, disposables) => {\n const cs = sythensize(new ChainableSynthesis());\n return event(function (value) {\n const result = cs.evaluate(value);\n if (result !== HaltChainable) {\n listener.call(thisArgs, result);\n }\n }, undefined, disposables);\n };\n return fn;\n }\n Event.chain = chain;\n const HaltChainable = Symbol('HaltChainable');\n class ChainableSynthesis {\n constructor() {\n this.steps = [];\n }\n map(fn) {\n this.steps.push(fn);\n return this;\n }\n forEach(fn) {\n this.steps.push(v => {\n fn(v);\n return v;\n });\n return this;\n }\n filter(fn) {\n this.steps.push(v => fn(v) ? v : HaltChainable);\n return this;\n }\n reduce(merge, initial) {\n let last = initial;\n this.steps.push(v => {\n last = merge(last, v);\n return last;\n });\n return this;\n }\n latch(equals = (a, b) => a === b) {\n let firstCall = true;\n let cache;\n this.steps.push(value => {\n const shouldEmit = firstCall || !equals(value, cache);\n firstCall = false;\n cache = value;\n return shouldEmit ? value : HaltChainable;\n });\n return this;\n }\n evaluate(value) {\n for (const step of this.steps) {\n value = step(value);\n if (value === HaltChainable) {\n break;\n }\n }\n return value;\n }\n }\n /**\n * Creates an {@link Event} from a node event emitter.\n */\n function fromNodeEventEmitter(emitter, eventName, map = id => id) {\n const fn = (...args) => result.fire(map(...args));\n const onFirstListenerAdd = () => emitter.on(eventName, fn);\n const onLastListenerRemove = () => emitter.removeListener(eventName, fn);\n const result = new Emitter({ onWillAddFirstListener: onFirstListenerAdd, onDidRemoveLastListener: onLastListenerRemove });\n return result.event;\n }\n Event.fromNodeEventEmitter = fromNodeEventEmitter;\n /**\n * Creates an {@link Event} from a DOM event emitter.\n */\n function fromDOMEventEmitter(emitter, eventName, map = id => id) {\n const fn = (...args) => result.fire(map(...args));\n const onFirstListenerAdd = () => emitter.addEventListener(eventName, fn);\n const onLastListenerRemove = () => emitter.removeEventListener(eventName, fn);\n const result = new Emitter({ onWillAddFirstListener: onFirstListenerAdd, onDidRemoveLastListener: onLastListenerRemove });\n return result.event;\n }\n Event.fromDOMEventEmitter = fromDOMEventEmitter;\n /**\n * Creates a promise out of an event, using the {@link Event.once} helper.\n */\n function toPromise(event) {\n return new Promise(resolve => once(event)(resolve));\n }\n Event.toPromise = toPromise;\n /**\n * Creates an event out of a promise that fires once when the promise is\n * resolved with the result of the promise or `undefined`.\n */\n function fromPromise(promise) {\n const result = new Emitter();\n promise.then(res => {\n result.fire(res);\n }, () => {\n result.fire(undefined);\n }).finally(() => {\n result.dispose();\n });\n return result.event;\n }\n Event.fromPromise = fromPromise;\n function runAndSubscribe(event, handler, initial) {\n handler(initial);\n return event(e => handler(e));\n }\n Event.runAndSubscribe = runAndSubscribe;\n /**\n * Adds a listener to an event and calls the listener immediately with undefined as the event object. A new\n * {@link DisposableStore} is passed to the listener which is disposed when the returned disposable is disposed.\n */\n function runAndSubscribeWithStore(event, handler) {\n let store = null;\n function run(e) {\n store === null || store === void 0 ? void 0 : store.dispose();\n store = new DisposableStore();\n handler(e, store);\n }\n run(undefined);\n const disposable = event(e => run(e));\n return toDisposable(() => {\n disposable.dispose();\n store === null || store === void 0 ? void 0 : store.dispose();\n });\n }\n Event.runAndSubscribeWithStore = runAndSubscribeWithStore;\n class EmitterObserver {\n constructor(_observable, store) {\n this._observable = _observable;\n this._counter = 0;\n this._hasChanged = false;\n const options = {\n onWillAddFirstListener: () => {\n _observable.addObserver(this);\n },\n onDidRemoveLastListener: () => {\n _observable.removeObserver(this);\n }\n };\n if (!store) {\n _addLeakageTraceLogic(options);\n }\n this.emitter = new Emitter(options);\n if (store) {\n store.add(this.emitter);\n }\n }\n beginUpdate(_observable) {\n // assert(_observable === this.obs);\n this._counter++;\n }\n handlePossibleChange(_observable) {\n // assert(_observable === this.obs);\n }\n handleChange(_observable, _change) {\n // assert(_observable === this.obs);\n this._hasChanged = true;\n }\n endUpdate(_observable) {\n // assert(_observable === this.obs);\n this._counter--;\n if (this._counter === 0) {\n this._observable.reportChanges();\n if (this._hasChanged) {\n this._hasChanged = false;\n this.emitter.fire(this._observable.get());\n }\n }\n }\n }\n /**\n * Creates an event emitter that is fired when the observable changes.\n * Each listeners subscribes to the emitter.\n */\n function fromObservable(obs, store) {\n const observer = new EmitterObserver(obs, store);\n return observer.emitter.event;\n }\n Event.fromObservable = fromObservable;\n /**\n * Each listener is attached to the observable directly.\n */\n function fromObservableLight(observable) {\n return (listener, thisArgs, disposables) => {\n let count = 0;\n let didChange = false;\n const observer = {\n beginUpdate() {\n count++;\n },\n endUpdate() {\n count--;\n if (count === 0) {\n observable.reportChanges();\n if (didChange) {\n didChange = false;\n listener.call(thisArgs);\n }\n }\n },\n handlePossibleChange() {\n // noop\n },\n handleChange() {\n didChange = true;\n }\n };\n observable.addObserver(observer);\n observable.reportChanges();\n const disposable = {\n dispose() {\n observable.removeObserver(observer);\n }\n };\n if (disposables instanceof DisposableStore) {\n disposables.add(disposable);\n }\n else if (Array.isArray(disposables)) {\n disposables.push(disposable);\n }\n return disposable;\n };\n }\n Event.fromObservableLight = fromObservableLight;\n})(Event || (Event = {}));\nexport class EventProfiling {\n constructor(name) {\n this.listenerCount = 0;\n this.invocationCount = 0;\n this.elapsedOverall = 0;\n this.durations = [];\n this.name = `${name}_${EventProfiling._idPool++}`;\n EventProfiling.all.add(this);\n }\n start(listenerCount) {\n this._stopWatch = new StopWatch();\n this.listenerCount = listenerCount;\n }\n stop() {\n if (this._stopWatch) {\n const elapsed = this._stopWatch.elapsed();\n this.durations.push(elapsed);\n this.elapsedOverall += elapsed;\n this.invocationCount += 1;\n this._stopWatch = undefined;\n }\n }\n}\nEventProfiling.all = new Set();\nEventProfiling._idPool = 0;\nlet _globalLeakWarningThreshold = -1;\nclass LeakageMonitor {\n constructor(threshold, name = Math.random().toString(18).slice(2, 5)) {\n this.threshold = threshold;\n this.name = name;\n this._warnCountdown = 0;\n }\n dispose() {\n var _a;\n (_a = this._stacks) === null || _a === void 0 ? void 0 : _a.clear();\n }\n check(stack, listenerCount) {\n const threshold = this.threshold;\n if (threshold <= 0 || listenerCount < threshold) {\n return undefined;\n }\n if (!this._stacks) {\n this._stacks = new Map();\n }\n const count = (this._stacks.get(stack.value) || 0);\n this._stacks.set(stack.value, count + 1);\n this._warnCountdown -= 1;\n if (this._warnCountdown <= 0) {\n // only warn on first exceed and then every time the limit\n // is exceeded by 50% again\n this._warnCountdown = threshold * 0.5;\n // find most frequent listener and print warning\n let topStack;\n let topCount = 0;\n for (const [stack, count] of this._stacks) {\n if (!topStack || topCount < count) {\n topStack = stack;\n topCount = count;\n }\n }\n console.warn(`[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`);\n console.warn(topStack);\n }\n return () => {\n const count = (this._stacks.get(stack.value) || 0);\n this._stacks.set(stack.value, count - 1);\n };\n }\n}\nclass Stacktrace {\n static create() {\n var _a;\n return new Stacktrace((_a = new Error().stack) !== null && _a !== void 0 ? _a : '');\n }\n constructor(value) {\n this.value = value;\n }\n print() {\n console.warn(this.value.split('\\n').slice(2).join('\\n'));\n }\n}\nclass UniqueContainer {\n constructor(value) {\n this.value = value;\n }\n}\nconst compactionThreshold = 2;\nconst forEachListener = (listeners, fn) => {\n if (listeners instanceof UniqueContainer) {\n fn(listeners);\n }\n else {\n for (let i = 0; i < listeners.length; i++) {\n const l = listeners[i];\n if (l) {\n fn(l);\n }\n }\n }\n};\n/**\n * The Emitter can be used to expose an Event to the public\n * to fire it from the insides.\n * Sample:\n class Document {\n\n private readonly _onDidChange = new Emitter<(value:string)=>any>();\n\n public onDidChange = this._onDidChange.event;\n\n // getter-style\n // get onDidChange(): Event<(value:string)=>any> {\n // \treturn this._onDidChange.event;\n // }\n\n private _doIt() {\n //...\n this._onDidChange.fire(value);\n }\n }\n */\nexport class Emitter {\n constructor(options) {\n var _a, _b, _c, _d, _e;\n this._size = 0;\n this._options = options;\n this._leakageMon = _globalLeakWarningThreshold > 0 || ((_a = this._options) === null || _a === void 0 ? void 0 : _a.leakWarningThreshold) ? new LeakageMonitor((_c = (_b = this._options) === null || _b === void 0 ? void 0 : _b.leakWarningThreshold) !== null && _c !== void 0 ? _c : _globalLeakWarningThreshold) : undefined;\n this._perfMon = ((_d = this._options) === null || _d === void 0 ? void 0 : _d._profName) ? new EventProfiling(this._options._profName) : undefined;\n this._deliveryQueue = (_e = this._options) === null || _e === void 0 ? void 0 : _e.deliveryQueue;\n }\n dispose() {\n var _a, _b, _c, _d;\n if (!this._disposed) {\n this._disposed = true;\n // It is bad to have listeners at the time of disposing an emitter, it is worst to have listeners keep the emitter\n // alive via the reference that's embedded in their disposables. Therefore we loop over all remaining listeners and\n // unset their subscriptions/disposables. Looping and blaming remaining listeners is done on next tick because the\n // the following programming pattern is very popular:\n //\n // const someModel = this._disposables.add(new ModelObject()); // (1) create and register model\n // this._disposables.add(someModel.onDidChange(() => { ... }); // (2) subscribe and register model-event listener\n // ...later...\n // this._disposables.dispose(); disposes (1) then (2): don't warn after (1) but after the \"overall dispose\" is done\n if (((_a = this._deliveryQueue) === null || _a === void 0 ? void 0 : _a.current) === this) {\n this._deliveryQueue.reset();\n }\n if (this._listeners) {\n if (_enableDisposeWithListenerWarning) {\n const listeners = this._listeners;\n queueMicrotask(() => {\n forEachListener(listeners, l => { var _a; return (_a = l.stack) === null || _a === void 0 ? void 0 : _a.print(); });\n });\n }\n this._listeners = undefined;\n this._size = 0;\n }\n (_c = (_b = this._options) === null || _b === void 0 ? void 0 : _b.onDidRemoveLastListener) === null || _c === void 0 ? void 0 : _c.call(_b);\n (_d = this._leakageMon) === null || _d === void 0 ? void 0 : _d.dispose();\n }\n }\n /**\n * For the public to allow to subscribe\n * to events from this Emitter\n */\n get event() {\n var _a;\n (_a = this._event) !== null && _a !== void 0 ? _a : (this._event = (callback, thisArgs, disposables) => {\n var _a, _b, _c, _d, _e;\n if (this._leakageMon && this._size > this._leakageMon.threshold * 3) {\n console.warn(`[${this._leakageMon.name}] REFUSES to accept new listeners because it exceeded its threshold by far`);\n return Disposable.None;\n }\n if (this._disposed) {\n // todo: should we warn if a listener is added to a disposed emitter? This happens often\n return Disposable.None;\n }\n if (thisArgs) {\n callback = callback.bind(thisArgs);\n }\n const contained = new UniqueContainer(callback);\n let removeMonitor;\n let stack;\n if (this._leakageMon && this._size >= Math.ceil(this._leakageMon.threshold * 0.2)) {\n // check and record this emitter for potential leakage\n contained.stack = Stacktrace.create();\n removeMonitor = this._leakageMon.check(contained.stack, this._size + 1);\n }\n if (_enableDisposeWithListenerWarning) {\n contained.stack = stack !== null && stack !== void 0 ? stack : Stacktrace.create();\n }\n if (!this._listeners) {\n (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.onWillAddFirstListener) === null || _b === void 0 ? void 0 : _b.call(_a, this);\n this._listeners = contained;\n (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.onDidAddFirstListener) === null || _d === void 0 ? void 0 : _d.call(_c, this);\n }\n else if (this._listeners instanceof UniqueContainer) {\n (_e = this._deliveryQueue) !== null && _e !== void 0 ? _e : (this._deliveryQueue = new EventDeliveryQueuePrivate());\n this._listeners = [this._listeners, contained];\n }\n else {\n this._listeners.push(contained);\n }\n this._size++;\n const result = toDisposable(() => { removeMonitor === null || removeMonitor === void 0 ? void 0 : removeMonitor(); this._removeListener(contained); });\n if (disposables instanceof DisposableStore) {\n disposables.add(result);\n }\n else if (Array.isArray(disposables)) {\n disposables.push(result);\n }\n return result;\n });\n return this._event;\n }\n _removeListener(listener) {\n var _a, _b, _c, _d;\n (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.onWillRemoveListener) === null || _b === void 0 ? void 0 : _b.call(_a, this);\n if (!this._listeners) {\n return; // expected if a listener gets disposed\n }\n if (this._size === 1) {\n this._listeners = undefined;\n (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.onDidRemoveLastListener) === null || _d === void 0 ? void 0 : _d.call(_c, this);\n this._size = 0;\n return;\n }\n // size > 1 which requires that listeners be a list:\n const listeners = this._listeners;\n const index = listeners.indexOf(listener);\n if (index === -1) {\n console.log('disposed?', this._disposed);\n console.log('size?', this._size);\n console.log('arr?', JSON.stringify(this._listeners));\n throw new Error('Attempted to dispose unknown listener');\n }\n this._size--;\n listeners[index] = undefined;\n const adjustDeliveryQueue = this._deliveryQueue.current === this;\n if (this._size * compactionThreshold <= listeners.length) {\n let n = 0;\n for (let i = 0; i < listeners.length; i++) {\n if (listeners[i]) {\n listeners[n++] = listeners[i];\n }\n else if (adjustDeliveryQueue) {\n this._deliveryQueue.end--;\n if (n < this._deliveryQueue.i) {\n this._deliveryQueue.i--;\n }\n }\n }\n listeners.length = n;\n }\n }\n _deliver(listener, value) {\n var _a;\n if (!listener) {\n return;\n }\n const errorHandler = ((_a = this._options) === null || _a === void 0 ? void 0 : _a.onListenerError) || onUnexpectedError;\n if (!errorHandler) {\n listener.value(value);\n return;\n }\n try {\n listener.value(value);\n }\n catch (e) {\n errorHandler(e);\n }\n }\n /** Delivers items in the queue. Assumes the queue is ready to go. */\n _deliverQueue(dq) {\n const listeners = dq.current._listeners;\n while (dq.i < dq.end) {\n // important: dq.i is incremented before calling deliver() because it might reenter deliverQueue()\n this._deliver(listeners[dq.i++], dq.value);\n }\n dq.reset();\n }\n /**\n * To be kept private to fire an event to\n * subscribers\n */\n fire(event) {\n var _a, _b, _c, _d;\n if ((_a = this._deliveryQueue) === null || _a === void 0 ? void 0 : _a.current) {\n this._deliverQueue(this._deliveryQueue);\n (_b = this._perfMon) === null || _b === void 0 ? void 0 : _b.stop(); // last fire() will have starting perfmon, stop it before starting the next dispatch\n }\n (_c = this._perfMon) === null || _c === void 0 ? void 0 : _c.start(this._size);\n if (!this._listeners) {\n // no-op\n }\n else if (this._listeners instanceof UniqueContainer) {\n this._deliver(this._listeners, event);\n }\n else {\n const dq = this._deliveryQueue;\n dq.enqueue(this, event, this._listeners.length);\n this._deliverQueue(dq);\n }\n (_d = this._perfMon) === null || _d === void 0 ? void 0 : _d.stop();\n }\n hasListeners() {\n return this._size > 0;\n }\n}\nexport const createEventDeliveryQueue = () => new EventDeliveryQueuePrivate();\nclass EventDeliveryQueuePrivate {\n constructor() {\n /**\n * Index in current's listener list.\n */\n this.i = -1;\n /**\n * The last index in the listener's list to deliver.\n */\n this.end = 0;\n }\n enqueue(emitter, value, end) {\n this.i = 0;\n this.end = end;\n this.current = emitter;\n this.value = value;\n }\n reset() {\n this.i = this.end; // force any current emission loop to stop, mainly for during dispose\n this.current = undefined;\n this.value = undefined;\n }\n}\nexport class PauseableEmitter extends Emitter {\n constructor(options) {\n super(options);\n this._isPaused = 0;\n this._eventQueue = new LinkedList();\n this._mergeFn = options === null || options === void 0 ? void 0 : options.merge;\n }\n pause() {\n this._isPaused++;\n }\n resume() {\n if (this._isPaused !== 0 && --this._isPaused === 0) {\n if (this._mergeFn) {\n // use the merge function to create a single composite\n // event. make a copy in case firing pauses this emitter\n if (this._eventQueue.size > 0) {\n const events = Array.from(this._eventQueue);\n this._eventQueue.clear();\n super.fire(this._mergeFn(events));\n }\n }\n else {\n // no merging, fire each event individually and test\n // that this emitter isn't paused halfway through\n while (!this._isPaused && this._eventQueue.size !== 0) {\n super.fire(this._eventQueue.shift());\n }\n }\n }\n }\n fire(event) {\n if (this._size) {\n if (this._isPaused !== 0) {\n this._eventQueue.push(event);\n }\n else {\n super.fire(event);\n }\n }\n }\n}\nexport class DebounceEmitter extends PauseableEmitter {\n constructor(options) {\n var _a;\n super(options);\n this._delay = (_a = options.delay) !== null && _a !== void 0 ? _a : 100;\n }\n fire(event) {\n if (!this._handle) {\n this.pause();\n this._handle = setTimeout(() => {\n this._handle = undefined;\n this.resume();\n }, this._delay);\n }\n super.fire(event);\n }\n}\n/**\n * An emitter which queue all events and then process them at the\n * end of the event loop.\n */\nexport class MicrotaskEmitter extends Emitter {\n constructor(options) {\n super(options);\n this._queuedEvents = [];\n this._mergeFn = options === null || options === void 0 ? void 0 : options.merge;\n }\n fire(event) {\n if (!this.hasListeners()) {\n return;\n }\n this._queuedEvents.push(event);\n if (this._queuedEvents.length === 1) {\n queueMicrotask(() => {\n if (this._mergeFn) {\n super.fire(this._mergeFn(this._queuedEvents));\n }\n else {\n this._queuedEvents.forEach(e => super.fire(e));\n }\n this._queuedEvents = [];\n });\n }\n }\n}\n/**\n * An event emitter that multiplexes many events into a single event.\n *\n * @example Listen to the `onData` event of all `Thing`s, dynamically adding and removing `Thing`s\n * to the multiplexer as needed.\n *\n * ```typescript\n * const anythingDataMultiplexer = new EventMultiplexer<{ data: string }>();\n *\n * const thingListeners = DisposableMap();\n *\n * thingService.onDidAddThing(thing => {\n * thingListeners.set(thing, anythingDataMultiplexer.add(thing.onData);\n * });\n * thingService.onDidRemoveThing(thing => {\n * thingListeners.deleteAndDispose(thing);\n * });\n *\n * anythingDataMultiplexer.event(e => {\n * console.log('Something fired data ' + e.data)\n * });\n * ```\n */\nexport class EventMultiplexer {\n constructor() {\n this.hasListeners = false;\n this.events = [];\n this.emitter = new Emitter({\n onWillAddFirstListener: () => this.onFirstListenerAdd(),\n onDidRemoveLastListener: () => this.onLastListenerRemove()\n });\n }\n get event() {\n return this.emitter.event;\n }\n add(event) {\n const e = { event: event, listener: null };\n this.events.push(e);\n if (this.hasListeners) {\n this.hook(e);\n }\n const dispose = () => {\n if (this.hasListeners) {\n this.unhook(e);\n }\n const idx = this.events.indexOf(e);\n this.events.splice(idx, 1);\n };\n return toDisposable(createSingleCallFunction(dispose));\n }\n onFirstListenerAdd() {\n this.hasListeners = true;\n this.events.forEach(e => this.hook(e));\n }\n onLastListenerRemove() {\n this.hasListeners = false;\n this.events.forEach(e => this.unhook(e));\n }\n hook(e) {\n e.listener = e.event(r => this.emitter.fire(r));\n }\n unhook(e) {\n if (e.listener) {\n e.listener.dispose();\n }\n e.listener = null;\n }\n dispose() {\n this.emitter.dispose();\n }\n}\n/**\n * The EventBufferer is useful in situations in which you want\n * to delay firing your events during some code.\n * You can wrap that code and be sure that the event will not\n * be fired during that wrap.\n *\n * ```\n * const emitter: Emitter;\n * const delayer = new EventDelayer();\n * const delayedEvent = delayer.wrapEvent(emitter.event);\n *\n * delayedEvent(console.log);\n *\n * delayer.bufferEvents(() => {\n * emitter.fire(); // event will not be fired yet\n * });\n *\n * // event will only be fired at this point\n * ```\n */\nexport class EventBufferer {\n constructor() {\n this.buffers = [];\n }\n wrapEvent(event) {\n return (listener, thisArgs, disposables) => {\n return event(i => {\n const buffer = this.buffers[this.buffers.length - 1];\n if (buffer) {\n buffer.push(() => listener.call(thisArgs, i));\n }\n else {\n listener.call(thisArgs, i);\n }\n }, undefined, disposables);\n };\n }\n bufferEvents(fn) {\n const buffer = [];\n this.buffers.push(buffer);\n const r = fn();\n this.buffers.pop();\n buffer.forEach(flush => flush());\n return r;\n }\n}\n/**\n * A Relay is an event forwarder which functions as a replugabble event pipe.\n * Once created, you can connect an input event to it and it will simply forward\n * events from that input event through its own `event` property. The `input`\n * can be changed at any point in time.\n */\nexport class Relay {\n constructor() {\n this.listening = false;\n this.inputEvent = Event.None;\n this.inputEventListener = Disposable.None;\n this.emitter = new Emitter({\n onDidAddFirstListener: () => {\n this.listening = true;\n this.inputEventListener = this.inputEvent(this.emitter.fire, this.emitter);\n },\n onDidRemoveLastListener: () => {\n this.listening = false;\n this.inputEventListener.dispose();\n }\n });\n this.event = this.emitter.event;\n }\n set input(event) {\n this.inputEvent = event;\n if (this.listening) {\n this.inputEventListener.dispose();\n this.inputEventListener = event(this.emitter.fire, this.emitter);\n }\n }\n dispose() {\n this.inputEventListener.dispose();\n this.emitter.dispose();\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Given a function, returns a function that is only calling that function once.\n */\nexport function createSingleCallFunction(fn, fnDidRunCallback) {\n const _this = this;\n let didCall = false;\n let result;\n return function () {\n if (didCall) {\n return result;\n }\n didCall = true;\n if (fnDidRunCallback) {\n try {\n result = fn.apply(_this, arguments);\n }\n finally {\n fnDidRunCallback();\n }\n }\n else {\n result = fn.apply(_this, arguments);\n }\n return result;\n };\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from './strings.js';\n/**\n * Return a hash value for an object.\n */\nexport function hash(obj) {\n return doHash(obj, 0);\n}\nexport function doHash(obj, hashVal) {\n switch (typeof obj) {\n case 'object':\n if (obj === null) {\n return numberHash(349, hashVal);\n }\n else if (Array.isArray(obj)) {\n return arrayHash(obj, hashVal);\n }\n return objectHash(obj, hashVal);\n case 'string':\n return stringHash(obj, hashVal);\n case 'boolean':\n return booleanHash(obj, hashVal);\n case 'number':\n return numberHash(obj, hashVal);\n case 'undefined':\n return numberHash(937, hashVal);\n default:\n return numberHash(617, hashVal);\n }\n}\nexport function numberHash(val, initialHashVal) {\n return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32\n}\nfunction booleanHash(b, initialHashVal) {\n return numberHash(b ? 433 : 863, initialHashVal);\n}\nexport function stringHash(s, hashVal) {\n hashVal = numberHash(149417, hashVal);\n for (let i = 0, length = s.length; i < length; i++) {\n hashVal = numberHash(s.charCodeAt(i), hashVal);\n }\n return hashVal;\n}\nfunction arrayHash(arr, initialHashVal) {\n initialHashVal = numberHash(104579, initialHashVal);\n return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);\n}\nfunction objectHash(obj, initialHashVal) {\n initialHashVal = numberHash(181387, initialHashVal);\n return Object.keys(obj).sort().reduce((hashVal, key) => {\n hashVal = stringHash(key, hashVal);\n return doHash(obj[key], hashVal);\n }, initialHashVal);\n}\nfunction leftRotate(value, bits, totalBits = 32) {\n // delta + bits = totalBits\n const delta = totalBits - bits;\n // All ones, expect `delta` zeros aligned to the right\n const mask = ~((1 << delta) - 1);\n // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)\n return ((value << bits) | ((mask & value) >>> delta)) >>> 0;\n}\nfunction fill(dest, index = 0, count = dest.byteLength, value = 0) {\n for (let i = 0; i < count; i++) {\n dest[index + i] = value;\n }\n}\nfunction leftPad(value, length, char = '0') {\n while (value.length < length) {\n value = char + value;\n }\n return value;\n}\nexport function toHexString(bufferOrValue, bitsize = 32) {\n if (bufferOrValue instanceof ArrayBuffer) {\n return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join('');\n }\n return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);\n}\n/**\n * A SHA1 implementation that works with strings and does not allocate.\n */\nexport class StringSHA1 {\n constructor() {\n this._h0 = 0x67452301;\n this._h1 = 0xEFCDAB89;\n this._h2 = 0x98BADCFE;\n this._h3 = 0x10325476;\n this._h4 = 0xC3D2E1F0;\n this._buff = new Uint8Array(64 /* SHA1Constant.BLOCK_SIZE */ + 3 /* to fit any utf-8 */);\n this._buffDV = new DataView(this._buff.buffer);\n this._buffLen = 0;\n this._totalLen = 0;\n this._leftoverHighSurrogate = 0;\n this._finished = false;\n }\n update(str) {\n const strLen = str.length;\n if (strLen === 0) {\n return;\n }\n const buff = this._buff;\n let buffLen = this._buffLen;\n let leftoverHighSurrogate = this._leftoverHighSurrogate;\n let charCode;\n let offset;\n if (leftoverHighSurrogate !== 0) {\n charCode = leftoverHighSurrogate;\n offset = -1;\n leftoverHighSurrogate = 0;\n }\n else {\n charCode = str.charCodeAt(0);\n offset = 0;\n }\n while (true) {\n let codePoint = charCode;\n if (strings.isHighSurrogate(charCode)) {\n if (offset + 1 < strLen) {\n const nextCharCode = str.charCodeAt(offset + 1);\n if (strings.isLowSurrogate(nextCharCode)) {\n offset++;\n codePoint = strings.computeCodePoint(charCode, nextCharCode);\n }\n else {\n // illegal => unicode replacement character\n codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;\n }\n }\n else {\n // last character is a surrogate pair\n leftoverHighSurrogate = charCode;\n break;\n }\n }\n else if (strings.isLowSurrogate(charCode)) {\n // illegal => unicode replacement character\n codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;\n }\n buffLen = this._push(buff, buffLen, codePoint);\n offset++;\n if (offset < strLen) {\n charCode = str.charCodeAt(offset);\n }\n else {\n break;\n }\n }\n this._buffLen = buffLen;\n this._leftoverHighSurrogate = leftoverHighSurrogate;\n }\n _push(buff, buffLen, codePoint) {\n if (codePoint < 0x0080) {\n buff[buffLen++] = codePoint;\n }\n else if (codePoint < 0x0800) {\n buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);\n buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n }\n else if (codePoint < 0x10000) {\n buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);\n buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n }\n else {\n buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);\n buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);\n buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n }\n if (buffLen >= 64 /* SHA1Constant.BLOCK_SIZE */) {\n this._step();\n buffLen -= 64 /* SHA1Constant.BLOCK_SIZE */;\n this._totalLen += 64 /* SHA1Constant.BLOCK_SIZE */;\n // take last 3 in case of UTF8 overflow\n buff[0] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 0];\n buff[1] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 1];\n buff[2] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 2];\n }\n return buffLen;\n }\n digest() {\n if (!this._finished) {\n this._finished = true;\n if (this._leftoverHighSurrogate) {\n // illegal => unicode replacement character\n this._leftoverHighSurrogate = 0;\n this._buffLen = this._push(this._buff, this._buffLen, 65533 /* SHA1Constant.UNICODE_REPLACEMENT */);\n }\n this._totalLen += this._buffLen;\n this._wrapUp();\n }\n return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);\n }\n _wrapUp() {\n this._buff[this._buffLen++] = 0x80;\n fill(this._buff, this._buffLen);\n if (this._buffLen > 56) {\n this._step();\n fill(this._buff);\n }\n // this will fit because the mantissa can cover up to 52 bits\n const ml = 8 * this._totalLen;\n this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);\n this._buffDV.setUint32(60, ml % 4294967296, false);\n this._step();\n }\n _step() {\n const bigBlock32 = StringSHA1._bigBlock32;\n const data = this._buffDV;\n for (let j = 0; j < 64 /* 16*4 */; j += 4) {\n bigBlock32.setUint32(j, data.getUint32(j, false), false);\n }\n for (let j = 64; j < 320 /* 80*4 */; j += 4) {\n bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);\n }\n let a = this._h0;\n let b = this._h1;\n let c = this._h2;\n let d = this._h3;\n let e = this._h4;\n let f, k;\n let temp;\n for (let j = 0; j < 80; j++) {\n if (j < 20) {\n f = (b & c) | ((~b) & d);\n k = 0x5A827999;\n }\n else if (j < 40) {\n f = b ^ c ^ d;\n k = 0x6ED9EBA1;\n }\n else if (j < 60) {\n f = (b & c) | (b & d) | (c & d);\n k = 0x8F1BBCDC;\n }\n else {\n f = b ^ c ^ d;\n k = 0xCA62C1D6;\n }\n temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;\n e = d;\n d = c;\n c = leftRotate(b, 30);\n b = a;\n a = temp;\n }\n this._h0 = (this._h0 + a) & 0xffffffff;\n this._h1 = (this._h1 + b) & 0xffffffff;\n this._h2 = (this._h2 + c) & 0xffffffff;\n this._h3 = (this._h3 + d) & 0xffffffff;\n this._h4 = (this._h4 + e) & 0xffffffff;\n }\n}\nStringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport var Iterable;\n(function (Iterable) {\n function is(thing) {\n return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';\n }\n Iterable.is = is;\n const _empty = Object.freeze([]);\n function empty() {\n return _empty;\n }\n Iterable.empty = empty;\n function* single(element) {\n yield element;\n }\n Iterable.single = single;\n function wrap(iterableOrElement) {\n if (is(iterableOrElement)) {\n return iterableOrElement;\n }\n else {\n return single(iterableOrElement);\n }\n }\n Iterable.wrap = wrap;\n function from(iterable) {\n return iterable || _empty;\n }\n Iterable.from = from;\n function* reverse(array) {\n for (let i = array.length - 1; i >= 0; i--) {\n yield array[i];\n }\n }\n Iterable.reverse = reverse;\n function isEmpty(iterable) {\n return !iterable || iterable[Symbol.iterator]().next().done === true;\n }\n Iterable.isEmpty = isEmpty;\n function first(iterable) {\n return iterable[Symbol.iterator]().next().value;\n }\n Iterable.first = first;\n function some(iterable, predicate) {\n for (const element of iterable) {\n if (predicate(element)) {\n return true;\n }\n }\n return false;\n }\n Iterable.some = some;\n function find(iterable, predicate) {\n for (const element of iterable) {\n if (predicate(element)) {\n return element;\n }\n }\n return undefined;\n }\n Iterable.find = find;\n function* filter(iterable, predicate) {\n for (const element of iterable) {\n if (predicate(element)) {\n yield element;\n }\n }\n }\n Iterable.filter = filter;\n function* map(iterable, fn) {\n let index = 0;\n for (const element of iterable) {\n yield fn(element, index++);\n }\n }\n Iterable.map = map;\n function* concat(...iterables) {\n for (const iterable of iterables) {\n yield* iterable;\n }\n }\n Iterable.concat = concat;\n function reduce(iterable, reducer, initialValue) {\n let value = initialValue;\n for (const element of iterable) {\n value = reducer(value, element);\n }\n return value;\n }\n Iterable.reduce = reduce;\n /**\n * Returns an iterable slice of the array, with the same semantics as `array.slice()`.\n */\n function* slice(arr, from, to = arr.length) {\n if (from < 0) {\n from += arr.length;\n }\n if (to < 0) {\n to += arr.length;\n }\n else if (to > arr.length) {\n to = arr.length;\n }\n for (; from < to; from++) {\n yield arr[from];\n }\n }\n Iterable.slice = slice;\n /**\n * Consumes `atMost` elements from iterable and returns the consumed elements,\n * and an iterable for the rest of the elements.\n */\n function consume(iterable, atMost = Number.POSITIVE_INFINITY) {\n const consumed = [];\n if (atMost === 0) {\n return [consumed, iterable];\n }\n const iterator = iterable[Symbol.iterator]();\n for (let i = 0; i < atMost; i++) {\n const next = iterator.next();\n if (next.done) {\n return [consumed, Iterable.empty()];\n }\n consumed.push(next.value);\n }\n return [consumed, { [Symbol.iterator]() { return iterator; } }];\n }\n Iterable.consume = consume;\n})(Iterable || (Iterable = {}));\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nclass KeyCodeStrMap {\n constructor() {\n this._keyCodeToStr = [];\n this._strToKeyCode = Object.create(null);\n }\n define(keyCode, str) {\n this._keyCodeToStr[keyCode] = str;\n this._strToKeyCode[str.toLowerCase()] = keyCode;\n }\n keyCodeToStr(keyCode) {\n return this._keyCodeToStr[keyCode];\n }\n strToKeyCode(str) {\n return this._strToKeyCode[str.toLowerCase()] || 0 /* KeyCode.Unknown */;\n }\n}\nconst uiMap = new KeyCodeStrMap();\nconst userSettingsUSMap = new KeyCodeStrMap();\nconst userSettingsGeneralMap = new KeyCodeStrMap();\nexport const EVENT_KEY_CODE_MAP = new Array(230);\nexport const NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE = {};\nconst scanCodeIntToStr = [];\nconst scanCodeStrToInt = Object.create(null);\nconst scanCodeLowerCaseStrToInt = Object.create(null);\n/**\n * -1 if a ScanCode => KeyCode mapping depends on kb layout.\n */\nexport const IMMUTABLE_CODE_TO_KEY_CODE = [];\n/**\n * -1 if a KeyCode => ScanCode mapping depends on kb layout.\n */\nexport const IMMUTABLE_KEY_CODE_TO_CODE = [];\nfor (let i = 0; i <= 193 /* ScanCode.MAX_VALUE */; i++) {\n IMMUTABLE_CODE_TO_KEY_CODE[i] = -1 /* KeyCode.DependsOnKbLayout */;\n}\nfor (let i = 0; i <= 132 /* KeyCode.MAX_VALUE */; i++) {\n IMMUTABLE_KEY_CODE_TO_CODE[i] = -1 /* ScanCode.DependsOnKbLayout */;\n}\n(function () {\n // See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n // See https://github.com/microsoft/node-native-keymap/blob/88c0b0e5/deps/chromium/keyboard_codes_win.h\n const empty = '';\n const mappings = [\n // immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel\n [1, 0 /* ScanCode.None */, 'None', 0 /* KeyCode.Unknown */, 'unknown', 0, 'VK_UNKNOWN', empty, empty],\n [1, 1 /* ScanCode.Hyper */, 'Hyper', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 2 /* ScanCode.Super */, 'Super', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 3 /* ScanCode.Fn */, 'Fn', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 4 /* ScanCode.FnLock */, 'FnLock', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 5 /* ScanCode.Suspend */, 'Suspend', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 6 /* ScanCode.Resume */, 'Resume', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 7 /* ScanCode.Turbo */, 'Turbo', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 8 /* ScanCode.Sleep */, 'Sleep', 0 /* KeyCode.Unknown */, empty, 0, 'VK_SLEEP', empty, empty],\n [1, 9 /* ScanCode.WakeUp */, 'WakeUp', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [0, 10 /* ScanCode.KeyA */, 'KeyA', 31 /* KeyCode.KeyA */, 'A', 65, 'VK_A', empty, empty],\n [0, 11 /* ScanCode.KeyB */, 'KeyB', 32 /* KeyCode.KeyB */, 'B', 66, 'VK_B', empty, empty],\n [0, 12 /* ScanCode.KeyC */, 'KeyC', 33 /* KeyCode.KeyC */, 'C', 67, 'VK_C', empty, empty],\n [0, 13 /* ScanCode.KeyD */, 'KeyD', 34 /* KeyCode.KeyD */, 'D', 68, 'VK_D', empty, empty],\n [0, 14 /* ScanCode.KeyE */, 'KeyE', 35 /* KeyCode.KeyE */, 'E', 69, 'VK_E', empty, empty],\n [0, 15 /* ScanCode.KeyF */, 'KeyF', 36 /* KeyCode.KeyF */, 'F', 70, 'VK_F', empty, empty],\n [0, 16 /* ScanCode.KeyG */, 'KeyG', 37 /* KeyCode.KeyG */, 'G', 71, 'VK_G', empty, empty],\n [0, 17 /* ScanCode.KeyH */, 'KeyH', 38 /* KeyCode.KeyH */, 'H', 72, 'VK_H', empty, empty],\n [0, 18 /* ScanCode.KeyI */, 'KeyI', 39 /* KeyCode.KeyI */, 'I', 73, 'VK_I', empty, empty],\n [0, 19 /* ScanCode.KeyJ */, 'KeyJ', 40 /* KeyCode.KeyJ */, 'J', 74, 'VK_J', empty, empty],\n [0, 20 /* ScanCode.KeyK */, 'KeyK', 41 /* KeyCode.KeyK */, 'K', 75, 'VK_K', empty, empty],\n [0, 21 /* ScanCode.KeyL */, 'KeyL', 42 /* KeyCode.KeyL */, 'L', 76, 'VK_L', empty, empty],\n [0, 22 /* ScanCode.KeyM */, 'KeyM', 43 /* KeyCode.KeyM */, 'M', 77, 'VK_M', empty, empty],\n [0, 23 /* ScanCode.KeyN */, 'KeyN', 44 /* KeyCode.KeyN */, 'N', 78, 'VK_N', empty, empty],\n [0, 24 /* ScanCode.KeyO */, 'KeyO', 45 /* KeyCode.KeyO */, 'O', 79, 'VK_O', empty, empty],\n [0, 25 /* ScanCode.KeyP */, 'KeyP', 46 /* KeyCode.KeyP */, 'P', 80, 'VK_P', empty, empty],\n [0, 26 /* ScanCode.KeyQ */, 'KeyQ', 47 /* KeyCode.KeyQ */, 'Q', 81, 'VK_Q', empty, empty],\n [0, 27 /* ScanCode.KeyR */, 'KeyR', 48 /* KeyCode.KeyR */, 'R', 82, 'VK_R', empty, empty],\n [0, 28 /* ScanCode.KeyS */, 'KeyS', 49 /* KeyCode.KeyS */, 'S', 83, 'VK_S', empty, empty],\n [0, 29 /* ScanCode.KeyT */, 'KeyT', 50 /* KeyCode.KeyT */, 'T', 84, 'VK_T', empty, empty],\n [0, 30 /* ScanCode.KeyU */, 'KeyU', 51 /* KeyCode.KeyU */, 'U', 85, 'VK_U', empty, empty],\n [0, 31 /* ScanCode.KeyV */, 'KeyV', 52 /* KeyCode.KeyV */, 'V', 86, 'VK_V', empty, empty],\n [0, 32 /* ScanCode.KeyW */, 'KeyW', 53 /* KeyCode.KeyW */, 'W', 87, 'VK_W', empty, empty],\n [0, 33 /* ScanCode.KeyX */, 'KeyX', 54 /* KeyCode.KeyX */, 'X', 88, 'VK_X', empty, empty],\n [0, 34 /* ScanCode.KeyY */, 'KeyY', 55 /* KeyCode.KeyY */, 'Y', 89, 'VK_Y', empty, empty],\n [0, 35 /* ScanCode.KeyZ */, 'KeyZ', 56 /* KeyCode.KeyZ */, 'Z', 90, 'VK_Z', empty, empty],\n [0, 36 /* ScanCode.Digit1 */, 'Digit1', 22 /* KeyCode.Digit1 */, '1', 49, 'VK_1', empty, empty],\n [0, 37 /* ScanCode.Digit2 */, 'Digit2', 23 /* KeyCode.Digit2 */, '2', 50, 'VK_2', empty, empty],\n [0, 38 /* ScanCode.Digit3 */, 'Digit3', 24 /* KeyCode.Digit3 */, '3', 51, 'VK_3', empty, empty],\n [0, 39 /* ScanCode.Digit4 */, 'Digit4', 25 /* KeyCode.Digit4 */, '4', 52, 'VK_4', empty, empty],\n [0, 40 /* ScanCode.Digit5 */, 'Digit5', 26 /* KeyCode.Digit5 */, '5', 53, 'VK_5', empty, empty],\n [0, 41 /* ScanCode.Digit6 */, 'Digit6', 27 /* KeyCode.Digit6 */, '6', 54, 'VK_6', empty, empty],\n [0, 42 /* ScanCode.Digit7 */, 'Digit7', 28 /* KeyCode.Digit7 */, '7', 55, 'VK_7', empty, empty],\n [0, 43 /* ScanCode.Digit8 */, 'Digit8', 29 /* KeyCode.Digit8 */, '8', 56, 'VK_8', empty, empty],\n [0, 44 /* ScanCode.Digit9 */, 'Digit9', 30 /* KeyCode.Digit9 */, '9', 57, 'VK_9', empty, empty],\n [0, 45 /* ScanCode.Digit0 */, 'Digit0', 21 /* KeyCode.Digit0 */, '0', 48, 'VK_0', empty, empty],\n [1, 46 /* ScanCode.Enter */, 'Enter', 3 /* KeyCode.Enter */, 'Enter', 13, 'VK_RETURN', empty, empty],\n [1, 47 /* ScanCode.Escape */, 'Escape', 9 /* KeyCode.Escape */, 'Escape', 27, 'VK_ESCAPE', empty, empty],\n [1, 48 /* ScanCode.Backspace */, 'Backspace', 1 /* KeyCode.Backspace */, 'Backspace', 8, 'VK_BACK', empty, empty],\n [1, 49 /* ScanCode.Tab */, 'Tab', 2 /* KeyCode.Tab */, 'Tab', 9, 'VK_TAB', empty, empty],\n [1, 50 /* ScanCode.Space */, 'Space', 10 /* KeyCode.Space */, 'Space', 32, 'VK_SPACE', empty, empty],\n [0, 51 /* ScanCode.Minus */, 'Minus', 88 /* KeyCode.Minus */, '-', 189, 'VK_OEM_MINUS', '-', 'OEM_MINUS'],\n [0, 52 /* ScanCode.Equal */, 'Equal', 86 /* KeyCode.Equal */, '=', 187, 'VK_OEM_PLUS', '=', 'OEM_PLUS'],\n [0, 53 /* ScanCode.BracketLeft */, 'BracketLeft', 92 /* KeyCode.BracketLeft */, '[', 219, 'VK_OEM_4', '[', 'OEM_4'],\n [0, 54 /* ScanCode.BracketRight */, 'BracketRight', 94 /* KeyCode.BracketRight */, ']', 221, 'VK_OEM_6', ']', 'OEM_6'],\n [0, 55 /* ScanCode.Backslash */, 'Backslash', 93 /* KeyCode.Backslash */, '\\\\', 220, 'VK_OEM_5', '\\\\', 'OEM_5'],\n [0, 56 /* ScanCode.IntlHash */, 'IntlHash', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty], // has been dropped from the w3c spec\n [0, 57 /* ScanCode.Semicolon */, 'Semicolon', 85 /* KeyCode.Semicolon */, ';', 186, 'VK_OEM_1', ';', 'OEM_1'],\n [0, 58 /* ScanCode.Quote */, 'Quote', 95 /* KeyCode.Quote */, '\\'', 222, 'VK_OEM_7', '\\'', 'OEM_7'],\n [0, 59 /* ScanCode.Backquote */, 'Backquote', 91 /* KeyCode.Backquote */, '`', 192, 'VK_OEM_3', '`', 'OEM_3'],\n [0, 60 /* ScanCode.Comma */, 'Comma', 87 /* KeyCode.Comma */, ',', 188, 'VK_OEM_COMMA', ',', 'OEM_COMMA'],\n [0, 61 /* ScanCode.Period */, 'Period', 89 /* KeyCode.Period */, '.', 190, 'VK_OEM_PERIOD', '.', 'OEM_PERIOD'],\n [0, 62 /* ScanCode.Slash */, 'Slash', 90 /* KeyCode.Slash */, '/', 191, 'VK_OEM_2', '/', 'OEM_2'],\n [1, 63 /* ScanCode.CapsLock */, 'CapsLock', 8 /* KeyCode.CapsLock */, 'CapsLock', 20, 'VK_CAPITAL', empty, empty],\n [1, 64 /* ScanCode.F1 */, 'F1', 59 /* KeyCode.F1 */, 'F1', 112, 'VK_F1', empty, empty],\n [1, 65 /* ScanCode.F2 */, 'F2', 60 /* KeyCode.F2 */, 'F2', 113, 'VK_F2', empty, empty],\n [1, 66 /* ScanCode.F3 */, 'F3', 61 /* KeyCode.F3 */, 'F3', 114, 'VK_F3', empty, empty],\n [1, 67 /* ScanCode.F4 */, 'F4', 62 /* KeyCode.F4 */, 'F4', 115, 'VK_F4', empty, empty],\n [1, 68 /* ScanCode.F5 */, 'F5', 63 /* KeyCode.F5 */, 'F5', 116, 'VK_F5', empty, empty],\n [1, 69 /* ScanCode.F6 */, 'F6', 64 /* KeyCode.F6 */, 'F6', 117, 'VK_F6', empty, empty],\n [1, 70 /* ScanCode.F7 */, 'F7', 65 /* KeyCode.F7 */, 'F7', 118, 'VK_F7', empty, empty],\n [1, 71 /* ScanCode.F8 */, 'F8', 66 /* KeyCode.F8 */, 'F8', 119, 'VK_F8', empty, empty],\n [1, 72 /* ScanCode.F9 */, 'F9', 67 /* KeyCode.F9 */, 'F9', 120, 'VK_F9', empty, empty],\n [1, 73 /* ScanCode.F10 */, 'F10', 68 /* KeyCode.F10 */, 'F10', 121, 'VK_F10', empty, empty],\n [1, 74 /* ScanCode.F11 */, 'F11', 69 /* KeyCode.F11 */, 'F11', 122, 'VK_F11', empty, empty],\n [1, 75 /* ScanCode.F12 */, 'F12', 70 /* KeyCode.F12 */, 'F12', 123, 'VK_F12', empty, empty],\n [1, 76 /* ScanCode.PrintScreen */, 'PrintScreen', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 77 /* ScanCode.ScrollLock */, 'ScrollLock', 84 /* KeyCode.ScrollLock */, 'ScrollLock', 145, 'VK_SCROLL', empty, empty],\n [1, 78 /* ScanCode.Pause */, 'Pause', 7 /* KeyCode.PauseBreak */, 'PauseBreak', 19, 'VK_PAUSE', empty, empty],\n [1, 79 /* ScanCode.Insert */, 'Insert', 19 /* KeyCode.Insert */, 'Insert', 45, 'VK_INSERT', empty, empty],\n [1, 80 /* ScanCode.Home */, 'Home', 14 /* KeyCode.Home */, 'Home', 36, 'VK_HOME', empty, empty],\n [1, 81 /* ScanCode.PageUp */, 'PageUp', 11 /* KeyCode.PageUp */, 'PageUp', 33, 'VK_PRIOR', empty, empty],\n [1, 82 /* ScanCode.Delete */, 'Delete', 20 /* KeyCode.Delete */, 'Delete', 46, 'VK_DELETE', empty, empty],\n [1, 83 /* ScanCode.End */, 'End', 13 /* KeyCode.End */, 'End', 35, 'VK_END', empty, empty],\n [1, 84 /* ScanCode.PageDown */, 'PageDown', 12 /* KeyCode.PageDown */, 'PageDown', 34, 'VK_NEXT', empty, empty],\n [1, 85 /* ScanCode.ArrowRight */, 'ArrowRight', 17 /* KeyCode.RightArrow */, 'RightArrow', 39, 'VK_RIGHT', 'Right', empty],\n [1, 86 /* ScanCode.ArrowLeft */, 'ArrowLeft', 15 /* KeyCode.LeftArrow */, 'LeftArrow', 37, 'VK_LEFT', 'Left', empty],\n [1, 87 /* ScanCode.ArrowDown */, 'ArrowDown', 18 /* KeyCode.DownArrow */, 'DownArrow', 40, 'VK_DOWN', 'Down', empty],\n [1, 88 /* ScanCode.ArrowUp */, 'ArrowUp', 16 /* KeyCode.UpArrow */, 'UpArrow', 38, 'VK_UP', 'Up', empty],\n [1, 89 /* ScanCode.NumLock */, 'NumLock', 83 /* KeyCode.NumLock */, 'NumLock', 144, 'VK_NUMLOCK', empty, empty],\n [1, 90 /* ScanCode.NumpadDivide */, 'NumpadDivide', 113 /* KeyCode.NumpadDivide */, 'NumPad_Divide', 111, 'VK_DIVIDE', empty, empty],\n [1, 91 /* ScanCode.NumpadMultiply */, 'NumpadMultiply', 108 /* KeyCode.NumpadMultiply */, 'NumPad_Multiply', 106, 'VK_MULTIPLY', empty, empty],\n [1, 92 /* ScanCode.NumpadSubtract */, 'NumpadSubtract', 111 /* KeyCode.NumpadSubtract */, 'NumPad_Subtract', 109, 'VK_SUBTRACT', empty, empty],\n [1, 93 /* ScanCode.NumpadAdd */, 'NumpadAdd', 109 /* KeyCode.NumpadAdd */, 'NumPad_Add', 107, 'VK_ADD', empty, empty],\n [1, 94 /* ScanCode.NumpadEnter */, 'NumpadEnter', 3 /* KeyCode.Enter */, empty, 0, empty, empty, empty],\n [1, 95 /* ScanCode.Numpad1 */, 'Numpad1', 99 /* KeyCode.Numpad1 */, 'NumPad1', 97, 'VK_NUMPAD1', empty, empty],\n [1, 96 /* ScanCode.Numpad2 */, 'Numpad2', 100 /* KeyCode.Numpad2 */, 'NumPad2', 98, 'VK_NUMPAD2', empty, empty],\n [1, 97 /* ScanCode.Numpad3 */, 'Numpad3', 101 /* KeyCode.Numpad3 */, 'NumPad3', 99, 'VK_NUMPAD3', empty, empty],\n [1, 98 /* ScanCode.Numpad4 */, 'Numpad4', 102 /* KeyCode.Numpad4 */, 'NumPad4', 100, 'VK_NUMPAD4', empty, empty],\n [1, 99 /* ScanCode.Numpad5 */, 'Numpad5', 103 /* KeyCode.Numpad5 */, 'NumPad5', 101, 'VK_NUMPAD5', empty, empty],\n [1, 100 /* ScanCode.Numpad6 */, 'Numpad6', 104 /* KeyCode.Numpad6 */, 'NumPad6', 102, 'VK_NUMPAD6', empty, empty],\n [1, 101 /* ScanCode.Numpad7 */, 'Numpad7', 105 /* KeyCode.Numpad7 */, 'NumPad7', 103, 'VK_NUMPAD7', empty, empty],\n [1, 102 /* ScanCode.Numpad8 */, 'Numpad8', 106 /* KeyCode.Numpad8 */, 'NumPad8', 104, 'VK_NUMPAD8', empty, empty],\n [1, 103 /* ScanCode.Numpad9 */, 'Numpad9', 107 /* KeyCode.Numpad9 */, 'NumPad9', 105, 'VK_NUMPAD9', empty, empty],\n [1, 104 /* ScanCode.Numpad0 */, 'Numpad0', 98 /* KeyCode.Numpad0 */, 'NumPad0', 96, 'VK_NUMPAD0', empty, empty],\n [1, 105 /* ScanCode.NumpadDecimal */, 'NumpadDecimal', 112 /* KeyCode.NumpadDecimal */, 'NumPad_Decimal', 110, 'VK_DECIMAL', empty, empty],\n [0, 106 /* ScanCode.IntlBackslash */, 'IntlBackslash', 97 /* KeyCode.IntlBackslash */, 'OEM_102', 226, 'VK_OEM_102', empty, empty],\n [1, 107 /* ScanCode.ContextMenu */, 'ContextMenu', 58 /* KeyCode.ContextMenu */, 'ContextMenu', 93, empty, empty, empty],\n [1, 108 /* ScanCode.Power */, 'Power', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 109 /* ScanCode.NumpadEqual */, 'NumpadEqual', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 110 /* ScanCode.F13 */, 'F13', 71 /* KeyCode.F13 */, 'F13', 124, 'VK_F13', empty, empty],\n [1, 111 /* ScanCode.F14 */, 'F14', 72 /* KeyCode.F14 */, 'F14', 125, 'VK_F14', empty, empty],\n [1, 112 /* ScanCode.F15 */, 'F15', 73 /* KeyCode.F15 */, 'F15', 126, 'VK_F15', empty, empty],\n [1, 113 /* ScanCode.F16 */, 'F16', 74 /* KeyCode.F16 */, 'F16', 127, 'VK_F16', empty, empty],\n [1, 114 /* ScanCode.F17 */, 'F17', 75 /* KeyCode.F17 */, 'F17', 128, 'VK_F17', empty, empty],\n [1, 115 /* ScanCode.F18 */, 'F18', 76 /* KeyCode.F18 */, 'F18', 129, 'VK_F18', empty, empty],\n [1, 116 /* ScanCode.F19 */, 'F19', 77 /* KeyCode.F19 */, 'F19', 130, 'VK_F19', empty, empty],\n [1, 117 /* ScanCode.F20 */, 'F20', 78 /* KeyCode.F20 */, 'F20', 131, 'VK_F20', empty, empty],\n [1, 118 /* ScanCode.F21 */, 'F21', 79 /* KeyCode.F21 */, 'F21', 132, 'VK_F21', empty, empty],\n [1, 119 /* ScanCode.F22 */, 'F22', 80 /* KeyCode.F22 */, 'F22', 133, 'VK_F22', empty, empty],\n [1, 120 /* ScanCode.F23 */, 'F23', 81 /* KeyCode.F23 */, 'F23', 134, 'VK_F23', empty, empty],\n [1, 121 /* ScanCode.F24 */, 'F24', 82 /* KeyCode.F24 */, 'F24', 135, 'VK_F24', empty, empty],\n [1, 122 /* ScanCode.Open */, 'Open', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 123 /* ScanCode.Help */, 'Help', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 124 /* ScanCode.Select */, 'Select', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 125 /* ScanCode.Again */, 'Again', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 126 /* ScanCode.Undo */, 'Undo', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 127 /* ScanCode.Cut */, 'Cut', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 128 /* ScanCode.Copy */, 'Copy', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 129 /* ScanCode.Paste */, 'Paste', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 130 /* ScanCode.Find */, 'Find', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 131 /* ScanCode.AudioVolumeMute */, 'AudioVolumeMute', 117 /* KeyCode.AudioVolumeMute */, 'AudioVolumeMute', 173, 'VK_VOLUME_MUTE', empty, empty],\n [1, 132 /* ScanCode.AudioVolumeUp */, 'AudioVolumeUp', 118 /* KeyCode.AudioVolumeUp */, 'AudioVolumeUp', 175, 'VK_VOLUME_UP', empty, empty],\n [1, 133 /* ScanCode.AudioVolumeDown */, 'AudioVolumeDown', 119 /* KeyCode.AudioVolumeDown */, 'AudioVolumeDown', 174, 'VK_VOLUME_DOWN', empty, empty],\n [1, 134 /* ScanCode.NumpadComma */, 'NumpadComma', 110 /* KeyCode.NUMPAD_SEPARATOR */, 'NumPad_Separator', 108, 'VK_SEPARATOR', empty, empty],\n [0, 135 /* ScanCode.IntlRo */, 'IntlRo', 115 /* KeyCode.ABNT_C1 */, 'ABNT_C1', 193, 'VK_ABNT_C1', empty, empty],\n [1, 136 /* ScanCode.KanaMode */, 'KanaMode', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [0, 137 /* ScanCode.IntlYen */, 'IntlYen', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 138 /* ScanCode.Convert */, 'Convert', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 139 /* ScanCode.NonConvert */, 'NonConvert', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 140 /* ScanCode.Lang1 */, 'Lang1', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 141 /* ScanCode.Lang2 */, 'Lang2', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 142 /* ScanCode.Lang3 */, 'Lang3', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 143 /* ScanCode.Lang4 */, 'Lang4', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 144 /* ScanCode.Lang5 */, 'Lang5', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 145 /* ScanCode.Abort */, 'Abort', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 146 /* ScanCode.Props */, 'Props', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 147 /* ScanCode.NumpadParenLeft */, 'NumpadParenLeft', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 148 /* ScanCode.NumpadParenRight */, 'NumpadParenRight', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 149 /* ScanCode.NumpadBackspace */, 'NumpadBackspace', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 150 /* ScanCode.NumpadMemoryStore */, 'NumpadMemoryStore', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 151 /* ScanCode.NumpadMemoryRecall */, 'NumpadMemoryRecall', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 152 /* ScanCode.NumpadMemoryClear */, 'NumpadMemoryClear', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 153 /* ScanCode.NumpadMemoryAdd */, 'NumpadMemoryAdd', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 154 /* ScanCode.NumpadMemorySubtract */, 'NumpadMemorySubtract', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 155 /* ScanCode.NumpadClear */, 'NumpadClear', 131 /* KeyCode.Clear */, 'Clear', 12, 'VK_CLEAR', empty, empty],\n [1, 156 /* ScanCode.NumpadClearEntry */, 'NumpadClearEntry', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 0 /* ScanCode.None */, empty, 5 /* KeyCode.Ctrl */, 'Ctrl', 17, 'VK_CONTROL', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 4 /* KeyCode.Shift */, 'Shift', 16, 'VK_SHIFT', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 6 /* KeyCode.Alt */, 'Alt', 18, 'VK_MENU', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 57 /* KeyCode.Meta */, 'Meta', 91, 'VK_COMMAND', empty, empty],\n [1, 157 /* ScanCode.ControlLeft */, 'ControlLeft', 5 /* KeyCode.Ctrl */, empty, 0, 'VK_LCONTROL', empty, empty],\n [1, 158 /* ScanCode.ShiftLeft */, 'ShiftLeft', 4 /* KeyCode.Shift */, empty, 0, 'VK_LSHIFT', empty, empty],\n [1, 159 /* ScanCode.AltLeft */, 'AltLeft', 6 /* KeyCode.Alt */, empty, 0, 'VK_LMENU', empty, empty],\n [1, 160 /* ScanCode.MetaLeft */, 'MetaLeft', 57 /* KeyCode.Meta */, empty, 0, 'VK_LWIN', empty, empty],\n [1, 161 /* ScanCode.ControlRight */, 'ControlRight', 5 /* KeyCode.Ctrl */, empty, 0, 'VK_RCONTROL', empty, empty],\n [1, 162 /* ScanCode.ShiftRight */, 'ShiftRight', 4 /* KeyCode.Shift */, empty, 0, 'VK_RSHIFT', empty, empty],\n [1, 163 /* ScanCode.AltRight */, 'AltRight', 6 /* KeyCode.Alt */, empty, 0, 'VK_RMENU', empty, empty],\n [1, 164 /* ScanCode.MetaRight */, 'MetaRight', 57 /* KeyCode.Meta */, empty, 0, 'VK_RWIN', empty, empty],\n [1, 165 /* ScanCode.BrightnessUp */, 'BrightnessUp', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 166 /* ScanCode.BrightnessDown */, 'BrightnessDown', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 167 /* ScanCode.MediaPlay */, 'MediaPlay', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 168 /* ScanCode.MediaRecord */, 'MediaRecord', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 169 /* ScanCode.MediaFastForward */, 'MediaFastForward', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 170 /* ScanCode.MediaRewind */, 'MediaRewind', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 171 /* ScanCode.MediaTrackNext */, 'MediaTrackNext', 124 /* KeyCode.MediaTrackNext */, 'MediaTrackNext', 176, 'VK_MEDIA_NEXT_TRACK', empty, empty],\n [1, 172 /* ScanCode.MediaTrackPrevious */, 'MediaTrackPrevious', 125 /* KeyCode.MediaTrackPrevious */, 'MediaTrackPrevious', 177, 'VK_MEDIA_PREV_TRACK', empty, empty],\n [1, 173 /* ScanCode.MediaStop */, 'MediaStop', 126 /* KeyCode.MediaStop */, 'MediaStop', 178, 'VK_MEDIA_STOP', empty, empty],\n [1, 174 /* ScanCode.Eject */, 'Eject', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 175 /* ScanCode.MediaPlayPause */, 'MediaPlayPause', 127 /* KeyCode.MediaPlayPause */, 'MediaPlayPause', 179, 'VK_MEDIA_PLAY_PAUSE', empty, empty],\n [1, 176 /* ScanCode.MediaSelect */, 'MediaSelect', 128 /* KeyCode.LaunchMediaPlayer */, 'LaunchMediaPlayer', 181, 'VK_MEDIA_LAUNCH_MEDIA_SELECT', empty, empty],\n [1, 177 /* ScanCode.LaunchMail */, 'LaunchMail', 129 /* KeyCode.LaunchMail */, 'LaunchMail', 180, 'VK_MEDIA_LAUNCH_MAIL', empty, empty],\n [1, 178 /* ScanCode.LaunchApp2 */, 'LaunchApp2', 130 /* KeyCode.LaunchApp2 */, 'LaunchApp2', 183, 'VK_MEDIA_LAUNCH_APP2', empty, empty],\n [1, 179 /* ScanCode.LaunchApp1 */, 'LaunchApp1', 0 /* KeyCode.Unknown */, empty, 0, 'VK_MEDIA_LAUNCH_APP1', empty, empty],\n [1, 180 /* ScanCode.SelectTask */, 'SelectTask', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 181 /* ScanCode.LaunchScreenSaver */, 'LaunchScreenSaver', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 182 /* ScanCode.BrowserSearch */, 'BrowserSearch', 120 /* KeyCode.BrowserSearch */, 'BrowserSearch', 170, 'VK_BROWSER_SEARCH', empty, empty],\n [1, 183 /* ScanCode.BrowserHome */, 'BrowserHome', 121 /* KeyCode.BrowserHome */, 'BrowserHome', 172, 'VK_BROWSER_HOME', empty, empty],\n [1, 184 /* ScanCode.BrowserBack */, 'BrowserBack', 122 /* KeyCode.BrowserBack */, 'BrowserBack', 166, 'VK_BROWSER_BACK', empty, empty],\n [1, 185 /* ScanCode.BrowserForward */, 'BrowserForward', 123 /* KeyCode.BrowserForward */, 'BrowserForward', 167, 'VK_BROWSER_FORWARD', empty, empty],\n [1, 186 /* ScanCode.BrowserStop */, 'BrowserStop', 0 /* KeyCode.Unknown */, empty, 0, 'VK_BROWSER_STOP', empty, empty],\n [1, 187 /* ScanCode.BrowserRefresh */, 'BrowserRefresh', 0 /* KeyCode.Unknown */, empty, 0, 'VK_BROWSER_REFRESH', empty, empty],\n [1, 188 /* ScanCode.BrowserFavorites */, 'BrowserFavorites', 0 /* KeyCode.Unknown */, empty, 0, 'VK_BROWSER_FAVORITES', empty, empty],\n [1, 189 /* ScanCode.ZoomToggle */, 'ZoomToggle', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 190 /* ScanCode.MailReply */, 'MailReply', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 191 /* ScanCode.MailForward */, 'MailForward', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n [1, 192 /* ScanCode.MailSend */, 'MailSend', 0 /* KeyCode.Unknown */, empty, 0, empty, empty, empty],\n // See https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html\n // If an Input Method Editor is processing key input and the event is keydown, return 229.\n [1, 0 /* ScanCode.None */, empty, 114 /* KeyCode.KEY_IN_COMPOSITION */, 'KeyInComposition', 229, empty, empty, empty],\n [1, 0 /* ScanCode.None */, empty, 116 /* KeyCode.ABNT_C2 */, 'ABNT_C2', 194, 'VK_ABNT_C2', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 96 /* KeyCode.OEM_8 */, 'OEM_8', 223, 'VK_OEM_8', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_KANA', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_HANGUL', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_JUNJA', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_FINAL', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_HANJA', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_KANJI', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_CONVERT', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_NONCONVERT', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_ACCEPT', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_MODECHANGE', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_SELECT', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PRINT', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_EXECUTE', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_SNAPSHOT', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_HELP', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_APPS', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PROCESSKEY', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PACKET', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_DBE_SBCSCHAR', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_DBE_DBCSCHAR', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_ATTN', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_CRSEL', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_EXSEL', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_EREOF', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PLAY', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_ZOOM', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_NONAME', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_PA1', empty, empty],\n [1, 0 /* ScanCode.None */, empty, 0 /* KeyCode.Unknown */, empty, 0, 'VK_OEM_CLEAR', empty, empty],\n ];\n const seenKeyCode = [];\n const seenScanCode = [];\n for (const mapping of mappings) {\n const [immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel] = mapping;\n if (!seenScanCode[scanCode]) {\n seenScanCode[scanCode] = true;\n scanCodeIntToStr[scanCode] = scanCodeStr;\n scanCodeStrToInt[scanCodeStr] = scanCode;\n scanCodeLowerCaseStrToInt[scanCodeStr.toLowerCase()] = scanCode;\n if (immutable) {\n IMMUTABLE_CODE_TO_KEY_CODE[scanCode] = keyCode;\n if ((keyCode !== 0 /* KeyCode.Unknown */)\n && (keyCode !== 3 /* KeyCode.Enter */)\n && (keyCode !== 5 /* KeyCode.Ctrl */)\n && (keyCode !== 4 /* KeyCode.Shift */)\n && (keyCode !== 6 /* KeyCode.Alt */)\n && (keyCode !== 57 /* KeyCode.Meta */)) {\n IMMUTABLE_KEY_CODE_TO_CODE[keyCode] = scanCode;\n }\n }\n }\n if (!seenKeyCode[keyCode]) {\n seenKeyCode[keyCode] = true;\n if (!keyCodeStr) {\n throw new Error(`String representation missing for key code ${keyCode} around scan code ${scanCodeStr}`);\n }\n uiMap.define(keyCode, keyCodeStr);\n userSettingsUSMap.define(keyCode, usUserSettingsLabel || keyCodeStr);\n userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel || usUserSettingsLabel || keyCodeStr);\n }\n if (eventKeyCode) {\n EVENT_KEY_CODE_MAP[eventKeyCode] = keyCode;\n }\n if (vkey) {\n NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[vkey] = keyCode;\n }\n }\n // Manually added due to the exclusion above (due to duplication with NumpadEnter)\n IMMUTABLE_KEY_CODE_TO_CODE[3 /* KeyCode.Enter */] = 46 /* ScanCode.Enter */;\n})();\nexport var KeyCodeUtils;\n(function (KeyCodeUtils) {\n function toString(keyCode) {\n return uiMap.keyCodeToStr(keyCode);\n }\n KeyCodeUtils.toString = toString;\n function fromString(key) {\n return uiMap.strToKeyCode(key);\n }\n KeyCodeUtils.fromString = fromString;\n function toUserSettingsUS(keyCode) {\n return userSettingsUSMap.keyCodeToStr(keyCode);\n }\n KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;\n function toUserSettingsGeneral(keyCode) {\n return userSettingsGeneralMap.keyCodeToStr(keyCode);\n }\n KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;\n function fromUserSettings(key) {\n return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);\n }\n KeyCodeUtils.fromUserSettings = fromUserSettings;\n function toElectronAccelerator(keyCode) {\n if (keyCode >= 98 /* KeyCode.Numpad0 */ && keyCode <= 113 /* KeyCode.NumpadDivide */) {\n // [Electron Accelerators] Electron is able to parse numpad keys, but unfortunately it\n // renders them just as regular keys in menus. For example, num0 is rendered as \"0\",\n // numdiv is rendered as \"/\", numsub is rendered as \"-\".\n //\n // This can lead to incredible confusion, as it makes numpad based keybindings indistinguishable\n // from keybindings based on regular keys.\n //\n // We therefore need to fall back to custom rendering for numpad keys.\n return null;\n }\n switch (keyCode) {\n case 16 /* KeyCode.UpArrow */:\n return 'Up';\n case 18 /* KeyCode.DownArrow */:\n return 'Down';\n case 15 /* KeyCode.LeftArrow */:\n return 'Left';\n case 17 /* KeyCode.RightArrow */:\n return 'Right';\n }\n return uiMap.keyCodeToStr(keyCode);\n }\n KeyCodeUtils.toElectronAccelerator = toElectronAccelerator;\n})(KeyCodeUtils || (KeyCodeUtils = {}));\nexport function KeyChord(firstPart, secondPart) {\n const chordPart = ((secondPart & 0x0000FFFF) << 16) >>> 0;\n return (firstPart | chordPart) >>> 0;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class Lazy {\n constructor(executor) {\n this.executor = executor;\n this._didRun = false;\n }\n /**\n * Get the wrapped value.\n *\n * This will force evaluation of the lazy value if it has not been resolved yet. Lazy values are only\n * resolved once. `getValue` will re-throw exceptions that are hit while resolving the value\n */\n get value() {\n if (!this._didRun) {\n try {\n this._value = this.executor();\n }\n catch (err) {\n this._error = err;\n }\n finally {\n this._didRun = true;\n }\n }\n if (this._error) {\n throw this._error;\n }\n return this._value;\n }\n /**\n * Get the wrapped value without forcing evaluation.\n */\n get rawValue() { return this._value; }\n}\n","import { createSingleCallFunction } from './functional.js';\nimport { Iterable } from './iterator.js';\n// #region Disposable Tracking\n/**\n * Enables logging of potentially leaked disposables.\n *\n * A disposable is considered leaked if it is not disposed or not registered as the child of\n * another disposable. This tracking is very simple an only works for classes that either\n * extend Disposable or use a DisposableStore. This means there are a lot of false positives.\n */\nconst TRACK_DISPOSABLES = false;\nlet disposableTracker = null;\nexport function setDisposableTracker(tracker) {\n disposableTracker = tracker;\n}\nif (TRACK_DISPOSABLES) {\n const __is_disposable_tracked__ = '__is_disposable_tracked__';\n setDisposableTracker(new class {\n trackDisposable(x) {\n const stack = new Error('Potentially leaked disposable').stack;\n setTimeout(() => {\n if (!x[__is_disposable_tracked__]) {\n console.log(stack);\n }\n }, 3000);\n }\n setParent(child, parent) {\n if (child && child !== Disposable.None) {\n try {\n child[__is_disposable_tracked__] = true;\n }\n catch (_a) {\n // noop\n }\n }\n }\n markAsDisposed(disposable) {\n if (disposable && disposable !== Disposable.None) {\n try {\n disposable[__is_disposable_tracked__] = true;\n }\n catch (_a) {\n // noop\n }\n }\n }\n markAsSingleton(disposable) { }\n });\n}\nexport function trackDisposable(x) {\n disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.trackDisposable(x);\n return x;\n}\nexport function markAsDisposed(disposable) {\n disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsDisposed(disposable);\n}\nfunction setParentOfDisposable(child, parent) {\n disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.setParent(child, parent);\n}\nfunction setParentOfDisposables(children, parent) {\n if (!disposableTracker) {\n return;\n }\n for (const child of children) {\n disposableTracker.setParent(child, parent);\n }\n}\n/**\n * Indicates that the given object is a singleton which does not need to be disposed.\n*/\nexport function markAsSingleton(singleton) {\n disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsSingleton(singleton);\n return singleton;\n}\n/**\n * Check if `thing` is {@link IDisposable disposable}.\n */\nexport function isDisposable(thing) {\n return typeof thing.dispose === 'function' && thing.dispose.length === 0;\n}\nexport function dispose(arg) {\n if (Iterable.is(arg)) {\n const errors = [];\n for (const d of arg) {\n if (d) {\n try {\n d.dispose();\n }\n catch (e) {\n errors.push(e);\n }\n }\n }\n if (errors.length === 1) {\n throw errors[0];\n }\n else if (errors.length > 1) {\n throw new AggregateError(errors, 'Encountered errors while disposing of store');\n }\n return Array.isArray(arg) ? [] : arg;\n }\n else if (arg) {\n arg.dispose();\n return arg;\n }\n}\n/**\n * Combine multiple disposable values into a single {@link IDisposable}.\n */\nexport function combinedDisposable(...disposables) {\n const parent = toDisposable(() => dispose(disposables));\n setParentOfDisposables(disposables, parent);\n return parent;\n}\n/**\n * Turn a function that implements dispose into an {@link IDisposable}.\n *\n * @param fn Clean up function, guaranteed to be called only **once**.\n */\nexport function toDisposable(fn) {\n const self = trackDisposable({\n dispose: createSingleCallFunction(() => {\n markAsDisposed(self);\n fn();\n })\n });\n return self;\n}\n/**\n * Manages a collection of disposable values.\n *\n * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an\n * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a\n * store that has already been disposed of.\n */\nexport class DisposableStore {\n constructor() {\n this._toDispose = new Set();\n this._isDisposed = false;\n trackDisposable(this);\n }\n /**\n * Dispose of all registered disposables and mark this object as disposed.\n *\n * Any future disposables added to this object will be disposed of on `add`.\n */\n dispose() {\n if (this._isDisposed) {\n return;\n }\n markAsDisposed(this);\n this._isDisposed = true;\n this.clear();\n }\n /**\n * @return `true` if this object has been disposed of.\n */\n get isDisposed() {\n return this._isDisposed;\n }\n /**\n * Dispose of all registered disposables but do not mark this object as disposed.\n */\n clear() {\n if (this._toDispose.size === 0) {\n return;\n }\n try {\n dispose(this._toDispose);\n }\n finally {\n this._toDispose.clear();\n }\n }\n /**\n * Add a new {@link IDisposable disposable} to the collection.\n */\n add(o) {\n if (!o) {\n return o;\n }\n if (o === this) {\n throw new Error('Cannot register a disposable on itself!');\n }\n setParentOfDisposable(o, this);\n if (this._isDisposed) {\n if (!DisposableStore.DISABLE_DISPOSED_WARNING) {\n console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);\n }\n }\n else {\n this._toDispose.add(o);\n }\n return o;\n }\n /**\n * Deletes the value from the store, but does not dispose it.\n */\n deleteAndLeak(o) {\n if (!o) {\n return;\n }\n if (this._toDispose.has(o)) {\n this._toDispose.delete(o);\n setParentOfDisposable(o, null);\n }\n }\n}\nDisposableStore.DISABLE_DISPOSED_WARNING = false;\n/**\n * Abstract base class for a {@link IDisposable disposable} object.\n *\n * Subclasses can {@linkcode _register} disposables that will be automatically cleaned up when this object is disposed of.\n */\nexport class Disposable {\n constructor() {\n this._store = new DisposableStore();\n trackDisposable(this);\n setParentOfDisposable(this._store, this);\n }\n dispose() {\n markAsDisposed(this);\n this._store.dispose();\n }\n /**\n * Adds `o` to the collection of disposables managed by this object.\n */\n _register(o) {\n if (o === this) {\n throw new Error('Cannot register a disposable on itself!');\n }\n return this._store.add(o);\n }\n}\n/**\n * A disposable that does nothing when it is disposed of.\n *\n * TODO: This should not be a static property.\n */\nDisposable.None = Object.freeze({ dispose() { } });\n/**\n * Manages the lifecycle of a disposable value that may be changed.\n *\n * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can\n * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.\n */\nexport class MutableDisposable {\n constructor() {\n this._isDisposed = false;\n trackDisposable(this);\n }\n get value() {\n return this._isDisposed ? undefined : this._value;\n }\n set value(value) {\n var _a;\n if (this._isDisposed || value === this._value) {\n return;\n }\n (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();\n if (value) {\n setParentOfDisposable(value, this);\n }\n this._value = value;\n }\n /**\n * Resets the stored value and disposed of the previously stored value.\n */\n clear() {\n this.value = undefined;\n }\n dispose() {\n var _a;\n this._isDisposed = true;\n markAsDisposed(this);\n (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();\n this._value = undefined;\n }\n}\nexport class RefCountedDisposable {\n constructor(_disposable) {\n this._disposable = _disposable;\n this._counter = 1;\n }\n acquire() {\n this._counter++;\n return this;\n }\n release() {\n if (--this._counter === 0) {\n this._disposable.dispose();\n }\n return this;\n }\n}\nexport class ImmortalReference {\n constructor(object) {\n this.object = object;\n }\n dispose() { }\n}\n/**\n * A map the manages the lifecycle of the values that it stores.\n */\nexport class DisposableMap {\n constructor() {\n this._store = new Map();\n this._isDisposed = false;\n trackDisposable(this);\n }\n /**\n * Disposes of all stored values and mark this object as disposed.\n *\n * Trying to use this object after it has been disposed of is an error.\n */\n dispose() {\n markAsDisposed(this);\n this._isDisposed = true;\n this.clearAndDisposeAll();\n }\n /**\n * Disposes of all stored values and clear the map, but DO NOT mark this object as disposed.\n */\n clearAndDisposeAll() {\n if (!this._store.size) {\n return;\n }\n try {\n dispose(this._store.values());\n }\n finally {\n this._store.clear();\n }\n }\n get(key) {\n return this._store.get(key);\n }\n set(key, value, skipDisposeOnOverwrite = false) {\n var _a;\n if (this._isDisposed) {\n console.warn(new Error('Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!').stack);\n }\n if (!skipDisposeOnOverwrite) {\n (_a = this._store.get(key)) === null || _a === void 0 ? void 0 : _a.dispose();\n }\n this._store.set(key, value);\n }\n /**\n * Delete the value stored for `key` from this map and also dispose of it.\n */\n deleteAndDispose(key) {\n var _a;\n (_a = this._store.get(key)) === null || _a === void 0 ? void 0 : _a.dispose();\n this._store.delete(key);\n }\n [Symbol.iterator]() {\n return this._store[Symbol.iterator]();\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nclass Node {\n constructor(element) {\n this.element = element;\n this.next = Node.Undefined;\n this.prev = Node.Undefined;\n }\n}\nNode.Undefined = new Node(undefined);\nexport class LinkedList {\n constructor() {\n this._first = Node.Undefined;\n this._last = Node.Undefined;\n this._size = 0;\n }\n get size() {\n return this._size;\n }\n isEmpty() {\n return this._first === Node.Undefined;\n }\n clear() {\n let node = this._first;\n while (node !== Node.Undefined) {\n const next = node.next;\n node.prev = Node.Undefined;\n node.next = Node.Undefined;\n node = next;\n }\n this._first = Node.Undefined;\n this._last = Node.Undefined;\n this._size = 0;\n }\n unshift(element) {\n return this._insert(element, false);\n }\n push(element) {\n return this._insert(element, true);\n }\n _insert(element, atTheEnd) {\n const newNode = new Node(element);\n if (this._first === Node.Undefined) {\n this._first = newNode;\n this._last = newNode;\n }\n else if (atTheEnd) {\n // push\n const oldLast = this._last;\n this._last = newNode;\n newNode.prev = oldLast;\n oldLast.next = newNode;\n }\n else {\n // unshift\n const oldFirst = this._first;\n this._first = newNode;\n newNode.next = oldFirst;\n oldFirst.prev = newNode;\n }\n this._size += 1;\n let didRemove = false;\n return () => {\n if (!didRemove) {\n didRemove = true;\n this._remove(newNode);\n }\n };\n }\n shift() {\n if (this._first === Node.Undefined) {\n return undefined;\n }\n else {\n const res = this._first.element;\n this._remove(this._first);\n return res;\n }\n }\n pop() {\n if (this._last === Node.Undefined) {\n return undefined;\n }\n else {\n const res = this._last.element;\n this._remove(this._last);\n return res;\n }\n }\n _remove(node) {\n if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {\n // middle\n const anchor = node.prev;\n anchor.next = node.next;\n node.next.prev = anchor;\n }\n else if (node.prev === Node.Undefined && node.next === Node.Undefined) {\n // only node\n this._first = Node.Undefined;\n this._last = Node.Undefined;\n }\n else if (node.next === Node.Undefined) {\n // last\n this._last = this._last.prev;\n this._last.next = Node.Undefined;\n }\n else if (node.prev === Node.Undefined) {\n // first\n this._first = this._first.next;\n this._first.prev = Node.Undefined;\n }\n // done\n this._size -= 1;\n }\n *[Symbol.iterator]() {\n let node = this._first;\n while (node !== Node.Undefined) {\n yield node.element;\n node = node.next;\n }\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar _a, _b;\nclass ResourceMapEntry {\n constructor(uri, value) {\n this.uri = uri;\n this.value = value;\n }\n}\nfunction isEntries(arg) {\n return Array.isArray(arg);\n}\nexport class ResourceMap {\n constructor(arg, toKey) {\n this[_a] = 'ResourceMap';\n if (arg instanceof ResourceMap) {\n this.map = new Map(arg.map);\n this.toKey = toKey !== null && toKey !== void 0 ? toKey : ResourceMap.defaultToKey;\n }\n else if (isEntries(arg)) {\n this.map = new Map();\n this.toKey = toKey !== null && toKey !== void 0 ? toKey : ResourceMap.defaultToKey;\n for (const [resource, value] of arg) {\n this.set(resource, value);\n }\n }\n else {\n this.map = new Map();\n this.toKey = arg !== null && arg !== void 0 ? arg : ResourceMap.defaultToKey;\n }\n }\n set(resource, value) {\n this.map.set(this.toKey(resource), new ResourceMapEntry(resource, value));\n return this;\n }\n get(resource) {\n var _c;\n return (_c = this.map.get(this.toKey(resource))) === null || _c === void 0 ? void 0 : _c.value;\n }\n has(resource) {\n return this.map.has(this.toKey(resource));\n }\n get size() {\n return this.map.size;\n }\n clear() {\n this.map.clear();\n }\n delete(resource) {\n return this.map.delete(this.toKey(resource));\n }\n forEach(clb, thisArg) {\n if (typeof thisArg !== 'undefined') {\n clb = clb.bind(thisArg);\n }\n for (const [_, entry] of this.map) {\n clb(entry.value, entry.uri, this);\n }\n }\n *values() {\n for (const entry of this.map.values()) {\n yield entry.value;\n }\n }\n *keys() {\n for (const entry of this.map.values()) {\n yield entry.uri;\n }\n }\n *entries() {\n for (const entry of this.map.values()) {\n yield [entry.uri, entry.value];\n }\n }\n *[(_a = Symbol.toStringTag, Symbol.iterator)]() {\n for (const [, entry] of this.map) {\n yield [entry.uri, entry.value];\n }\n }\n}\nResourceMap.defaultToKey = (resource) => resource.toString();\nexport class LinkedMap {\n constructor() {\n this[_b] = 'LinkedMap';\n this._map = new Map();\n this._head = undefined;\n this._tail = undefined;\n this._size = 0;\n this._state = 0;\n }\n clear() {\n this._map.clear();\n this._head = undefined;\n this._tail = undefined;\n this._size = 0;\n this._state++;\n }\n isEmpty() {\n return !this._head && !this._tail;\n }\n get size() {\n return this._size;\n }\n get first() {\n var _c;\n return (_c = this._head) === null || _c === void 0 ? void 0 : _c.value;\n }\n get last() {\n var _c;\n return (_c = this._tail) === null || _c === void 0 ? void 0 : _c.value;\n }\n has(key) {\n return this._map.has(key);\n }\n get(key, touch = 0 /* Touch.None */) {\n const item = this._map.get(key);\n if (!item) {\n return undefined;\n }\n if (touch !== 0 /* Touch.None */) {\n this.touch(item, touch);\n }\n return item.value;\n }\n set(key, value, touch = 0 /* Touch.None */) {\n let item = this._map.get(key);\n if (item) {\n item.value = value;\n if (touch !== 0 /* Touch.None */) {\n this.touch(item, touch);\n }\n }\n else {\n item = { key, value, next: undefined, previous: undefined };\n switch (touch) {\n case 0 /* Touch.None */:\n this.addItemLast(item);\n break;\n case 1 /* Touch.AsOld */:\n this.addItemFirst(item);\n break;\n case 2 /* Touch.AsNew */:\n this.addItemLast(item);\n break;\n default:\n this.addItemLast(item);\n break;\n }\n this._map.set(key, item);\n this._size++;\n }\n return this;\n }\n delete(key) {\n return !!this.remove(key);\n }\n remove(key) {\n const item = this._map.get(key);\n if (!item) {\n return undefined;\n }\n this._map.delete(key);\n this.removeItem(item);\n this._size--;\n return item.value;\n }\n shift() {\n if (!this._head && !this._tail) {\n return undefined;\n }\n if (!this._head || !this._tail) {\n throw new Error('Invalid list');\n }\n const item = this._head;\n this._map.delete(item.key);\n this.removeItem(item);\n this._size--;\n return item.value;\n }\n forEach(callbackfn, thisArg) {\n const state = this._state;\n let current = this._head;\n while (current) {\n if (thisArg) {\n callbackfn.bind(thisArg)(current.value, current.key, this);\n }\n else {\n callbackfn(current.value, current.key, this);\n }\n if (this._state !== state) {\n throw new Error(`LinkedMap got modified during iteration.`);\n }\n current = current.next;\n }\n }\n keys() {\n const map = this;\n const state = this._state;\n let current = this._head;\n const iterator = {\n [Symbol.iterator]() {\n return iterator;\n },\n next() {\n if (map._state !== state) {\n throw new Error(`LinkedMap got modified during iteration.`);\n }\n if (current) {\n const result = { value: current.key, done: false };\n current = current.next;\n return result;\n }\n else {\n return { value: undefined, done: true };\n }\n }\n };\n return iterator;\n }\n values() {\n const map = this;\n const state = this._state;\n let current = this._head;\n const iterator = {\n [Symbol.iterator]() {\n return iterator;\n },\n next() {\n if (map._state !== state) {\n throw new Error(`LinkedMap got modified during iteration.`);\n }\n if (current) {\n const result = { value: current.value, done: false };\n current = current.next;\n return result;\n }\n else {\n return { value: undefined, done: true };\n }\n }\n };\n return iterator;\n }\n entries() {\n const map = this;\n const state = this._state;\n let current = this._head;\n const iterator = {\n [Symbol.iterator]() {\n return iterator;\n },\n next() {\n if (map._state !== state) {\n throw new Error(`LinkedMap got modified during iteration.`);\n }\n if (current) {\n const result = { value: [current.key, current.value], done: false };\n current = current.next;\n return result;\n }\n else {\n return { value: undefined, done: true };\n }\n }\n };\n return iterator;\n }\n [(_b = Symbol.toStringTag, Symbol.iterator)]() {\n return this.entries();\n }\n trimOld(newSize) {\n if (newSize >= this.size) {\n return;\n }\n if (newSize === 0) {\n this.clear();\n return;\n }\n let current = this._head;\n let currentSize = this.size;\n while (current && currentSize > newSize) {\n this._map.delete(current.key);\n current = current.next;\n currentSize--;\n }\n this._head = current;\n this._size = currentSize;\n if (current) {\n current.previous = undefined;\n }\n this._state++;\n }\n addItemFirst(item) {\n // First time Insert\n if (!this._head && !this._tail) {\n this._tail = item;\n }\n else if (!this._head) {\n throw new Error('Invalid list');\n }\n else {\n item.next = this._head;\n this._head.previous = item;\n }\n this._head = item;\n this._state++;\n }\n addItemLast(item) {\n // First time Insert\n if (!this._head && !this._tail) {\n this._head = item;\n }\n else if (!this._tail) {\n throw new Error('Invalid list');\n }\n else {\n item.previous = this._tail;\n this._tail.next = item;\n }\n this._tail = item;\n this._state++;\n }\n removeItem(item) {\n if (item === this._head && item === this._tail) {\n this._head = undefined;\n this._tail = undefined;\n }\n else if (item === this._head) {\n // This can only happen if size === 1 which is handled\n // by the case above.\n if (!item.next) {\n throw new Error('Invalid list');\n }\n item.next.previous = undefined;\n this._head = item.next;\n }\n else if (item === this._tail) {\n // This can only happen if size === 1 which is handled\n // by the case above.\n if (!item.previous) {\n throw new Error('Invalid list');\n }\n item.previous.next = undefined;\n this._tail = item.previous;\n }\n else {\n const next = item.next;\n const previous = item.previous;\n if (!next || !previous) {\n throw new Error('Invalid list');\n }\n next.previous = previous;\n previous.next = next;\n }\n item.next = undefined;\n item.previous = undefined;\n this._state++;\n }\n touch(item, touch) {\n if (!this._head || !this._tail) {\n throw new Error('Invalid list');\n }\n if ((touch !== 1 /* Touch.AsOld */ && touch !== 2 /* Touch.AsNew */)) {\n return;\n }\n if (touch === 1 /* Touch.AsOld */) {\n if (item === this._head) {\n return;\n }\n const next = item.next;\n const previous = item.previous;\n // Unlink the item\n if (item === this._tail) {\n // previous must be defined since item was not head but is tail\n // So there are more than on item in the map\n previous.next = undefined;\n this._tail = previous;\n }\n else {\n // Both next and previous are not undefined since item was neither head nor tail.\n next.previous = previous;\n previous.next = next;\n }\n // Insert the node at head\n item.previous = undefined;\n item.next = this._head;\n this._head.previous = item;\n this._head = item;\n this._state++;\n }\n else if (touch === 2 /* Touch.AsNew */) {\n if (item === this._tail) {\n return;\n }\n const next = item.next;\n const previous = item.previous;\n // Unlink the item.\n if (item === this._head) {\n // next must be defined since item was not tail but is head\n // So there are more than on item in the map\n next.previous = undefined;\n this._head = next;\n }\n else {\n // Both next and previous are not undefined since item was neither head nor tail.\n next.previous = previous;\n previous.next = next;\n }\n item.next = undefined;\n item.previous = this._tail;\n this._tail.next = item;\n this._tail = item;\n this._state++;\n }\n }\n toJSON() {\n const data = [];\n this.forEach((value, key) => {\n data.push([key, value]);\n });\n return data;\n }\n fromJSON(data) {\n this.clear();\n for (const [key, value] of data) {\n this.set(key, value);\n }\n }\n}\nexport class LRUCache extends LinkedMap {\n constructor(limit, ratio = 1) {\n super();\n this._limit = limit;\n this._ratio = Math.min(Math.max(0, ratio), 1);\n }\n get limit() {\n return this._limit;\n }\n set limit(limit) {\n this._limit = limit;\n this.checkTrim();\n }\n get(key, touch = 2 /* Touch.AsNew */) {\n return super.get(key, touch);\n }\n peek(key) {\n return super.get(key, 0 /* Touch.None */);\n }\n set(key, value) {\n super.set(key, value, 2 /* Touch.AsNew */);\n this.checkTrim();\n return this;\n }\n checkTrim() {\n if (this.size > this._limit) {\n this.trimOld(Math.round(this._limit * this._ratio));\n }\n }\n}\n/**\n * A map that allows access both by keys and values.\n * **NOTE**: values need to be unique.\n */\nexport class BidirectionalMap {\n constructor(entries) {\n this._m1 = new Map();\n this._m2 = new Map();\n if (entries) {\n for (const [key, value] of entries) {\n this.set(key, value);\n }\n }\n }\n clear() {\n this._m1.clear();\n this._m2.clear();\n }\n set(key, value) {\n this._m1.set(key, value);\n this._m2.set(value, key);\n }\n get(key) {\n return this._m1.get(key);\n }\n getKey(value) {\n return this._m2.get(value);\n }\n delete(key) {\n const value = this._m1.get(key);\n if (value === undefined) {\n return false;\n }\n this._m1.delete(key);\n this._m2.delete(value);\n return true;\n }\n keys() {\n return this._m1.keys();\n }\n values() {\n return this._m1.values();\n }\n}\nexport class SetMap {\n constructor() {\n this.map = new Map();\n }\n add(key, value) {\n let values = this.map.get(key);\n if (!values) {\n values = new Set();\n this.map.set(key, values);\n }\n values.add(value);\n }\n delete(key, value) {\n const values = this.map.get(key);\n if (!values) {\n return;\n }\n values.delete(value);\n if (values.size === 0) {\n this.map.delete(key);\n }\n }\n forEach(key, fn) {\n const values = this.map.get(key);\n if (!values) {\n return;\n }\n values.forEach(fn);\n }\n get(key) {\n const values = this.map.get(key);\n if (!values) {\n return new Set();\n }\n return values;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { isTypedArray, isObject, isUndefinedOrNull } from './types.js';\nexport function deepClone(obj) {\n if (!obj || typeof obj !== 'object') {\n return obj;\n }\n if (obj instanceof RegExp) {\n return obj;\n }\n const result = Array.isArray(obj) ? [] : {};\n Object.entries(obj).forEach(([key, value]) => {\n result[key] = value && typeof value === 'object' ? deepClone(value) : value;\n });\n return result;\n}\nexport function deepFreeze(obj) {\n if (!obj || typeof obj !== 'object') {\n return obj;\n }\n const stack = [obj];\n while (stack.length > 0) {\n const obj = stack.shift();\n Object.freeze(obj);\n for (const key in obj) {\n if (_hasOwnProperty.call(obj, key)) {\n const prop = obj[key];\n if (typeof prop === 'object' && !Object.isFrozen(prop) && !isTypedArray(prop)) {\n stack.push(prop);\n }\n }\n }\n }\n return obj;\n}\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function cloneAndChange(obj, changer) {\n return _cloneAndChange(obj, changer, new Set());\n}\nfunction _cloneAndChange(obj, changer, seen) {\n if (isUndefinedOrNull(obj)) {\n return obj;\n }\n const changed = changer(obj);\n if (typeof changed !== 'undefined') {\n return changed;\n }\n if (Array.isArray(obj)) {\n const r1 = [];\n for (const e of obj) {\n r1.push(_cloneAndChange(e, changer, seen));\n }\n return r1;\n }\n if (isObject(obj)) {\n if (seen.has(obj)) {\n throw new Error('Cannot clone recursive data-structure');\n }\n seen.add(obj);\n const r2 = {};\n for (const i2 in obj) {\n if (_hasOwnProperty.call(obj, i2)) {\n r2[i2] = _cloneAndChange(obj[i2], changer, seen);\n }\n }\n seen.delete(obj);\n return r2;\n }\n return obj;\n}\n/**\n * Copies all properties of source into destination. The optional parameter \"overwrite\" allows to control\n * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite).\n */\nexport function mixin(destination, source, overwrite = true) {\n if (!isObject(destination)) {\n return source;\n }\n if (isObject(source)) {\n Object.keys(source).forEach(key => {\n if (key in destination) {\n if (overwrite) {\n if (isObject(destination[key]) && isObject(source[key])) {\n mixin(destination[key], source[key], overwrite);\n }\n else {\n destination[key] = source[key];\n }\n }\n }\n else {\n destination[key] = source[key];\n }\n });\n }\n return destination;\n}\nexport function equals(one, other) {\n if (one === other) {\n return true;\n }\n if (one === null || one === undefined || other === null || other === undefined) {\n return false;\n }\n if (typeof one !== typeof other) {\n return false;\n }\n if (typeof one !== 'object') {\n return false;\n }\n if ((Array.isArray(one)) !== (Array.isArray(other))) {\n return false;\n }\n let i;\n let key;\n if (Array.isArray(one)) {\n if (one.length !== other.length) {\n return false;\n }\n for (i = 0; i < one.length; i++) {\n if (!equals(one[i], other[i])) {\n return false;\n }\n }\n }\n else {\n const oneKeys = [];\n for (key in one) {\n oneKeys.push(key);\n }\n oneKeys.sort();\n const otherKeys = [];\n for (key in other) {\n otherKeys.push(key);\n }\n otherKeys.sort();\n if (!equals(oneKeys, otherKeys)) {\n return false;\n }\n for (i = 0; i < oneKeys.length; i++) {\n if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {\n return false;\n }\n }\n }\n return true;\n}\nexport function getAllPropertyNames(obj) {\n let res = [];\n while (Object.prototype !== obj) {\n res = res.concat(Object.getOwnPropertyNames(obj));\n obj = Object.getPrototypeOf(obj);\n }\n return res;\n}\nexport function getAllMethodNames(obj) {\n const methods = [];\n for (const prop of getAllPropertyNames(obj)) {\n if (typeof obj[prop] === 'function') {\n methods.push(prop);\n }\n }\n return methods;\n}\nexport function createProxyObject(methodNames, invoke) {\n const createProxyMethod = (method) => {\n return function () {\n const args = Array.prototype.slice.call(arguments, 0);\n return invoke(method, args);\n };\n };\n const result = {};\n for (const methodName of methodNames) {\n result[methodName] = createProxyMethod(methodName);\n }\n return result;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// NOTE: VSCode's copy of nodejs path library to be usable in common (non-node) namespace\n// Copied from: https://github.com/nodejs/node/blob/v16.14.2/lib/path.js\n/**\n * Copyright Joyent, Inc. and other Node contributors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to permit\n * persons to whom the Software is furnished to do so, subject to the\n * following conditions:\n *\n * The above copyright notice and this permission notice shall be included\n * in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n * USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\nimport * as process from './process.js';\nconst CHAR_UPPERCASE_A = 65; /* A */\nconst CHAR_LOWERCASE_A = 97; /* a */\nconst CHAR_UPPERCASE_Z = 90; /* Z */\nconst CHAR_LOWERCASE_Z = 122; /* z */\nconst CHAR_DOT = 46; /* . */\nconst CHAR_FORWARD_SLASH = 47; /* / */\nconst CHAR_BACKWARD_SLASH = 92; /* \\ */\nconst CHAR_COLON = 58; /* : */\nconst CHAR_QUESTION_MARK = 63; /* ? */\nclass ErrorInvalidArgType extends Error {\n constructor(name, expected, actual) {\n // determiner: 'must be' or 'must not be'\n let determiner;\n if (typeof expected === 'string' && expected.indexOf('not ') === 0) {\n determiner = 'must not be';\n expected = expected.replace(/^not /, '');\n }\n else {\n determiner = 'must be';\n }\n const type = name.indexOf('.') !== -1 ? 'property' : 'argument';\n let msg = `The \"${name}\" ${type} ${determiner} of type ${expected}`;\n msg += `. Received type ${typeof actual}`;\n super(msg);\n this.code = 'ERR_INVALID_ARG_TYPE';\n }\n}\nfunction validateObject(pathObject, name) {\n if (pathObject === null || typeof pathObject !== 'object') {\n throw new ErrorInvalidArgType(name, 'Object', pathObject);\n }\n}\nfunction validateString(value, name) {\n if (typeof value !== 'string') {\n throw new ErrorInvalidArgType(name, 'string', value);\n }\n}\nconst platformIsWin32 = (process.platform === 'win32');\nfunction isPathSeparator(code) {\n return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n}\nfunction isPosixPathSeparator(code) {\n return code === CHAR_FORWARD_SLASH;\n}\nfunction isWindowsDeviceRoot(code) {\n return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||\n (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);\n}\n// Resolves . and .. elements in a path with directory names\nfunction normalizeString(path, allowAboveRoot, separator, isPathSeparator) {\n let res = '';\n let lastSegmentLength = 0;\n let lastSlash = -1;\n let dots = 0;\n let code = 0;\n for (let i = 0; i <= path.length; ++i) {\n if (i < path.length) {\n code = path.charCodeAt(i);\n }\n else if (isPathSeparator(code)) {\n break;\n }\n else {\n code = CHAR_FORWARD_SLASH;\n }\n if (isPathSeparator(code)) {\n if (lastSlash === i - 1 || dots === 1) {\n // NOOP\n }\n else if (dots === 2) {\n if (res.length < 2 || lastSegmentLength !== 2 ||\n res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n res.charCodeAt(res.length - 2) !== CHAR_DOT) {\n if (res.length > 2) {\n const lastSlashIndex = res.lastIndexOf(separator);\n if (lastSlashIndex === -1) {\n res = '';\n lastSegmentLength = 0;\n }\n else {\n res = res.slice(0, lastSlashIndex);\n lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);\n }\n lastSlash = i;\n dots = 0;\n continue;\n }\n else if (res.length !== 0) {\n res = '';\n lastSegmentLength = 0;\n lastSlash = i;\n dots = 0;\n continue;\n }\n }\n if (allowAboveRoot) {\n res += res.length > 0 ? `${separator}..` : '..';\n lastSegmentLength = 2;\n }\n }\n else {\n if (res.length > 0) {\n res += `${separator}${path.slice(lastSlash + 1, i)}`;\n }\n else {\n res = path.slice(lastSlash + 1, i);\n }\n lastSegmentLength = i - lastSlash - 1;\n }\n lastSlash = i;\n dots = 0;\n }\n else if (code === CHAR_DOT && dots !== -1) {\n ++dots;\n }\n else {\n dots = -1;\n }\n }\n return res;\n}\nfunction _format(sep, pathObject) {\n validateObject(pathObject, 'pathObject');\n const dir = pathObject.dir || pathObject.root;\n const base = pathObject.base ||\n `${pathObject.name || ''}${pathObject.ext || ''}`;\n if (!dir) {\n return base;\n }\n return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;\n}\nexport const win32 = {\n // path.resolve([from ...], to)\n resolve(...pathSegments) {\n let resolvedDevice = '';\n let resolvedTail = '';\n let resolvedAbsolute = false;\n for (let i = pathSegments.length - 1; i >= -1; i--) {\n let path;\n if (i >= 0) {\n path = pathSegments[i];\n validateString(path, 'path');\n // Skip empty entries\n if (path.length === 0) {\n continue;\n }\n }\n else if (resolvedDevice.length === 0) {\n path = process.cwd();\n }\n else {\n // Windows has the concept of drive-specific current working\n // directories. If we've resolved a drive letter but not yet an\n // absolute path, get cwd for that drive, or the process cwd if\n // the drive cwd is not available. We're sure the device is not\n // a UNC path at this points, because UNC paths are always absolute.\n path = process.env[`=${resolvedDevice}`] || process.cwd();\n // Verify that a cwd was found and that it actually points\n // to our drive. If not, default to the drive's root.\n if (path === undefined ||\n (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&\n path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {\n path = `${resolvedDevice}\\\\`;\n }\n }\n const len = path.length;\n let rootEnd = 0;\n let device = '';\n let isAbsolute = false;\n const code = path.charCodeAt(0);\n // Try to match a root\n if (len === 1) {\n if (isPathSeparator(code)) {\n // `path` contains just a path separator\n rootEnd = 1;\n isAbsolute = true;\n }\n }\n else if (isPathSeparator(code)) {\n // Possible UNC root\n // If we started with a separator, we know we at least have an\n // absolute path of some kind (UNC or otherwise)\n isAbsolute = true;\n if (isPathSeparator(path.charCodeAt(1))) {\n // Matched double path separator at beginning\n let j = 2;\n let last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n const firstPart = path.slice(last, j);\n // Matched!\n last = j;\n // Match 1 or more path separators\n while (j < len && isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n // Matched!\n last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j === len || j !== last) {\n // We matched a UNC root\n device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n rootEnd = j;\n }\n }\n }\n }\n else {\n rootEnd = 1;\n }\n }\n else if (isWindowsDeviceRoot(code) &&\n path.charCodeAt(1) === CHAR_COLON) {\n // Possible device root\n device = path.slice(0, 2);\n rootEnd = 2;\n if (len > 2 && isPathSeparator(path.charCodeAt(2))) {\n // Treat separator following drive name as an absolute path\n // indicator\n isAbsolute = true;\n rootEnd = 3;\n }\n }\n if (device.length > 0) {\n if (resolvedDevice.length > 0) {\n if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {\n // This path points to another device so it is not applicable\n continue;\n }\n }\n else {\n resolvedDevice = device;\n }\n }\n if (resolvedAbsolute) {\n if (resolvedDevice.length > 0) {\n break;\n }\n }\n else {\n resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n resolvedAbsolute = isAbsolute;\n if (isAbsolute && resolvedDevice.length > 0) {\n break;\n }\n }\n }\n // At this point the path should be resolved to a full absolute path,\n // but handle relative paths to be safe (might happen when process.cwd()\n // fails)\n // Normalize the tail path\n resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\\\', isPathSeparator);\n return resolvedAbsolute ?\n `${resolvedDevice}\\\\${resolvedTail}` :\n `${resolvedDevice}${resolvedTail}` || '.';\n },\n normalize(path) {\n validateString(path, 'path');\n const len = path.length;\n if (len === 0) {\n return '.';\n }\n let rootEnd = 0;\n let device;\n let isAbsolute = false;\n const code = path.charCodeAt(0);\n // Try to match a root\n if (len === 1) {\n // `path` contains just a single char, exit early to avoid\n // unnecessary work\n return isPosixPathSeparator(code) ? '\\\\' : path;\n }\n if (isPathSeparator(code)) {\n // Possible UNC root\n // If we started with a separator, we know we at least have an absolute\n // path of some kind (UNC or otherwise)\n isAbsolute = true;\n if (isPathSeparator(path.charCodeAt(1))) {\n // Matched double path separator at beginning\n let j = 2;\n let last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n const firstPart = path.slice(last, j);\n // Matched!\n last = j;\n // Match 1 or more path separators\n while (j < len && isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n // Matched!\n last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j === len) {\n // We matched a UNC root only\n // Return the normalized version of the UNC root since there\n // is nothing left to process\n return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n }\n if (j !== last) {\n // We matched a UNC root with leftovers\n device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n rootEnd = j;\n }\n }\n }\n }\n else {\n rootEnd = 1;\n }\n }\n else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n // Possible device root\n device = path.slice(0, 2);\n rootEnd = 2;\n if (len > 2 && isPathSeparator(path.charCodeAt(2))) {\n // Treat separator following drive name as an absolute path\n // indicator\n isAbsolute = true;\n rootEnd = 3;\n }\n }\n let tail = rootEnd < len ?\n normalizeString(path.slice(rootEnd), !isAbsolute, '\\\\', isPathSeparator) :\n '';\n if (tail.length === 0 && !isAbsolute) {\n tail = '.';\n }\n if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n tail += '\\\\';\n }\n if (device === undefined) {\n return isAbsolute ? `\\\\${tail}` : tail;\n }\n return isAbsolute ? `${device}\\\\${tail}` : `${device}${tail}`;\n },\n isAbsolute(path) {\n validateString(path, 'path');\n const len = path.length;\n if (len === 0) {\n return false;\n }\n const code = path.charCodeAt(0);\n return isPathSeparator(code) ||\n // Possible device root\n (len > 2 &&\n isWindowsDeviceRoot(code) &&\n path.charCodeAt(1) === CHAR_COLON &&\n isPathSeparator(path.charCodeAt(2)));\n },\n join(...paths) {\n if (paths.length === 0) {\n return '.';\n }\n let joined;\n let firstPart;\n for (let i = 0; i < paths.length; ++i) {\n const arg = paths[i];\n validateString(arg, 'path');\n if (arg.length > 0) {\n if (joined === undefined) {\n joined = firstPart = arg;\n }\n else {\n joined += `\\\\${arg}`;\n }\n }\n }\n if (joined === undefined) {\n return '.';\n }\n // Make sure that the joined path doesn't start with two slashes, because\n // normalize() will mistake it for a UNC path then.\n //\n // This step is skipped when it is very clear that the user actually\n // intended to point at a UNC path. This is assumed when the first\n // non-empty string arguments starts with exactly two slashes followed by\n // at least one more non-slash character.\n //\n // Note that for normalize() to treat a path as a UNC path it needs to\n // have at least 2 components, so we don't filter for that here.\n // This means that the user can use join to construct UNC paths from\n // a server name and a share name; for example:\n // path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n let needsReplace = true;\n let slashCount = 0;\n if (typeof firstPart === 'string' && isPathSeparator(firstPart.charCodeAt(0))) {\n ++slashCount;\n const firstLen = firstPart.length;\n if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) {\n ++slashCount;\n if (firstLen > 2) {\n if (isPathSeparator(firstPart.charCodeAt(2))) {\n ++slashCount;\n }\n else {\n // We matched a UNC path in the first part\n needsReplace = false;\n }\n }\n }\n }\n if (needsReplace) {\n // Find any more consecutive slashes we need to replace\n while (slashCount < joined.length &&\n isPathSeparator(joined.charCodeAt(slashCount))) {\n slashCount++;\n }\n // Replace the slashes if needed\n if (slashCount >= 2) {\n joined = `\\\\${joined.slice(slashCount)}`;\n }\n }\n return win32.normalize(joined);\n },\n // It will solve the relative path from `from` to `to`, for instance:\n // from = 'C:\\\\orandea\\\\test\\\\aaa'\n // to = 'C:\\\\orandea\\\\impl\\\\bbb'\n // The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n relative(from, to) {\n validateString(from, 'from');\n validateString(to, 'to');\n if (from === to) {\n return '';\n }\n const fromOrig = win32.resolve(from);\n const toOrig = win32.resolve(to);\n if (fromOrig === toOrig) {\n return '';\n }\n from = fromOrig.toLowerCase();\n to = toOrig.toLowerCase();\n if (from === to) {\n return '';\n }\n // Trim any leading backslashes\n let fromStart = 0;\n while (fromStart < from.length &&\n from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {\n fromStart++;\n }\n // Trim trailing backslashes (applicable to UNC paths only)\n let fromEnd = from.length;\n while (fromEnd - 1 > fromStart &&\n from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {\n fromEnd--;\n }\n const fromLen = fromEnd - fromStart;\n // Trim any leading backslashes\n let toStart = 0;\n while (toStart < to.length &&\n to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {\n toStart++;\n }\n // Trim trailing backslashes (applicable to UNC paths only)\n let toEnd = to.length;\n while (toEnd - 1 > toStart &&\n to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {\n toEnd--;\n }\n const toLen = toEnd - toStart;\n // Compare paths to find the longest common path from root\n const length = fromLen < toLen ? fromLen : toLen;\n let lastCommonSep = -1;\n let i = 0;\n for (; i < length; i++) {\n const fromCode = from.charCodeAt(fromStart + i);\n if (fromCode !== to.charCodeAt(toStart + i)) {\n break;\n }\n else if (fromCode === CHAR_BACKWARD_SLASH) {\n lastCommonSep = i;\n }\n }\n // We found a mismatch before the first common path separator was seen, so\n // return the original `to`.\n if (i !== length) {\n if (lastCommonSep === -1) {\n return toOrig;\n }\n }\n else {\n if (toLen > length) {\n if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {\n // We get here if `from` is the exact base path for `to`.\n // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n return toOrig.slice(toStart + i + 1);\n }\n if (i === 2) {\n // We get here if `from` is the device root.\n // For example: from='C:\\\\'; to='C:\\\\foo'\n return toOrig.slice(toStart + i);\n }\n }\n if (fromLen > length) {\n if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n // We get here if `to` is the exact base path for `from`.\n // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n lastCommonSep = i;\n }\n else if (i === 2) {\n // We get here if `to` is the device root.\n // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n lastCommonSep = 3;\n }\n }\n if (lastCommonSep === -1) {\n lastCommonSep = 0;\n }\n }\n let out = '';\n // Generate the relative path based on the path difference between `to` and\n // `from`\n for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {\n out += out.length === 0 ? '..' : '\\\\..';\n }\n }\n toStart += lastCommonSep;\n // Lastly, append the rest of the destination (`to`) path that comes after\n // the common path parts\n if (out.length > 0) {\n return `${out}${toOrig.slice(toStart, toEnd)}`;\n }\n if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {\n ++toStart;\n }\n return toOrig.slice(toStart, toEnd);\n },\n toNamespacedPath(path) {\n // Note: this will *probably* throw somewhere.\n if (typeof path !== 'string' || path.length === 0) {\n return path;\n }\n const resolvedPath = win32.resolve(path);\n if (resolvedPath.length <= 2) {\n return path;\n }\n if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n // Possible UNC root\n if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n const code = resolvedPath.charCodeAt(2);\n if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n // Matched non-long UNC root, convert the path to a long UNC path\n return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n }\n }\n }\n else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) &&\n resolvedPath.charCodeAt(1) === CHAR_COLON &&\n resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {\n // Matched device root, convert the path to a long UNC path\n return `\\\\\\\\?\\\\${resolvedPath}`;\n }\n return path;\n },\n dirname(path) {\n validateString(path, 'path');\n const len = path.length;\n if (len === 0) {\n return '.';\n }\n let rootEnd = -1;\n let offset = 0;\n const code = path.charCodeAt(0);\n if (len === 1) {\n // `path` contains just a path separator, exit early to avoid\n // unnecessary work or a dot.\n return isPathSeparator(code) ? path : '.';\n }\n // Try to match a root\n if (isPathSeparator(code)) {\n // Possible UNC root\n rootEnd = offset = 1;\n if (isPathSeparator(path.charCodeAt(1))) {\n // Matched double path separator at beginning\n let j = 2;\n let last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n // Matched!\n last = j;\n // Match 1 or more path separators\n while (j < len && isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n // Matched!\n last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j === len) {\n // We matched a UNC root only\n return path;\n }\n if (j !== last) {\n // We matched a UNC root with leftovers\n // Offset by 1 to include the separator after the UNC root to\n // treat it as a \"normal root\" on top of a (UNC) root\n rootEnd = offset = j + 1;\n }\n }\n }\n }\n // Possible device root\n }\n else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2;\n offset = rootEnd;\n }\n let end = -1;\n let matchedSlash = true;\n for (let i = len - 1; i >= offset; --i) {\n if (isPathSeparator(path.charCodeAt(i))) {\n if (!matchedSlash) {\n end = i;\n break;\n }\n }\n else {\n // We saw the first non-path separator\n matchedSlash = false;\n }\n }\n if (end === -1) {\n if (rootEnd === -1) {\n return '.';\n }\n end = rootEnd;\n }\n return path.slice(0, end);\n },\n basename(path, ext) {\n if (ext !== undefined) {\n validateString(ext, 'ext');\n }\n validateString(path, 'path');\n let start = 0;\n let end = -1;\n let matchedSlash = true;\n let i;\n // Check for a drive letter prefix so as not to mistake the following\n // path separator as an extra separator at the end of the path that can be\n // disregarded\n if (path.length >= 2 &&\n isWindowsDeviceRoot(path.charCodeAt(0)) &&\n path.charCodeAt(1) === CHAR_COLON) {\n start = 2;\n }\n if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n if (ext === path) {\n return '';\n }\n let extIdx = ext.length - 1;\n let firstNonSlashEnd = -1;\n for (i = path.length - 1; i >= start; --i) {\n const code = path.charCodeAt(i);\n if (isPathSeparator(code)) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n }\n else {\n if (firstNonSlashEnd === -1) {\n // We saw the first non-path separator, remember this index in case\n // we need it if the extension ends up not matching\n matchedSlash = false;\n firstNonSlashEnd = i + 1;\n }\n if (extIdx >= 0) {\n // Try to match the explicit extension\n if (code === ext.charCodeAt(extIdx)) {\n if (--extIdx === -1) {\n // We matched the extension, so mark this as the end of our path\n // component\n end = i;\n }\n }\n else {\n // Extension does not match, so our result is the entire path\n // component\n extIdx = -1;\n end = firstNonSlashEnd;\n }\n }\n }\n }\n if (start === end) {\n end = firstNonSlashEnd;\n }\n else if (end === -1) {\n end = path.length;\n }\n return path.slice(start, end);\n }\n for (i = path.length - 1; i >= start; --i) {\n if (isPathSeparator(path.charCodeAt(i))) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n }\n else if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // path component\n matchedSlash = false;\n end = i + 1;\n }\n }\n if (end === -1) {\n return '';\n }\n return path.slice(start, end);\n },\n extname(path) {\n validateString(path, 'path');\n let start = 0;\n let startDot = -1;\n let startPart = 0;\n let end = -1;\n let matchedSlash = true;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n let preDotState = 0;\n // Check for a drive letter prefix so as not to mistake the following\n // path separator as an extra separator at the end of the path that can be\n // disregarded\n if (path.length >= 2 &&\n path.charCodeAt(1) === CHAR_COLON &&\n isWindowsDeviceRoot(path.charCodeAt(0))) {\n start = startPart = 2;\n }\n for (let i = path.length - 1; i >= start; --i) {\n const code = path.charCodeAt(i);\n if (isPathSeparator(code)) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === CHAR_DOT) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1) {\n startDot = i;\n }\n else if (preDotState !== 1) {\n preDotState = 1;\n }\n }\n else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n if (startDot === -1 ||\n end === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n (preDotState === 1 &&\n startDot === end - 1 &&\n startDot === startPart + 1)) {\n return '';\n }\n return path.slice(startDot, end);\n },\n format: _format.bind(null, '\\\\'),\n parse(path) {\n validateString(path, 'path');\n const ret = { root: '', dir: '', base: '', ext: '', name: '' };\n if (path.length === 0) {\n return ret;\n }\n const len = path.length;\n let rootEnd = 0;\n let code = path.charCodeAt(0);\n if (len === 1) {\n if (isPathSeparator(code)) {\n // `path` contains just a path separator, exit early to avoid\n // unnecessary work\n ret.root = ret.dir = path;\n return ret;\n }\n ret.base = ret.name = path;\n return ret;\n }\n // Try to match a root\n if (isPathSeparator(code)) {\n // Possible UNC root\n rootEnd = 1;\n if (isPathSeparator(path.charCodeAt(1))) {\n // Matched double path separator at beginning\n let j = 2;\n let last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n // Matched!\n last = j;\n // Match 1 or more path separators\n while (j < len && isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j < len && j !== last) {\n // Matched!\n last = j;\n // Match 1 or more non-path separators\n while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n j++;\n }\n if (j === len) {\n // We matched a UNC root only\n rootEnd = j;\n }\n else if (j !== last) {\n // We matched a UNC root with leftovers\n rootEnd = j + 1;\n }\n }\n }\n }\n }\n else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n // Possible device root\n if (len <= 2) {\n // `path` contains just a drive root, exit early to avoid\n // unnecessary work\n ret.root = ret.dir = path;\n return ret;\n }\n rootEnd = 2;\n if (isPathSeparator(path.charCodeAt(2))) {\n if (len === 3) {\n // `path` contains just a drive root, exit early to avoid\n // unnecessary work\n ret.root = ret.dir = path;\n return ret;\n }\n rootEnd = 3;\n }\n }\n if (rootEnd > 0) {\n ret.root = path.slice(0, rootEnd);\n }\n let startDot = -1;\n let startPart = rootEnd;\n let end = -1;\n let matchedSlash = true;\n let i = path.length - 1;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n let preDotState = 0;\n // Get non-dir info\n for (; i >= rootEnd; --i) {\n code = path.charCodeAt(i);\n if (isPathSeparator(code)) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === CHAR_DOT) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1) {\n startDot = i;\n }\n else if (preDotState !== 1) {\n preDotState = 1;\n }\n }\n else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n if (end !== -1) {\n if (startDot === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n (preDotState === 1 &&\n startDot === end - 1 &&\n startDot === startPart + 1)) {\n ret.base = ret.name = path.slice(startPart, end);\n }\n else {\n ret.name = path.slice(startPart, startDot);\n ret.base = path.slice(startPart, end);\n ret.ext = path.slice(startDot, end);\n }\n }\n // If the directory is the root, use the entire root as the `dir` including\n // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n if (startPart > 0 && startPart !== rootEnd) {\n ret.dir = path.slice(0, startPart - 1);\n }\n else {\n ret.dir = ret.root;\n }\n return ret;\n },\n sep: '\\\\',\n delimiter: ';',\n win32: null,\n posix: null\n};\nconst posixCwd = (() => {\n if (platformIsWin32) {\n // Converts Windows' backslash path separators to POSIX forward slashes\n // and truncates any drive indicator\n const regexp = /\\\\/g;\n return () => {\n const cwd = process.cwd().replace(regexp, '/');\n return cwd.slice(cwd.indexOf('/'));\n };\n }\n // We're already on POSIX, no need for any transformations\n return () => process.cwd();\n})();\nexport const posix = {\n // path.resolve([from ...], to)\n resolve(...pathSegments) {\n let resolvedPath = '';\n let resolvedAbsolute = false;\n for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n const path = i >= 0 ? pathSegments[i] : posixCwd();\n validateString(path, 'path');\n // Skip empty entries\n if (path.length === 0) {\n continue;\n }\n resolvedPath = `${path}/${resolvedPath}`;\n resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n }\n // At this point the path should be resolved to a full absolute path, but\n // handle relative paths to be safe (might happen when process.cwd() fails)\n // Normalize the path\n resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);\n if (resolvedAbsolute) {\n return `/${resolvedPath}`;\n }\n return resolvedPath.length > 0 ? resolvedPath : '.';\n },\n normalize(path) {\n validateString(path, 'path');\n if (path.length === 0) {\n return '.';\n }\n const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n // Normalize the path\n path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator);\n if (path.length === 0) {\n if (isAbsolute) {\n return '/';\n }\n return trailingSeparator ? './' : '.';\n }\n if (trailingSeparator) {\n path += '/';\n }\n return isAbsolute ? `/${path}` : path;\n },\n isAbsolute(path) {\n validateString(path, 'path');\n return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n },\n join(...paths) {\n if (paths.length === 0) {\n return '.';\n }\n let joined;\n for (let i = 0; i < paths.length; ++i) {\n const arg = paths[i];\n validateString(arg, 'path');\n if (arg.length > 0) {\n if (joined === undefined) {\n joined = arg;\n }\n else {\n joined += `/${arg}`;\n }\n }\n }\n if (joined === undefined) {\n return '.';\n }\n return posix.normalize(joined);\n },\n relative(from, to) {\n validateString(from, 'from');\n validateString(to, 'to');\n if (from === to) {\n return '';\n }\n // Trim leading forward slashes.\n from = posix.resolve(from);\n to = posix.resolve(to);\n if (from === to) {\n return '';\n }\n const fromStart = 1;\n const fromEnd = from.length;\n const fromLen = fromEnd - fromStart;\n const toStart = 1;\n const toLen = to.length - toStart;\n // Compare paths to find the longest common path from root\n const length = (fromLen < toLen ? fromLen : toLen);\n let lastCommonSep = -1;\n let i = 0;\n for (; i < length; i++) {\n const fromCode = from.charCodeAt(fromStart + i);\n if (fromCode !== to.charCodeAt(toStart + i)) {\n break;\n }\n else if (fromCode === CHAR_FORWARD_SLASH) {\n lastCommonSep = i;\n }\n }\n if (i === length) {\n if (toLen > length) {\n if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n // We get here if `from` is the exact base path for `to`.\n // For example: from='/foo/bar'; to='/foo/bar/baz'\n return to.slice(toStart + i + 1);\n }\n if (i === 0) {\n // We get here if `from` is the root\n // For example: from='/'; to='/foo'\n return to.slice(toStart + i);\n }\n }\n else if (fromLen > length) {\n if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n // We get here if `to` is the exact base path for `from`.\n // For example: from='/foo/bar/baz'; to='/foo/bar'\n lastCommonSep = i;\n }\n else if (i === 0) {\n // We get here if `to` is the root.\n // For example: from='/foo/bar'; to='/'\n lastCommonSep = 0;\n }\n }\n }\n let out = '';\n // Generate the relative path based on the path difference between `to`\n // and `from`.\n for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n out += out.length === 0 ? '..' : '/..';\n }\n }\n // Lastly, append the rest of the destination (`to`) path that comes after\n // the common path parts.\n return `${out}${to.slice(toStart + lastCommonSep)}`;\n },\n toNamespacedPath(path) {\n // Non-op on posix systems\n return path;\n },\n dirname(path) {\n validateString(path, 'path');\n if (path.length === 0) {\n return '.';\n }\n const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n let end = -1;\n let matchedSlash = true;\n for (let i = path.length - 1; i >= 1; --i) {\n if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n if (!matchedSlash) {\n end = i;\n break;\n }\n }\n else {\n // We saw the first non-path separator\n matchedSlash = false;\n }\n }\n if (end === -1) {\n return hasRoot ? '/' : '.';\n }\n if (hasRoot && end === 1) {\n return '//';\n }\n return path.slice(0, end);\n },\n basename(path, ext) {\n if (ext !== undefined) {\n validateString(ext, 'ext');\n }\n validateString(path, 'path');\n let start = 0;\n let end = -1;\n let matchedSlash = true;\n let i;\n if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n if (ext === path) {\n return '';\n }\n let extIdx = ext.length - 1;\n let firstNonSlashEnd = -1;\n for (i = path.length - 1; i >= 0; --i) {\n const code = path.charCodeAt(i);\n if (code === CHAR_FORWARD_SLASH) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n }\n else {\n if (firstNonSlashEnd === -1) {\n // We saw the first non-path separator, remember this index in case\n // we need it if the extension ends up not matching\n matchedSlash = false;\n firstNonSlashEnd = i + 1;\n }\n if (extIdx >= 0) {\n // Try to match the explicit extension\n if (code === ext.charCodeAt(extIdx)) {\n if (--extIdx === -1) {\n // We matched the extension, so mark this as the end of our path\n // component\n end = i;\n }\n }\n else {\n // Extension does not match, so our result is the entire path\n // component\n extIdx = -1;\n end = firstNonSlashEnd;\n }\n }\n }\n }\n if (start === end) {\n end = firstNonSlashEnd;\n }\n else if (end === -1) {\n end = path.length;\n }\n return path.slice(start, end);\n }\n for (i = path.length - 1; i >= 0; --i) {\n if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n }\n else if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // path component\n matchedSlash = false;\n end = i + 1;\n }\n }\n if (end === -1) {\n return '';\n }\n return path.slice(start, end);\n },\n extname(path) {\n validateString(path, 'path');\n let startDot = -1;\n let startPart = 0;\n let end = -1;\n let matchedSlash = true;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n let preDotState = 0;\n for (let i = path.length - 1; i >= 0; --i) {\n const code = path.charCodeAt(i);\n if (code === CHAR_FORWARD_SLASH) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === CHAR_DOT) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1) {\n startDot = i;\n }\n else if (preDotState !== 1) {\n preDotState = 1;\n }\n }\n else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n if (startDot === -1 ||\n end === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n (preDotState === 1 &&\n startDot === end - 1 &&\n startDot === startPart + 1)) {\n return '';\n }\n return path.slice(startDot, end);\n },\n format: _format.bind(null, '/'),\n parse(path) {\n validateString(path, 'path');\n const ret = { root: '', dir: '', base: '', ext: '', name: '' };\n if (path.length === 0) {\n return ret;\n }\n const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n let start;\n if (isAbsolute) {\n ret.root = '/';\n start = 1;\n }\n else {\n start = 0;\n }\n let startDot = -1;\n let startPart = 0;\n let end = -1;\n let matchedSlash = true;\n let i = path.length - 1;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n let preDotState = 0;\n // Get non-dir info\n for (; i >= start; --i) {\n const code = path.charCodeAt(i);\n if (code === CHAR_FORWARD_SLASH) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === CHAR_DOT) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1) {\n startDot = i;\n }\n else if (preDotState !== 1) {\n preDotState = 1;\n }\n }\n else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n if (end !== -1) {\n const start = startPart === 0 && isAbsolute ? 1 : startPart;\n if (startDot === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n (preDotState === 1 &&\n startDot === end - 1 &&\n startDot === startPart + 1)) {\n ret.base = ret.name = path.slice(start, end);\n }\n else {\n ret.name = path.slice(start, startDot);\n ret.base = path.slice(start, end);\n ret.ext = path.slice(startDot, end);\n }\n }\n if (startPart > 0) {\n ret.dir = path.slice(0, startPart - 1);\n }\n else if (isAbsolute) {\n ret.dir = '/';\n }\n return ret;\n },\n sep: '/',\n delimiter: ':',\n win32: null,\n posix: null\n};\nposix.win32 = win32.win32 = win32;\nposix.posix = win32.posix = posix;\nexport const normalize = (platformIsWin32 ? win32.normalize : posix.normalize);\nexport const resolve = (platformIsWin32 ? win32.resolve : posix.resolve);\nexport const relative = (platformIsWin32 ? win32.relative : posix.relative);\nexport const dirname = (platformIsWin32 ? win32.dirname : posix.dirname);\nexport const basename = (platformIsWin32 ? win32.basename : posix.basename);\nexport const extname = (platformIsWin32 ? win32.extname : posix.extname);\nexport const sep = (platformIsWin32 ? win32.sep : posix.sep);\n","var _a;\n/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as nls from '../../nls.js';\nexport const LANGUAGE_DEFAULT = 'en';\nlet _isWindows = false;\nlet _isMacintosh = false;\nlet _isLinux = false;\nlet _isLinuxSnap = false;\nlet _isNative = false;\nlet _isWeb = false;\nlet _isElectron = false;\nlet _isIOS = false;\nlet _isCI = false;\nlet _isMobile = false;\nlet _locale = undefined;\nlet _language = LANGUAGE_DEFAULT;\nlet _platformLocale = LANGUAGE_DEFAULT;\nlet _translationsConfigFile = undefined;\nlet _userAgent = undefined;\nconst $globalThis = globalThis;\nlet nodeProcess = undefined;\nif (typeof $globalThis.vscode !== 'undefined' && typeof $globalThis.vscode.process !== 'undefined') {\n // Native environment (sandboxed)\n nodeProcess = $globalThis.vscode.process;\n}\nelse if (typeof process !== 'undefined') {\n // Native environment (non-sandboxed)\n nodeProcess = process;\n}\nconst isElectronProcess = typeof ((_a = nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.versions) === null || _a === void 0 ? void 0 : _a.electron) === 'string';\nconst isElectronRenderer = isElectronProcess && (nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.type) === 'renderer';\n// Web environment\nif (typeof navigator === 'object' && !isElectronRenderer) {\n _userAgent = navigator.userAgent;\n _isWindows = _userAgent.indexOf('Windows') >= 0;\n _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;\n _isIOS = (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;\n _isLinux = _userAgent.indexOf('Linux') >= 0;\n _isMobile = (_userAgent === null || _userAgent === void 0 ? void 0 : _userAgent.indexOf('Mobi')) >= 0;\n _isWeb = true;\n const configuredLocale = nls.getConfiguredDefaultLocale(\n // This call _must_ be done in the file that calls `nls.getConfiguredDefaultLocale`\n // to ensure that the NLS AMD Loader plugin has been loaded and configured.\n // This is because the loader plugin decides what the default locale is based on\n // how it's able to resolve the strings.\n nls.localize({ key: 'ensureLoaderPluginIsLoaded', comment: ['{Locked}'] }, '_'));\n _locale = configuredLocale || LANGUAGE_DEFAULT;\n _language = _locale;\n _platformLocale = navigator.language;\n}\n// Native environment\nelse if (typeof nodeProcess === 'object') {\n _isWindows = (nodeProcess.platform === 'win32');\n _isMacintosh = (nodeProcess.platform === 'darwin');\n _isLinux = (nodeProcess.platform === 'linux');\n _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];\n _isElectron = isElectronProcess;\n _isCI = !!nodeProcess.env['CI'] || !!nodeProcess.env['BUILD_ARTIFACTSTAGINGDIRECTORY'];\n _locale = LANGUAGE_DEFAULT;\n _language = LANGUAGE_DEFAULT;\n const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];\n if (rawNlsConfig) {\n try {\n const nlsConfig = JSON.parse(rawNlsConfig);\n const resolved = nlsConfig.availableLanguages['*'];\n _locale = nlsConfig.locale;\n _platformLocale = nlsConfig.osLocale;\n // VSCode's default language is 'en'\n _language = resolved ? resolved : LANGUAGE_DEFAULT;\n _translationsConfigFile = nlsConfig._translationsConfigFile;\n }\n catch (e) {\n }\n }\n _isNative = true;\n}\n// Unknown environment\nelse {\n console.error('Unable to resolve platform.');\n}\nlet _platform = 0 /* Platform.Web */;\nif (_isMacintosh) {\n _platform = 1 /* Platform.Mac */;\n}\nelse if (_isWindows) {\n _platform = 3 /* Platform.Windows */;\n}\nelse if (_isLinux) {\n _platform = 2 /* Platform.Linux */;\n}\nexport const isWindows = _isWindows;\nexport const isMacintosh = _isMacintosh;\nexport const isLinux = _isLinux;\nexport const isNative = _isNative;\nexport const isWeb = _isWeb;\nexport const isWebWorker = (_isWeb && typeof $globalThis.importScripts === 'function');\nexport const webWorkerOrigin = isWebWorker ? $globalThis.origin : undefined;\nexport const isIOS = _isIOS;\nexport const isMobile = _isMobile;\nexport const userAgent = _userAgent;\n/**\n * The language used for the user interface. The format of\n * the string is all lower case (e.g. zh-tw for Traditional\n * Chinese)\n */\nexport const language = _language;\nexport const setTimeout0IsFaster = (typeof $globalThis.postMessage === 'function' && !$globalThis.importScripts);\n/**\n * See https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#:~:text=than%204%2C%20then-,set%20timeout%20to%204,-.\n *\n * Works similarly to `setTimeout(0)` but doesn't suffer from the 4ms artificial delay\n * that browsers set when the nesting level is > 5.\n */\nexport const setTimeout0 = (() => {\n if (setTimeout0IsFaster) {\n const pending = [];\n $globalThis.addEventListener('message', (e) => {\n if (e.data && e.data.vscodeScheduleAsyncWork) {\n for (let i = 0, len = pending.length; i < len; i++) {\n const candidate = pending[i];\n if (candidate.id === e.data.vscodeScheduleAsyncWork) {\n pending.splice(i, 1);\n candidate.callback();\n return;\n }\n }\n }\n });\n let lastId = 0;\n return (callback) => {\n const myId = ++lastId;\n pending.push({\n id: myId,\n callback: callback\n });\n $globalThis.postMessage({ vscodeScheduleAsyncWork: myId }, '*');\n };\n }\n return (callback) => setTimeout(callback);\n})();\nexport const OS = (_isMacintosh || _isIOS ? 2 /* OperatingSystem.Macintosh */ : (_isWindows ? 1 /* OperatingSystem.Windows */ : 3 /* OperatingSystem.Linux */));\nlet _isLittleEndian = true;\nlet _isLittleEndianComputed = false;\nexport function isLittleEndian() {\n if (!_isLittleEndianComputed) {\n _isLittleEndianComputed = true;\n const test = new Uint8Array(2);\n test[0] = 1;\n test[1] = 2;\n const view = new Uint16Array(test.buffer);\n _isLittleEndian = (view[0] === (2 << 8) + 1);\n }\n return _isLittleEndian;\n}\nexport const isChrome = !!(userAgent && userAgent.indexOf('Chrome') >= 0);\nexport const isFirefox = !!(userAgent && userAgent.indexOf('Firefox') >= 0);\nexport const isSafari = !!(!isChrome && (userAgent && userAgent.indexOf('Safari') >= 0));\nexport const isEdge = !!(userAgent && userAgent.indexOf('Edg/') >= 0);\nexport const isAndroid = !!(userAgent && userAgent.indexOf('Android') >= 0);\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { isMacintosh, isWindows } from './platform.js';\nlet safeProcess;\n// Native sandbox environment\nconst vscodeGlobal = globalThis.vscode;\nif (typeof vscodeGlobal !== 'undefined' && typeof vscodeGlobal.process !== 'undefined') {\n const sandboxProcess = vscodeGlobal.process;\n safeProcess = {\n get platform() { return sandboxProcess.platform; },\n get arch() { return sandboxProcess.arch; },\n get env() { return sandboxProcess.env; },\n cwd() { return sandboxProcess.cwd(); }\n };\n}\n// Native node.js environment\nelse if (typeof process !== 'undefined') {\n safeProcess = {\n get platform() { return process.platform; },\n get arch() { return process.arch; },\n get env() { return process.env; },\n cwd() { return process.env['VSCODE_CWD'] || process.cwd(); }\n };\n}\n// Web environment\nelse {\n safeProcess = {\n // Supported\n get platform() { return isWindows ? 'win32' : isMacintosh ? 'darwin' : 'linux'; },\n get arch() { return undefined; /* arch is undefined in web */ },\n // Unsupported\n get env() { return {}; },\n cwd() { return '/'; }\n };\n}\n/**\n * Provides safe access to the `cwd` property in node.js, sandboxed or web\n * environments.\n *\n * Note: in web, this property is hardcoded to be `/`.\n *\n * @skipMangle\n */\nexport const cwd = safeProcess.cwd;\n/**\n * Provides safe access to the `env` property in node.js, sandboxed or web\n * environments.\n *\n * Note: in web, this property is hardcoded to be `{}`.\n */\nexport const env = safeProcess.env;\n/**\n * Provides safe access to the `platform` property in node.js, sandboxed or web\n * environments.\n */\nexport const platform = safeProcess.platform;\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nconst hasPerformanceNow = (globalThis.performance && typeof globalThis.performance.now === 'function');\nexport class StopWatch {\n static create(highResolution) {\n return new StopWatch(highResolution);\n }\n constructor(highResolution) {\n this._now = hasPerformanceNow && highResolution === false ? Date.now : globalThis.performance.now.bind(globalThis.performance);\n this._startTime = this._now();\n this._stopTime = -1;\n }\n stop() {\n this._stopTime = this._now();\n }\n elapsed() {\n if (this._stopTime !== -1) {\n return this._stopTime - this._startTime;\n }\n return this._now() - this._startTime;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar _a;\nimport { LRUCachedFunction } from './cache.js';\nimport { Lazy } from './lazy.js';\nexport function isFalsyOrWhitespace(str) {\n if (!str || typeof str !== 'string') {\n return true;\n }\n return str.trim().length === 0;\n}\nconst _formatRegexp = /{(\\d+)}/g;\n/**\n * Helper to produce a string with a variable number of arguments. Insert variable segments\n * into the string using the {n} notation where N is the index of the argument following the string.\n * @param value string to which formatting is applied\n * @param args replacements for {n}-entries\n */\nexport function format(value, ...args) {\n if (args.length === 0) {\n return value;\n }\n return value.replace(_formatRegexp, function (match, group) {\n const idx = parseInt(group, 10);\n return isNaN(idx) || idx < 0 || idx >= args.length ?\n match :\n args[idx];\n });\n}\n/**\n * Converts HTML characters inside the string to use entities instead. Makes the string safe from\n * being used e.g. in HTMLElement.innerHTML.\n */\nexport function escape(html) {\n return html.replace(/[<>&]/g, function (match) {\n switch (match) {\n case '<': return '<';\n case '>': return '>';\n case '&': return '&';\n default: return match;\n }\n });\n}\n/**\n * Escapes regular expression characters in a given string\n */\nexport function escapeRegExpCharacters(value) {\n return value.replace(/[\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\[\\]\\(\\)]/g, '\\\\$&');\n}\n/**\n * Removes all occurrences of needle from the beginning and end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim (default is a blank)\n */\nexport function trim(haystack, needle = ' ') {\n const trimmed = ltrim(haystack, needle);\n return rtrim(trimmed, needle);\n}\n/**\n * Removes all occurrences of needle from the beginning of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function ltrim(haystack, needle) {\n if (!haystack || !needle) {\n return haystack;\n }\n const needleLen = needle.length;\n if (needleLen === 0 || haystack.length === 0) {\n return haystack;\n }\n let offset = 0;\n while (haystack.indexOf(needle, offset) === offset) {\n offset = offset + needleLen;\n }\n return haystack.substring(offset);\n}\n/**\n * Removes all occurrences of needle from the end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function rtrim(haystack, needle) {\n if (!haystack || !needle) {\n return haystack;\n }\n const needleLen = needle.length, haystackLen = haystack.length;\n if (needleLen === 0 || haystackLen === 0) {\n return haystack;\n }\n let offset = haystackLen, idx = -1;\n while (true) {\n idx = haystack.lastIndexOf(needle, offset - 1);\n if (idx === -1 || idx + needleLen !== offset) {\n break;\n }\n if (idx === 0) {\n return '';\n }\n offset = idx;\n }\n return haystack.substring(0, offset);\n}\nexport function convertSimple2RegExpPattern(pattern) {\n return pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\n}\nexport function stripWildcards(pattern) {\n return pattern.replace(/\\*/g, '');\n}\nexport function createRegExp(searchString, isRegex, options = {}) {\n if (!searchString) {\n throw new Error('Cannot create regex from empty string');\n }\n if (!isRegex) {\n searchString = escapeRegExpCharacters(searchString);\n }\n if (options.wholeWord) {\n if (!/\\B/.test(searchString.charAt(0))) {\n searchString = '\\\\b' + searchString;\n }\n if (!/\\B/.test(searchString.charAt(searchString.length - 1))) {\n searchString = searchString + '\\\\b';\n }\n }\n let modifiers = '';\n if (options.global) {\n modifiers += 'g';\n }\n if (!options.matchCase) {\n modifiers += 'i';\n }\n if (options.multiline) {\n modifiers += 'm';\n }\n if (options.unicode) {\n modifiers += 'u';\n }\n return new RegExp(searchString, modifiers);\n}\nexport function regExpLeadsToEndlessLoop(regexp) {\n // Exit early if it's one of these special cases which are meant to match\n // against an empty string\n if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\\\s*$') {\n return false;\n }\n // We check against an empty string. If the regular expression doesn't advance\n // (e.g. ends in an endless loop) it will match an empty string.\n const match = regexp.exec('');\n return !!(match && regexp.lastIndex === 0);\n}\nexport function splitLines(str) {\n return str.split(/\\r\\n|\\r|\\n/);\n}\n/**\n * Returns first index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function firstNonWhitespaceIndex(str) {\n for (let i = 0, len = str.length; i < len; i++) {\n const chCode = str.charCodeAt(i);\n if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) {\n return i;\n }\n }\n return -1;\n}\n/**\n * Returns the leading whitespace of the string.\n * If the string contains only whitespaces, returns entire string\n */\nexport function getLeadingWhitespace(str, start = 0, end = str.length) {\n for (let i = start; i < end; i++) {\n const chCode = str.charCodeAt(i);\n if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) {\n return str.substring(start, i);\n }\n }\n return str.substring(start, end);\n}\n/**\n * Returns last index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function lastNonWhitespaceIndex(str, startIndex = str.length - 1) {\n for (let i = startIndex; i >= 0; i--) {\n const chCode = str.charCodeAt(i);\n if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) {\n return i;\n }\n }\n return -1;\n}\nexport function compare(a, b) {\n if (a < b) {\n return -1;\n }\n else if (a > b) {\n return 1;\n }\n else {\n return 0;\n }\n}\nexport function compareSubstring(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {\n for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {\n const codeA = a.charCodeAt(aStart);\n const codeB = b.charCodeAt(bStart);\n if (codeA < codeB) {\n return -1;\n }\n else if (codeA > codeB) {\n return 1;\n }\n }\n const aLen = aEnd - aStart;\n const bLen = bEnd - bStart;\n if (aLen < bLen) {\n return -1;\n }\n else if (aLen > bLen) {\n return 1;\n }\n return 0;\n}\nexport function compareIgnoreCase(a, b) {\n return compareSubstringIgnoreCase(a, b, 0, a.length, 0, b.length);\n}\nexport function compareSubstringIgnoreCase(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {\n for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {\n let codeA = a.charCodeAt(aStart);\n let codeB = b.charCodeAt(bStart);\n if (codeA === codeB) {\n // equal\n continue;\n }\n if (codeA >= 128 || codeB >= 128) {\n // not ASCII letters -> fallback to lower-casing strings\n return compareSubstring(a.toLowerCase(), b.toLowerCase(), aStart, aEnd, bStart, bEnd);\n }\n // mapper lower-case ascii letter onto upper-case varinats\n // [97-122] (lower ascii) --> [65-90] (upper ascii)\n if (isLowerAsciiLetter(codeA)) {\n codeA -= 32;\n }\n if (isLowerAsciiLetter(codeB)) {\n codeB -= 32;\n }\n // compare both code points\n const diff = codeA - codeB;\n if (diff === 0) {\n continue;\n }\n return diff;\n }\n const aLen = aEnd - aStart;\n const bLen = bEnd - bStart;\n if (aLen < bLen) {\n return -1;\n }\n else if (aLen > bLen) {\n return 1;\n }\n return 0;\n}\nexport function isAsciiDigit(code) {\n return code >= 48 /* CharCode.Digit0 */ && code <= 57 /* CharCode.Digit9 */;\n}\nexport function isLowerAsciiLetter(code) {\n return code >= 97 /* CharCode.a */ && code <= 122 /* CharCode.z */;\n}\nexport function isUpperAsciiLetter(code) {\n return code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */;\n}\nexport function equalsIgnoreCase(a, b) {\n return a.length === b.length && compareSubstringIgnoreCase(a, b) === 0;\n}\nexport function startsWithIgnoreCase(str, candidate) {\n const candidateLength = candidate.length;\n if (candidate.length > str.length) {\n return false;\n }\n return compareSubstringIgnoreCase(str, candidate, 0, candidateLength) === 0;\n}\n/**\n * @returns the length of the common prefix of the two strings.\n */\nexport function commonPrefixLength(a, b) {\n const len = Math.min(a.length, b.length);\n let i;\n for (i = 0; i < len; i++) {\n if (a.charCodeAt(i) !== b.charCodeAt(i)) {\n return i;\n }\n }\n return len;\n}\n/**\n * @returns the length of the common suffix of the two strings.\n */\nexport function commonSuffixLength(a, b) {\n const len = Math.min(a.length, b.length);\n let i;\n const aLastIndex = a.length - 1;\n const bLastIndex = b.length - 1;\n for (i = 0; i < len; i++) {\n if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {\n return i;\n }\n }\n return len;\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function isHighSurrogate(charCode) {\n return (0xD800 <= charCode && charCode <= 0xDBFF);\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function isLowSurrogate(charCode) {\n return (0xDC00 <= charCode && charCode <= 0xDFFF);\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function computeCodePoint(highSurrogate, lowSurrogate) {\n return ((highSurrogate - 0xD800) << 10) + (lowSurrogate - 0xDC00) + 0x10000;\n}\n/**\n * get the code point that begins at offset `offset`\n */\nexport function getNextCodePoint(str, len, offset) {\n const charCode = str.charCodeAt(offset);\n if (isHighSurrogate(charCode) && offset + 1 < len) {\n const nextCharCode = str.charCodeAt(offset + 1);\n if (isLowSurrogate(nextCharCode)) {\n return computeCodePoint(charCode, nextCharCode);\n }\n }\n return charCode;\n}\n/**\n * get the code point that ends right before offset `offset`\n */\nfunction getPrevCodePoint(str, offset) {\n const charCode = str.charCodeAt(offset - 1);\n if (isLowSurrogate(charCode) && offset > 1) {\n const prevCharCode = str.charCodeAt(offset - 2);\n if (isHighSurrogate(prevCharCode)) {\n return computeCodePoint(prevCharCode, charCode);\n }\n }\n return charCode;\n}\nexport class CodePointIterator {\n get offset() {\n return this._offset;\n }\n constructor(str, offset = 0) {\n this._str = str;\n this._len = str.length;\n this._offset = offset;\n }\n setOffset(offset) {\n this._offset = offset;\n }\n prevCodePoint() {\n const codePoint = getPrevCodePoint(this._str, this._offset);\n this._offset -= (codePoint >= 65536 /* Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n return codePoint;\n }\n nextCodePoint() {\n const codePoint = getNextCodePoint(this._str, this._len, this._offset);\n this._offset += (codePoint >= 65536 /* Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n return codePoint;\n }\n eol() {\n return (this._offset >= this._len);\n }\n}\nexport class GraphemeIterator {\n get offset() {\n return this._iterator.offset;\n }\n constructor(str, offset = 0) {\n this._iterator = new CodePointIterator(str, offset);\n }\n nextGraphemeLength() {\n const graphemeBreakTree = GraphemeBreakTree.getInstance();\n const iterator = this._iterator;\n const initialOffset = iterator.offset;\n let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.nextCodePoint());\n while (!iterator.eol()) {\n const offset = iterator.offset;\n const nextGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.nextCodePoint());\n if (breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {\n // move iterator back\n iterator.setOffset(offset);\n break;\n }\n graphemeBreakType = nextGraphemeBreakType;\n }\n return (iterator.offset - initialOffset);\n }\n prevGraphemeLength() {\n const graphemeBreakTree = GraphemeBreakTree.getInstance();\n const iterator = this._iterator;\n const initialOffset = iterator.offset;\n let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.prevCodePoint());\n while (iterator.offset > 0) {\n const offset = iterator.offset;\n const prevGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.prevCodePoint());\n if (breakBetweenGraphemeBreakType(prevGraphemeBreakType, graphemeBreakType)) {\n // move iterator back\n iterator.setOffset(offset);\n break;\n }\n graphemeBreakType = prevGraphemeBreakType;\n }\n return (initialOffset - iterator.offset);\n }\n eol() {\n return this._iterator.eol();\n }\n}\nexport function nextCharLength(str, initialOffset) {\n const iterator = new GraphemeIterator(str, initialOffset);\n return iterator.nextGraphemeLength();\n}\nexport function prevCharLength(str, initialOffset) {\n const iterator = new GraphemeIterator(str, initialOffset);\n return iterator.prevGraphemeLength();\n}\nexport function getCharContainingOffset(str, offset) {\n if (offset > 0 && isLowSurrogate(str.charCodeAt(offset))) {\n offset--;\n }\n const endOffset = offset + nextCharLength(str, offset);\n const startOffset = endOffset - prevCharLength(str, endOffset);\n return [startOffset, endOffset];\n}\nlet CONTAINS_RTL = undefined;\nfunction makeContainsRtl() {\n // Generated using https://github.com/alexdima/unicode-utils/blob/main/rtl-test.js\n return /(?:[\\u05BE\\u05C0\\u05C3\\u05C6\\u05D0-\\u05F4\\u0608\\u060B\\u060D\\u061B-\\u064A\\u066D-\\u066F\\u0671-\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1-\\u07EA\\u07F4\\u07F5\\u07FA\\u07FE-\\u0815\\u081A\\u0824\\u0828\\u0830-\\u0858\\u085E-\\u088E\\u08A0-\\u08C9\\u200F\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFD3D\\uFD50-\\uFDC7\\uFDF0-\\uFDFC\\uFE70-\\uFEFC]|\\uD802[\\uDC00-\\uDD1B\\uDD20-\\uDE00\\uDE10-\\uDE35\\uDE40-\\uDEE4\\uDEEB-\\uDF35\\uDF40-\\uDFFF]|\\uD803[\\uDC00-\\uDD23\\uDE80-\\uDEA9\\uDEAD-\\uDF45\\uDF51-\\uDF81\\uDF86-\\uDFF6]|\\uD83A[\\uDC00-\\uDCCF\\uDD00-\\uDD43\\uDD4B-\\uDFFF]|\\uD83B[\\uDC00-\\uDEBB])/;\n}\n/**\n * Returns true if `str` contains any Unicode character that is classified as \"R\" or \"AL\".\n */\nexport function containsRTL(str) {\n if (!CONTAINS_RTL) {\n CONTAINS_RTL = makeContainsRtl();\n }\n return CONTAINS_RTL.test(str);\n}\nconst IS_BASIC_ASCII = /^[\\t\\n\\r\\x20-\\x7E]*$/;\n/**\n * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \\n, \\r, \\t\n */\nexport function isBasicASCII(str) {\n return IS_BASIC_ASCII.test(str);\n}\nexport const UNUSUAL_LINE_TERMINATORS = /[\\u2028\\u2029]/; // LINE SEPARATOR (LS) or PARAGRAPH SEPARATOR (PS)\n/**\n * Returns true if `str` contains unusual line terminators, like LS or PS\n */\nexport function containsUnusualLineTerminators(str) {\n return UNUSUAL_LINE_TERMINATORS.test(str);\n}\nexport function isFullWidthCharacter(charCode) {\n // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns\n // http://jrgraphix.net/research/unicode_blocks.php\n // 2E80 - 2EFF CJK Radicals Supplement\n // 2F00 - 2FDF Kangxi Radicals\n // 2FF0 - 2FFF Ideographic Description Characters\n // 3000 - 303F CJK Symbols and Punctuation\n // 3040 - 309F Hiragana\n // 30A0 - 30FF Katakana\n // 3100 - 312F Bopomofo\n // 3130 - 318F Hangul Compatibility Jamo\n // 3190 - 319F Kanbun\n // 31A0 - 31BF Bopomofo Extended\n // 31F0 - 31FF Katakana Phonetic Extensions\n // 3200 - 32FF Enclosed CJK Letters and Months\n // 3300 - 33FF CJK Compatibility\n // 3400 - 4DBF CJK Unified Ideographs Extension A\n // 4DC0 - 4DFF Yijing Hexagram Symbols\n // 4E00 - 9FFF CJK Unified Ideographs\n // A000 - A48F Yi Syllables\n // A490 - A4CF Yi Radicals\n // AC00 - D7AF Hangul Syllables\n // [IGNORE] D800 - DB7F High Surrogates\n // [IGNORE] DB80 - DBFF High Private Use Surrogates\n // [IGNORE] DC00 - DFFF Low Surrogates\n // [IGNORE] E000 - F8FF Private Use Area\n // F900 - FAFF CJK Compatibility Ideographs\n // [IGNORE] FB00 - FB4F Alphabetic Presentation Forms\n // [IGNORE] FB50 - FDFF Arabic Presentation Forms-A\n // [IGNORE] FE00 - FE0F Variation Selectors\n // [IGNORE] FE20 - FE2F Combining Half Marks\n // [IGNORE] FE30 - FE4F CJK Compatibility Forms\n // [IGNORE] FE50 - FE6F Small Form Variants\n // [IGNORE] FE70 - FEFF Arabic Presentation Forms-B\n // FF00 - FFEF Halfwidth and Fullwidth Forms\n // [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]\n // of which FF01 - FF5E fullwidth ASCII of 21 to 7E\n // [IGNORE] and FF65 - FFDC halfwidth of Katakana and Hangul\n // [IGNORE] FFF0 - FFFF Specials\n return ((charCode >= 0x2E80 && charCode <= 0xD7AF)\n || (charCode >= 0xF900 && charCode <= 0xFAFF)\n || (charCode >= 0xFF01 && charCode <= 0xFF5E));\n}\n/**\n * A fast function (therefore imprecise) to check if code points are emojis.\n * Generated using https://github.com/alexdima/unicode-utils/blob/main/emoji-test.js\n */\nexport function isEmojiImprecise(x) {\n return ((x >= 0x1F1E6 && x <= 0x1F1FF) || (x === 8986) || (x === 8987) || (x === 9200)\n || (x === 9203) || (x >= 9728 && x <= 10175) || (x === 11088) || (x === 11093)\n || (x >= 127744 && x <= 128591) || (x >= 128640 && x <= 128764)\n || (x >= 128992 && x <= 129008) || (x >= 129280 && x <= 129535)\n || (x >= 129648 && x <= 129782));\n}\n// -- UTF-8 BOM\nexport const UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* CharCode.UTF8_BOM */);\nexport function startsWithUTF8BOM(str) {\n return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* CharCode.UTF8_BOM */);\n}\nexport function containsUppercaseCharacter(target, ignoreEscapedChars = false) {\n if (!target) {\n return false;\n }\n if (ignoreEscapedChars) {\n target = target.replace(/\\\\./g, '');\n }\n return target.toLowerCase() !== target;\n}\n/**\n * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.\n */\nexport function singleLetterHash(n) {\n const LETTERS_CNT = (90 /* CharCode.Z */ - 65 /* CharCode.A */ + 1);\n n = n % (2 * LETTERS_CNT);\n if (n < LETTERS_CNT) {\n return String.fromCharCode(97 /* CharCode.a */ + n);\n }\n return String.fromCharCode(65 /* CharCode.A */ + n - LETTERS_CNT);\n}\nfunction breakBetweenGraphemeBreakType(breakTypeA, breakTypeB) {\n // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules\n // !!! Let's make the common case a bit faster\n if (breakTypeA === 0 /* GraphemeBreakType.Other */) {\n // see https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakTest-13.0.0d10.html#table\n return (breakTypeB !== 5 /* GraphemeBreakType.Extend */ && breakTypeB !== 7 /* GraphemeBreakType.SpacingMark */);\n }\n // Do not break between a CR and LF. Otherwise, break before and after controls.\n // GB3 CR × LF\n // GB4 (Control | CR | LF) ÷\n // GB5 ÷ (Control | CR | LF)\n if (breakTypeA === 2 /* GraphemeBreakType.CR */) {\n if (breakTypeB === 3 /* GraphemeBreakType.LF */) {\n return false; // GB3\n }\n }\n if (breakTypeA === 4 /* GraphemeBreakType.Control */ || breakTypeA === 2 /* GraphemeBreakType.CR */ || breakTypeA === 3 /* GraphemeBreakType.LF */) {\n return true; // GB4\n }\n if (breakTypeB === 4 /* GraphemeBreakType.Control */ || breakTypeB === 2 /* GraphemeBreakType.CR */ || breakTypeB === 3 /* GraphemeBreakType.LF */) {\n return true; // GB5\n }\n // Do not break Hangul syllable sequences.\n // GB6 L × (L | V | LV | LVT)\n // GB7 (LV | V) × (V | T)\n // GB8 (LVT | T) × T\n if (breakTypeA === 8 /* GraphemeBreakType.L */) {\n if (breakTypeB === 8 /* GraphemeBreakType.L */ || breakTypeB === 9 /* GraphemeBreakType.V */ || breakTypeB === 11 /* GraphemeBreakType.LV */ || breakTypeB === 12 /* GraphemeBreakType.LVT */) {\n return false; // GB6\n }\n }\n if (breakTypeA === 11 /* GraphemeBreakType.LV */ || breakTypeA === 9 /* GraphemeBreakType.V */) {\n if (breakTypeB === 9 /* GraphemeBreakType.V */ || breakTypeB === 10 /* GraphemeBreakType.T */) {\n return false; // GB7\n }\n }\n if (breakTypeA === 12 /* GraphemeBreakType.LVT */ || breakTypeA === 10 /* GraphemeBreakType.T */) {\n if (breakTypeB === 10 /* GraphemeBreakType.T */) {\n return false; // GB8\n }\n }\n // Do not break before extending characters or ZWJ.\n // GB9 × (Extend | ZWJ)\n if (breakTypeB === 5 /* GraphemeBreakType.Extend */ || breakTypeB === 13 /* GraphemeBreakType.ZWJ */) {\n return false; // GB9\n }\n // The GB9a and GB9b rules only apply to extended grapheme clusters:\n // Do not break before SpacingMarks, or after Prepend characters.\n // GB9a × SpacingMark\n // GB9b Prepend ×\n if (breakTypeB === 7 /* GraphemeBreakType.SpacingMark */) {\n return false; // GB9a\n }\n if (breakTypeA === 1 /* GraphemeBreakType.Prepend */) {\n return false; // GB9b\n }\n // Do not break within emoji modifier sequences or emoji zwj sequences.\n // GB11 \\p{Extended_Pictographic} Extend* ZWJ × \\p{Extended_Pictographic}\n if (breakTypeA === 13 /* GraphemeBreakType.ZWJ */ && breakTypeB === 14 /* GraphemeBreakType.Extended_Pictographic */) {\n // Note: we are not implementing the rule entirely here to avoid introducing states\n return false; // GB11\n }\n // GB12 sot (RI RI)* RI × RI\n // GB13 [^RI] (RI RI)* RI × RI\n if (breakTypeA === 6 /* GraphemeBreakType.Regional_Indicator */ && breakTypeB === 6 /* GraphemeBreakType.Regional_Indicator */) {\n // Note: we are not implementing the rule entirely here to avoid introducing states\n return false; // GB12 & GB13\n }\n // GB999 Any ÷ Any\n return true;\n}\nclass GraphemeBreakTree {\n static getInstance() {\n if (!GraphemeBreakTree._INSTANCE) {\n GraphemeBreakTree._INSTANCE = new GraphemeBreakTree();\n }\n return GraphemeBreakTree._INSTANCE;\n }\n constructor() {\n this._data = getGraphemeBreakRawData();\n }\n getGraphemeBreakType(codePoint) {\n // !!! Let's make 7bit ASCII a bit faster: 0..31\n if (codePoint < 32) {\n if (codePoint === 10 /* CharCode.LineFeed */) {\n return 3 /* GraphemeBreakType.LF */;\n }\n if (codePoint === 13 /* CharCode.CarriageReturn */) {\n return 2 /* GraphemeBreakType.CR */;\n }\n return 4 /* GraphemeBreakType.Control */;\n }\n // !!! Let's make 7bit ASCII a bit faster: 32..126\n if (codePoint < 127) {\n return 0 /* GraphemeBreakType.Other */;\n }\n const data = this._data;\n const nodeCount = data.length / 3;\n let nodeIndex = 1;\n while (nodeIndex <= nodeCount) {\n if (codePoint < data[3 * nodeIndex]) {\n // go left\n nodeIndex = 2 * nodeIndex;\n }\n else if (codePoint > data[3 * nodeIndex + 1]) {\n // go right\n nodeIndex = 2 * nodeIndex + 1;\n }\n else {\n // hit\n return data[3 * nodeIndex + 2];\n }\n }\n return 0 /* GraphemeBreakType.Other */;\n }\n}\nGraphemeBreakTree._INSTANCE = null;\nfunction getGraphemeBreakRawData() {\n // generated using https://github.com/alexdima/unicode-utils/blob/main/grapheme-break.js\n return JSON.parse('[0,0,0,51229,51255,12,44061,44087,12,127462,127487,6,7083,7085,5,47645,47671,12,54813,54839,12,128678,128678,14,3270,3270,5,9919,9923,14,45853,45879,12,49437,49463,12,53021,53047,12,71216,71218,7,128398,128399,14,129360,129374,14,2519,2519,5,4448,4519,9,9742,9742,14,12336,12336,14,44957,44983,12,46749,46775,12,48541,48567,12,50333,50359,12,52125,52151,12,53917,53943,12,69888,69890,5,73018,73018,5,127990,127990,14,128558,128559,14,128759,128760,14,129653,129655,14,2027,2035,5,2891,2892,7,3761,3761,5,6683,6683,5,8293,8293,4,9825,9826,14,9999,9999,14,43452,43453,5,44509,44535,12,45405,45431,12,46301,46327,12,47197,47223,12,48093,48119,12,48989,49015,12,49885,49911,12,50781,50807,12,51677,51703,12,52573,52599,12,53469,53495,12,54365,54391,12,65279,65279,4,70471,70472,7,72145,72147,7,119173,119179,5,127799,127818,14,128240,128244,14,128512,128512,14,128652,128652,14,128721,128722,14,129292,129292,14,129445,129450,14,129734,129743,14,1476,1477,5,2366,2368,7,2750,2752,7,3076,3076,5,3415,3415,5,4141,4144,5,6109,6109,5,6964,6964,5,7394,7400,5,9197,9198,14,9770,9770,14,9877,9877,14,9968,9969,14,10084,10084,14,43052,43052,5,43713,43713,5,44285,44311,12,44733,44759,12,45181,45207,12,45629,45655,12,46077,46103,12,46525,46551,12,46973,46999,12,47421,47447,12,47869,47895,12,48317,48343,12,48765,48791,12,49213,49239,12,49661,49687,12,50109,50135,12,50557,50583,12,51005,51031,12,51453,51479,12,51901,51927,12,52349,52375,12,52797,52823,12,53245,53271,12,53693,53719,12,54141,54167,12,54589,54615,12,55037,55063,12,69506,69509,5,70191,70193,5,70841,70841,7,71463,71467,5,72330,72342,5,94031,94031,5,123628,123631,5,127763,127765,14,127941,127941,14,128043,128062,14,128302,128317,14,128465,128467,14,128539,128539,14,128640,128640,14,128662,128662,14,128703,128703,14,128745,128745,14,129004,129007,14,129329,129330,14,129402,129402,14,129483,129483,14,129686,129704,14,130048,131069,14,173,173,4,1757,1757,1,2200,2207,5,2434,2435,7,2631,2632,5,2817,2817,5,3008,3008,5,3201,3201,5,3387,3388,5,3542,3542,5,3902,3903,7,4190,4192,5,6002,6003,5,6439,6440,5,6765,6770,7,7019,7027,5,7154,7155,7,8205,8205,13,8505,8505,14,9654,9654,14,9757,9757,14,9792,9792,14,9852,9853,14,9890,9894,14,9937,9937,14,9981,9981,14,10035,10036,14,11035,11036,14,42654,42655,5,43346,43347,7,43587,43587,5,44006,44007,7,44173,44199,12,44397,44423,12,44621,44647,12,44845,44871,12,45069,45095,12,45293,45319,12,45517,45543,12,45741,45767,12,45965,45991,12,46189,46215,12,46413,46439,12,46637,46663,12,46861,46887,12,47085,47111,12,47309,47335,12,47533,47559,12,47757,47783,12,47981,48007,12,48205,48231,12,48429,48455,12,48653,48679,12,48877,48903,12,49101,49127,12,49325,49351,12,49549,49575,12,49773,49799,12,49997,50023,12,50221,50247,12,50445,50471,12,50669,50695,12,50893,50919,12,51117,51143,12,51341,51367,12,51565,51591,12,51789,51815,12,52013,52039,12,52237,52263,12,52461,52487,12,52685,52711,12,52909,52935,12,53133,53159,12,53357,53383,12,53581,53607,12,53805,53831,12,54029,54055,12,54253,54279,12,54477,54503,12,54701,54727,12,54925,54951,12,55149,55175,12,68101,68102,5,69762,69762,7,70067,70069,7,70371,70378,5,70720,70721,7,71087,71087,5,71341,71341,5,71995,71996,5,72249,72249,7,72850,72871,5,73109,73109,5,118576,118598,5,121505,121519,5,127245,127247,14,127568,127569,14,127777,127777,14,127872,127891,14,127956,127967,14,128015,128016,14,128110,128172,14,128259,128259,14,128367,128368,14,128424,128424,14,128488,128488,14,128530,128532,14,128550,128551,14,128566,128566,14,128647,128647,14,128656,128656,14,128667,128673,14,128691,128693,14,128715,128715,14,128728,128732,14,128752,128752,14,128765,128767,14,129096,129103,14,129311,129311,14,129344,129349,14,129394,129394,14,129413,129425,14,129466,129471,14,129511,129535,14,129664,129666,14,129719,129722,14,129760,129767,14,917536,917631,5,13,13,2,1160,1161,5,1564,1564,4,1807,1807,1,2085,2087,5,2307,2307,7,2382,2383,7,2497,2500,5,2563,2563,7,2677,2677,5,2763,2764,7,2879,2879,5,2914,2915,5,3021,3021,5,3142,3144,5,3263,3263,5,3285,3286,5,3398,3400,7,3530,3530,5,3633,3633,5,3864,3865,5,3974,3975,5,4155,4156,7,4229,4230,5,5909,5909,7,6078,6085,7,6277,6278,5,6451,6456,7,6744,6750,5,6846,6846,5,6972,6972,5,7074,7077,5,7146,7148,7,7222,7223,5,7416,7417,5,8234,8238,4,8417,8417,5,9000,9000,14,9203,9203,14,9730,9731,14,9748,9749,14,9762,9763,14,9776,9783,14,9800,9811,14,9831,9831,14,9872,9873,14,9882,9882,14,9900,9903,14,9929,9933,14,9941,9960,14,9974,9974,14,9989,9989,14,10006,10006,14,10062,10062,14,10160,10160,14,11647,11647,5,12953,12953,14,43019,43019,5,43232,43249,5,43443,43443,5,43567,43568,7,43696,43696,5,43765,43765,7,44013,44013,5,44117,44143,12,44229,44255,12,44341,44367,12,44453,44479,12,44565,44591,12,44677,44703,12,44789,44815,12,44901,44927,12,45013,45039,12,45125,45151,12,45237,45263,12,45349,45375,12,45461,45487,12,45573,45599,12,45685,45711,12,45797,45823,12,45909,45935,12,46021,46047,12,46133,46159,12,46245,46271,12,46357,46383,12,46469,46495,12,46581,46607,12,46693,46719,12,46805,46831,12,46917,46943,12,47029,47055,12,47141,47167,12,47253,47279,12,47365,47391,12,47477,47503,12,47589,47615,12,47701,47727,12,47813,47839,12,47925,47951,12,48037,48063,12,48149,48175,12,48261,48287,12,48373,48399,12,48485,48511,12,48597,48623,12,48709,48735,12,48821,48847,12,48933,48959,12,49045,49071,12,49157,49183,12,49269,49295,12,49381,49407,12,49493,49519,12,49605,49631,12,49717,49743,12,49829,49855,12,49941,49967,12,50053,50079,12,50165,50191,12,50277,50303,12,50389,50415,12,50501,50527,12,50613,50639,12,50725,50751,12,50837,50863,12,50949,50975,12,51061,51087,12,51173,51199,12,51285,51311,12,51397,51423,12,51509,51535,12,51621,51647,12,51733,51759,12,51845,51871,12,51957,51983,12,52069,52095,12,52181,52207,12,52293,52319,12,52405,52431,12,52517,52543,12,52629,52655,12,52741,52767,12,52853,52879,12,52965,52991,12,53077,53103,12,53189,53215,12,53301,53327,12,53413,53439,12,53525,53551,12,53637,53663,12,53749,53775,12,53861,53887,12,53973,53999,12,54085,54111,12,54197,54223,12,54309,54335,12,54421,54447,12,54533,54559,12,54645,54671,12,54757,54783,12,54869,54895,12,54981,55007,12,55093,55119,12,55243,55291,10,66045,66045,5,68325,68326,5,69688,69702,5,69817,69818,5,69957,69958,7,70089,70092,5,70198,70199,5,70462,70462,5,70502,70508,5,70750,70750,5,70846,70846,7,71100,71101,5,71230,71230,7,71351,71351,5,71737,71738,5,72000,72000,7,72160,72160,5,72273,72278,5,72752,72758,5,72882,72883,5,73031,73031,5,73461,73462,7,94192,94193,7,119149,119149,7,121403,121452,5,122915,122916,5,126980,126980,14,127358,127359,14,127535,127535,14,127759,127759,14,127771,127771,14,127792,127793,14,127825,127867,14,127897,127899,14,127945,127945,14,127985,127986,14,128000,128007,14,128021,128021,14,128066,128100,14,128184,128235,14,128249,128252,14,128266,128276,14,128335,128335,14,128379,128390,14,128407,128419,14,128444,128444,14,128481,128481,14,128499,128499,14,128526,128526,14,128536,128536,14,128543,128543,14,128556,128556,14,128564,128564,14,128577,128580,14,128643,128645,14,128649,128649,14,128654,128654,14,128660,128660,14,128664,128664,14,128675,128675,14,128686,128689,14,128695,128696,14,128705,128709,14,128717,128719,14,128725,128725,14,128736,128741,14,128747,128748,14,128755,128755,14,128762,128762,14,128981,128991,14,129009,129023,14,129160,129167,14,129296,129304,14,129320,129327,14,129340,129342,14,129356,129356,14,129388,129392,14,129399,129400,14,129404,129407,14,129432,129442,14,129454,129455,14,129473,129474,14,129485,129487,14,129648,129651,14,129659,129660,14,129671,129679,14,129709,129711,14,129728,129730,14,129751,129753,14,129776,129782,14,917505,917505,4,917760,917999,5,10,10,3,127,159,4,768,879,5,1471,1471,5,1536,1541,1,1648,1648,5,1767,1768,5,1840,1866,5,2070,2073,5,2137,2139,5,2274,2274,1,2363,2363,7,2377,2380,7,2402,2403,5,2494,2494,5,2507,2508,7,2558,2558,5,2622,2624,7,2641,2641,5,2691,2691,7,2759,2760,5,2786,2787,5,2876,2876,5,2881,2884,5,2901,2902,5,3006,3006,5,3014,3016,7,3072,3072,5,3134,3136,5,3157,3158,5,3260,3260,5,3266,3266,5,3274,3275,7,3328,3329,5,3391,3392,7,3405,3405,5,3457,3457,5,3536,3537,7,3551,3551,5,3636,3642,5,3764,3772,5,3895,3895,5,3967,3967,7,3993,4028,5,4146,4151,5,4182,4183,7,4226,4226,5,4253,4253,5,4957,4959,5,5940,5940,7,6070,6070,7,6087,6088,7,6158,6158,4,6432,6434,5,6448,6449,7,6679,6680,5,6742,6742,5,6754,6754,5,6783,6783,5,6912,6915,5,6966,6970,5,6978,6978,5,7042,7042,7,7080,7081,5,7143,7143,7,7150,7150,7,7212,7219,5,7380,7392,5,7412,7412,5,8203,8203,4,8232,8232,4,8265,8265,14,8400,8412,5,8421,8432,5,8617,8618,14,9167,9167,14,9200,9200,14,9410,9410,14,9723,9726,14,9733,9733,14,9745,9745,14,9752,9752,14,9760,9760,14,9766,9766,14,9774,9774,14,9786,9786,14,9794,9794,14,9823,9823,14,9828,9828,14,9833,9850,14,9855,9855,14,9875,9875,14,9880,9880,14,9885,9887,14,9896,9897,14,9906,9916,14,9926,9927,14,9935,9935,14,9939,9939,14,9962,9962,14,9972,9972,14,9978,9978,14,9986,9986,14,9997,9997,14,10002,10002,14,10017,10017,14,10055,10055,14,10071,10071,14,10133,10135,14,10548,10549,14,11093,11093,14,12330,12333,5,12441,12442,5,42608,42610,5,43010,43010,5,43045,43046,5,43188,43203,7,43302,43309,5,43392,43394,5,43446,43449,5,43493,43493,5,43571,43572,7,43597,43597,7,43703,43704,5,43756,43757,5,44003,44004,7,44009,44010,7,44033,44059,12,44089,44115,12,44145,44171,12,44201,44227,12,44257,44283,12,44313,44339,12,44369,44395,12,44425,44451,12,44481,44507,12,44537,44563,12,44593,44619,12,44649,44675,12,44705,44731,12,44761,44787,12,44817,44843,12,44873,44899,12,44929,44955,12,44985,45011,12,45041,45067,12,45097,45123,12,45153,45179,12,45209,45235,12,45265,45291,12,45321,45347,12,45377,45403,12,45433,45459,12,45489,45515,12,45545,45571,12,45601,45627,12,45657,45683,12,45713,45739,12,45769,45795,12,45825,45851,12,45881,45907,12,45937,45963,12,45993,46019,12,46049,46075,12,46105,46131,12,46161,46187,12,46217,46243,12,46273,46299,12,46329,46355,12,46385,46411,12,46441,46467,12,46497,46523,12,46553,46579,12,46609,46635,12,46665,46691,12,46721,46747,12,46777,46803,12,46833,46859,12,46889,46915,12,46945,46971,12,47001,47027,12,47057,47083,12,47113,47139,12,47169,47195,12,47225,47251,12,47281,47307,12,47337,47363,12,47393,47419,12,47449,47475,12,47505,47531,12,47561,47587,12,47617,47643,12,47673,47699,12,47729,47755,12,47785,47811,12,47841,47867,12,47897,47923,12,47953,47979,12,48009,48035,12,48065,48091,12,48121,48147,12,48177,48203,12,48233,48259,12,48289,48315,12,48345,48371,12,48401,48427,12,48457,48483,12,48513,48539,12,48569,48595,12,48625,48651,12,48681,48707,12,48737,48763,12,48793,48819,12,48849,48875,12,48905,48931,12,48961,48987,12,49017,49043,12,49073,49099,12,49129,49155,12,49185,49211,12,49241,49267,12,49297,49323,12,49353,49379,12,49409,49435,12,49465,49491,12,49521,49547,12,49577,49603,12,49633,49659,12,49689,49715,12,49745,49771,12,49801,49827,12,49857,49883,12,49913,49939,12,49969,49995,12,50025,50051,12,50081,50107,12,50137,50163,12,50193,50219,12,50249,50275,12,50305,50331,12,50361,50387,12,50417,50443,12,50473,50499,12,50529,50555,12,50585,50611,12,50641,50667,12,50697,50723,12,50753,50779,12,50809,50835,12,50865,50891,12,50921,50947,12,50977,51003,12,51033,51059,12,51089,51115,12,51145,51171,12,51201,51227,12,51257,51283,12,51313,51339,12,51369,51395,12,51425,51451,12,51481,51507,12,51537,51563,12,51593,51619,12,51649,51675,12,51705,51731,12,51761,51787,12,51817,51843,12,51873,51899,12,51929,51955,12,51985,52011,12,52041,52067,12,52097,52123,12,52153,52179,12,52209,52235,12,52265,52291,12,52321,52347,12,52377,52403,12,52433,52459,12,52489,52515,12,52545,52571,12,52601,52627,12,52657,52683,12,52713,52739,12,52769,52795,12,52825,52851,12,52881,52907,12,52937,52963,12,52993,53019,12,53049,53075,12,53105,53131,12,53161,53187,12,53217,53243,12,53273,53299,12,53329,53355,12,53385,53411,12,53441,53467,12,53497,53523,12,53553,53579,12,53609,53635,12,53665,53691,12,53721,53747,12,53777,53803,12,53833,53859,12,53889,53915,12,53945,53971,12,54001,54027,12,54057,54083,12,54113,54139,12,54169,54195,12,54225,54251,12,54281,54307,12,54337,54363,12,54393,54419,12,54449,54475,12,54505,54531,12,54561,54587,12,54617,54643,12,54673,54699,12,54729,54755,12,54785,54811,12,54841,54867,12,54897,54923,12,54953,54979,12,55009,55035,12,55065,55091,12,55121,55147,12,55177,55203,12,65024,65039,5,65520,65528,4,66422,66426,5,68152,68154,5,69291,69292,5,69633,69633,5,69747,69748,5,69811,69814,5,69826,69826,5,69932,69932,7,70016,70017,5,70079,70080,7,70095,70095,5,70196,70196,5,70367,70367,5,70402,70403,7,70464,70464,5,70487,70487,5,70709,70711,7,70725,70725,7,70833,70834,7,70843,70844,7,70849,70849,7,71090,71093,5,71103,71104,5,71227,71228,7,71339,71339,5,71344,71349,5,71458,71461,5,71727,71735,5,71985,71989,7,71998,71998,5,72002,72002,7,72154,72155,5,72193,72202,5,72251,72254,5,72281,72283,5,72344,72345,5,72766,72766,7,72874,72880,5,72885,72886,5,73023,73029,5,73104,73105,5,73111,73111,5,92912,92916,5,94095,94098,5,113824,113827,4,119142,119142,7,119155,119162,4,119362,119364,5,121476,121476,5,122888,122904,5,123184,123190,5,125252,125258,5,127183,127183,14,127340,127343,14,127377,127386,14,127491,127503,14,127548,127551,14,127744,127756,14,127761,127761,14,127769,127769,14,127773,127774,14,127780,127788,14,127796,127797,14,127820,127823,14,127869,127869,14,127894,127895,14,127902,127903,14,127943,127943,14,127947,127950,14,127972,127972,14,127988,127988,14,127992,127994,14,128009,128011,14,128019,128019,14,128023,128041,14,128064,128064,14,128102,128107,14,128174,128181,14,128238,128238,14,128246,128247,14,128254,128254,14,128264,128264,14,128278,128299,14,128329,128330,14,128348,128359,14,128371,128377,14,128392,128393,14,128401,128404,14,128421,128421,14,128433,128434,14,128450,128452,14,128476,128478,14,128483,128483,14,128495,128495,14,128506,128506,14,128519,128520,14,128528,128528,14,128534,128534,14,128538,128538,14,128540,128542,14,128544,128549,14,128552,128555,14,128557,128557,14,128560,128563,14,128565,128565,14,128567,128576,14,128581,128591,14,128641,128642,14,128646,128646,14,128648,128648,14,128650,128651,14,128653,128653,14,128655,128655,14,128657,128659,14,128661,128661,14,128663,128663,14,128665,128666,14,128674,128674,14,128676,128677,14,128679,128685,14,128690,128690,14,128694,128694,14,128697,128702,14,128704,128704,14,128710,128714,14,128716,128716,14,128720,128720,14,128723,128724,14,128726,128727,14,128733,128735,14,128742,128744,14,128746,128746,14,128749,128751,14,128753,128754,14,128756,128758,14,128761,128761,14,128763,128764,14,128884,128895,14,128992,129003,14,129008,129008,14,129036,129039,14,129114,129119,14,129198,129279,14,129293,129295,14,129305,129310,14,129312,129319,14,129328,129328,14,129331,129338,14,129343,129343,14,129351,129355,14,129357,129359,14,129375,129387,14,129393,129393,14,129395,129398,14,129401,129401,14,129403,129403,14,129408,129412,14,129426,129431,14,129443,129444,14,129451,129453,14,129456,129465,14,129472,129472,14,129475,129482,14,129484,129484,14,129488,129510,14,129536,129647,14,129652,129652,14,129656,129658,14,129661,129663,14,129667,129670,14,129680,129685,14,129705,129708,14,129712,129718,14,129723,129727,14,129731,129733,14,129744,129750,14,129754,129759,14,129768,129775,14,129783,129791,14,917504,917504,4,917506,917535,4,917632,917759,4,918000,921599,4,0,9,4,11,12,4,14,31,4,169,169,14,174,174,14,1155,1159,5,1425,1469,5,1473,1474,5,1479,1479,5,1552,1562,5,1611,1631,5,1750,1756,5,1759,1764,5,1770,1773,5,1809,1809,5,1958,1968,5,2045,2045,5,2075,2083,5,2089,2093,5,2192,2193,1,2250,2273,5,2275,2306,5,2362,2362,5,2364,2364,5,2369,2376,5,2381,2381,5,2385,2391,5,2433,2433,5,2492,2492,5,2495,2496,7,2503,2504,7,2509,2509,5,2530,2531,5,2561,2562,5,2620,2620,5,2625,2626,5,2635,2637,5,2672,2673,5,2689,2690,5,2748,2748,5,2753,2757,5,2761,2761,7,2765,2765,5,2810,2815,5,2818,2819,7,2878,2878,5,2880,2880,7,2887,2888,7,2893,2893,5,2903,2903,5,2946,2946,5,3007,3007,7,3009,3010,7,3018,3020,7,3031,3031,5,3073,3075,7,3132,3132,5,3137,3140,7,3146,3149,5,3170,3171,5,3202,3203,7,3262,3262,7,3264,3265,7,3267,3268,7,3271,3272,7,3276,3277,5,3298,3299,5,3330,3331,7,3390,3390,5,3393,3396,5,3402,3404,7,3406,3406,1,3426,3427,5,3458,3459,7,3535,3535,5,3538,3540,5,3544,3550,7,3570,3571,7,3635,3635,7,3655,3662,5,3763,3763,7,3784,3789,5,3893,3893,5,3897,3897,5,3953,3966,5,3968,3972,5,3981,3991,5,4038,4038,5,4145,4145,7,4153,4154,5,4157,4158,5,4184,4185,5,4209,4212,5,4228,4228,7,4237,4237,5,4352,4447,8,4520,4607,10,5906,5908,5,5938,5939,5,5970,5971,5,6068,6069,5,6071,6077,5,6086,6086,5,6089,6099,5,6155,6157,5,6159,6159,5,6313,6313,5,6435,6438,7,6441,6443,7,6450,6450,5,6457,6459,5,6681,6682,7,6741,6741,7,6743,6743,7,6752,6752,5,6757,6764,5,6771,6780,5,6832,6845,5,6847,6862,5,6916,6916,7,6965,6965,5,6971,6971,7,6973,6977,7,6979,6980,7,7040,7041,5,7073,7073,7,7078,7079,7,7082,7082,7,7142,7142,5,7144,7145,5,7149,7149,5,7151,7153,5,7204,7211,7,7220,7221,7,7376,7378,5,7393,7393,7,7405,7405,5,7415,7415,7,7616,7679,5,8204,8204,5,8206,8207,4,8233,8233,4,8252,8252,14,8288,8292,4,8294,8303,4,8413,8416,5,8418,8420,5,8482,8482,14,8596,8601,14,8986,8987,14,9096,9096,14,9193,9196,14,9199,9199,14,9201,9202,14,9208,9210,14,9642,9643,14,9664,9664,14,9728,9729,14,9732,9732,14,9735,9741,14,9743,9744,14,9746,9746,14,9750,9751,14,9753,9756,14,9758,9759,14,9761,9761,14,9764,9765,14,9767,9769,14,9771,9773,14,9775,9775,14,9784,9785,14,9787,9791,14,9793,9793,14,9795,9799,14,9812,9822,14,9824,9824,14,9827,9827,14,9829,9830,14,9832,9832,14,9851,9851,14,9854,9854,14,9856,9861,14,9874,9874,14,9876,9876,14,9878,9879,14,9881,9881,14,9883,9884,14,9888,9889,14,9895,9895,14,9898,9899,14,9904,9905,14,9917,9918,14,9924,9925,14,9928,9928,14,9934,9934,14,9936,9936,14,9938,9938,14,9940,9940,14,9961,9961,14,9963,9967,14,9970,9971,14,9973,9973,14,9975,9977,14,9979,9980,14,9982,9985,14,9987,9988,14,9992,9996,14,9998,9998,14,10000,10001,14,10004,10004,14,10013,10013,14,10024,10024,14,10052,10052,14,10060,10060,14,10067,10069,14,10083,10083,14,10085,10087,14,10145,10145,14,10175,10175,14,11013,11015,14,11088,11088,14,11503,11505,5,11744,11775,5,12334,12335,5,12349,12349,14,12951,12951,14,42607,42607,5,42612,42621,5,42736,42737,5,43014,43014,5,43043,43044,7,43047,43047,7,43136,43137,7,43204,43205,5,43263,43263,5,43335,43345,5,43360,43388,8,43395,43395,7,43444,43445,7,43450,43451,7,43454,43456,7,43561,43566,5,43569,43570,5,43573,43574,5,43596,43596,5,43644,43644,5,43698,43700,5,43710,43711,5,43755,43755,7,43758,43759,7,43766,43766,5,44005,44005,5,44008,44008,5,44012,44012,7,44032,44032,11,44060,44060,11,44088,44088,11,44116,44116,11,44144,44144,11,44172,44172,11,44200,44200,11,44228,44228,11,44256,44256,11,44284,44284,11,44312,44312,11,44340,44340,11,44368,44368,11,44396,44396,11,44424,44424,11,44452,44452,11,44480,44480,11,44508,44508,11,44536,44536,11,44564,44564,11,44592,44592,11,44620,44620,11,44648,44648,11,44676,44676,11,44704,44704,11,44732,44732,11,44760,44760,11,44788,44788,11,44816,44816,11,44844,44844,11,44872,44872,11,44900,44900,11,44928,44928,11,44956,44956,11,44984,44984,11,45012,45012,11,45040,45040,11,45068,45068,11,45096,45096,11,45124,45124,11,45152,45152,11,45180,45180,11,45208,45208,11,45236,45236,11,45264,45264,11,45292,45292,11,45320,45320,11,45348,45348,11,45376,45376,11,45404,45404,11,45432,45432,11,45460,45460,11,45488,45488,11,45516,45516,11,45544,45544,11,45572,45572,11,45600,45600,11,45628,45628,11,45656,45656,11,45684,45684,11,45712,45712,11,45740,45740,11,45768,45768,11,45796,45796,11,45824,45824,11,45852,45852,11,45880,45880,11,45908,45908,11,45936,45936,11,45964,45964,11,45992,45992,11,46020,46020,11,46048,46048,11,46076,46076,11,46104,46104,11,46132,46132,11,46160,46160,11,46188,46188,11,46216,46216,11,46244,46244,11,46272,46272,11,46300,46300,11,46328,46328,11,46356,46356,11,46384,46384,11,46412,46412,11,46440,46440,11,46468,46468,11,46496,46496,11,46524,46524,11,46552,46552,11,46580,46580,11,46608,46608,11,46636,46636,11,46664,46664,11,46692,46692,11,46720,46720,11,46748,46748,11,46776,46776,11,46804,46804,11,46832,46832,11,46860,46860,11,46888,46888,11,46916,46916,11,46944,46944,11,46972,46972,11,47000,47000,11,47028,47028,11,47056,47056,11,47084,47084,11,47112,47112,11,47140,47140,11,47168,47168,11,47196,47196,11,47224,47224,11,47252,47252,11,47280,47280,11,47308,47308,11,47336,47336,11,47364,47364,11,47392,47392,11,47420,47420,11,47448,47448,11,47476,47476,11,47504,47504,11,47532,47532,11,47560,47560,11,47588,47588,11,47616,47616,11,47644,47644,11,47672,47672,11,47700,47700,11,47728,47728,11,47756,47756,11,47784,47784,11,47812,47812,11,47840,47840,11,47868,47868,11,47896,47896,11,47924,47924,11,47952,47952,11,47980,47980,11,48008,48008,11,48036,48036,11,48064,48064,11,48092,48092,11,48120,48120,11,48148,48148,11,48176,48176,11,48204,48204,11,48232,48232,11,48260,48260,11,48288,48288,11,48316,48316,11,48344,48344,11,48372,48372,11,48400,48400,11,48428,48428,11,48456,48456,11,48484,48484,11,48512,48512,11,48540,48540,11,48568,48568,11,48596,48596,11,48624,48624,11,48652,48652,11,48680,48680,11,48708,48708,11,48736,48736,11,48764,48764,11,48792,48792,11,48820,48820,11,48848,48848,11,48876,48876,11,48904,48904,11,48932,48932,11,48960,48960,11,48988,48988,11,49016,49016,11,49044,49044,11,49072,49072,11,49100,49100,11,49128,49128,11,49156,49156,11,49184,49184,11,49212,49212,11,49240,49240,11,49268,49268,11,49296,49296,11,49324,49324,11,49352,49352,11,49380,49380,11,49408,49408,11,49436,49436,11,49464,49464,11,49492,49492,11,49520,49520,11,49548,49548,11,49576,49576,11,49604,49604,11,49632,49632,11,49660,49660,11,49688,49688,11,49716,49716,11,49744,49744,11,49772,49772,11,49800,49800,11,49828,49828,11,49856,49856,11,49884,49884,11,49912,49912,11,49940,49940,11,49968,49968,11,49996,49996,11,50024,50024,11,50052,50052,11,50080,50080,11,50108,50108,11,50136,50136,11,50164,50164,11,50192,50192,11,50220,50220,11,50248,50248,11,50276,50276,11,50304,50304,11,50332,50332,11,50360,50360,11,50388,50388,11,50416,50416,11,50444,50444,11,50472,50472,11,50500,50500,11,50528,50528,11,50556,50556,11,50584,50584,11,50612,50612,11,50640,50640,11,50668,50668,11,50696,50696,11,50724,50724,11,50752,50752,11,50780,50780,11,50808,50808,11,50836,50836,11,50864,50864,11,50892,50892,11,50920,50920,11,50948,50948,11,50976,50976,11,51004,51004,11,51032,51032,11,51060,51060,11,51088,51088,11,51116,51116,11,51144,51144,11,51172,51172,11,51200,51200,11,51228,51228,11,51256,51256,11,51284,51284,11,51312,51312,11,51340,51340,11,51368,51368,11,51396,51396,11,51424,51424,11,51452,51452,11,51480,51480,11,51508,51508,11,51536,51536,11,51564,51564,11,51592,51592,11,51620,51620,11,51648,51648,11,51676,51676,11,51704,51704,11,51732,51732,11,51760,51760,11,51788,51788,11,51816,51816,11,51844,51844,11,51872,51872,11,51900,51900,11,51928,51928,11,51956,51956,11,51984,51984,11,52012,52012,11,52040,52040,11,52068,52068,11,52096,52096,11,52124,52124,11,52152,52152,11,52180,52180,11,52208,52208,11,52236,52236,11,52264,52264,11,52292,52292,11,52320,52320,11,52348,52348,11,52376,52376,11,52404,52404,11,52432,52432,11,52460,52460,11,52488,52488,11,52516,52516,11,52544,52544,11,52572,52572,11,52600,52600,11,52628,52628,11,52656,52656,11,52684,52684,11,52712,52712,11,52740,52740,11,52768,52768,11,52796,52796,11,52824,52824,11,52852,52852,11,52880,52880,11,52908,52908,11,52936,52936,11,52964,52964,11,52992,52992,11,53020,53020,11,53048,53048,11,53076,53076,11,53104,53104,11,53132,53132,11,53160,53160,11,53188,53188,11,53216,53216,11,53244,53244,11,53272,53272,11,53300,53300,11,53328,53328,11,53356,53356,11,53384,53384,11,53412,53412,11,53440,53440,11,53468,53468,11,53496,53496,11,53524,53524,11,53552,53552,11,53580,53580,11,53608,53608,11,53636,53636,11,53664,53664,11,53692,53692,11,53720,53720,11,53748,53748,11,53776,53776,11,53804,53804,11,53832,53832,11,53860,53860,11,53888,53888,11,53916,53916,11,53944,53944,11,53972,53972,11,54000,54000,11,54028,54028,11,54056,54056,11,54084,54084,11,54112,54112,11,54140,54140,11,54168,54168,11,54196,54196,11,54224,54224,11,54252,54252,11,54280,54280,11,54308,54308,11,54336,54336,11,54364,54364,11,54392,54392,11,54420,54420,11,54448,54448,11,54476,54476,11,54504,54504,11,54532,54532,11,54560,54560,11,54588,54588,11,54616,54616,11,54644,54644,11,54672,54672,11,54700,54700,11,54728,54728,11,54756,54756,11,54784,54784,11,54812,54812,11,54840,54840,11,54868,54868,11,54896,54896,11,54924,54924,11,54952,54952,11,54980,54980,11,55008,55008,11,55036,55036,11,55064,55064,11,55092,55092,11,55120,55120,11,55148,55148,11,55176,55176,11,55216,55238,9,64286,64286,5,65056,65071,5,65438,65439,5,65529,65531,4,66272,66272,5,68097,68099,5,68108,68111,5,68159,68159,5,68900,68903,5,69446,69456,5,69632,69632,7,69634,69634,7,69744,69744,5,69759,69761,5,69808,69810,7,69815,69816,7,69821,69821,1,69837,69837,1,69927,69931,5,69933,69940,5,70003,70003,5,70018,70018,7,70070,70078,5,70082,70083,1,70094,70094,7,70188,70190,7,70194,70195,7,70197,70197,7,70206,70206,5,70368,70370,7,70400,70401,5,70459,70460,5,70463,70463,7,70465,70468,7,70475,70477,7,70498,70499,7,70512,70516,5,70712,70719,5,70722,70724,5,70726,70726,5,70832,70832,5,70835,70840,5,70842,70842,5,70845,70845,5,70847,70848,5,70850,70851,5,71088,71089,7,71096,71099,7,71102,71102,7,71132,71133,5,71219,71226,5,71229,71229,5,71231,71232,5,71340,71340,7,71342,71343,7,71350,71350,7,71453,71455,5,71462,71462,7,71724,71726,7,71736,71736,7,71984,71984,5,71991,71992,7,71997,71997,7,71999,71999,1,72001,72001,1,72003,72003,5,72148,72151,5,72156,72159,7,72164,72164,7,72243,72248,5,72250,72250,1,72263,72263,5,72279,72280,7,72324,72329,1,72343,72343,7,72751,72751,7,72760,72765,5,72767,72767,5,72873,72873,7,72881,72881,7,72884,72884,7,73009,73014,5,73020,73021,5,73030,73030,1,73098,73102,7,73107,73108,7,73110,73110,7,73459,73460,5,78896,78904,4,92976,92982,5,94033,94087,7,94180,94180,5,113821,113822,5,118528,118573,5,119141,119141,5,119143,119145,5,119150,119154,5,119163,119170,5,119210,119213,5,121344,121398,5,121461,121461,5,121499,121503,5,122880,122886,5,122907,122913,5,122918,122922,5,123566,123566,5,125136,125142,5,126976,126979,14,126981,127182,14,127184,127231,14,127279,127279,14,127344,127345,14,127374,127374,14,127405,127461,14,127489,127490,14,127514,127514,14,127538,127546,14,127561,127567,14,127570,127743,14,127757,127758,14,127760,127760,14,127762,127762,14,127766,127768,14,127770,127770,14,127772,127772,14,127775,127776,14,127778,127779,14,127789,127791,14,127794,127795,14,127798,127798,14,127819,127819,14,127824,127824,14,127868,127868,14,127870,127871,14,127892,127893,14,127896,127896,14,127900,127901,14,127904,127940,14,127942,127942,14,127944,127944,14,127946,127946,14,127951,127955,14,127968,127971,14,127973,127984,14,127987,127987,14,127989,127989,14,127991,127991,14,127995,127999,5,128008,128008,14,128012,128014,14,128017,128018,14,128020,128020,14,128022,128022,14,128042,128042,14,128063,128063,14,128065,128065,14,128101,128101,14,128108,128109,14,128173,128173,14,128182,128183,14,128236,128237,14,128239,128239,14,128245,128245,14,128248,128248,14,128253,128253,14,128255,128258,14,128260,128263,14,128265,128265,14,128277,128277,14,128300,128301,14,128326,128328,14,128331,128334,14,128336,128347,14,128360,128366,14,128369,128370,14,128378,128378,14,128391,128391,14,128394,128397,14,128400,128400,14,128405,128406,14,128420,128420,14,128422,128423,14,128425,128432,14,128435,128443,14,128445,128449,14,128453,128464,14,128468,128475,14,128479,128480,14,128482,128482,14,128484,128487,14,128489,128494,14,128496,128498,14,128500,128505,14,128507,128511,14,128513,128518,14,128521,128525,14,128527,128527,14,128529,128529,14,128533,128533,14,128535,128535,14,128537,128537,14]');\n}\n//#endregion\n/**\n * Computes the offset after performing a left delete on the given string,\n * while considering unicode grapheme/emoji rules.\n*/\nexport function getLeftDeleteOffset(offset, str) {\n if (offset === 0) {\n return 0;\n }\n // Try to delete emoji part.\n const emojiOffset = getOffsetBeforeLastEmojiComponent(offset, str);\n if (emojiOffset !== undefined) {\n return emojiOffset;\n }\n // Otherwise, just skip a single code point.\n const iterator = new CodePointIterator(str, offset);\n iterator.prevCodePoint();\n return iterator.offset;\n}\nfunction getOffsetBeforeLastEmojiComponent(initialOffset, str) {\n // See https://www.unicode.org/reports/tr51/tr51-14.html#EBNF_and_Regex for the\n // structure of emojis.\n const iterator = new CodePointIterator(str, initialOffset);\n let codePoint = iterator.prevCodePoint();\n // Skip modifiers\n while ((isEmojiModifier(codePoint) || codePoint === 65039 /* CodePoint.emojiVariantSelector */ || codePoint === 8419 /* CodePoint.enclosingKeyCap */)) {\n if (iterator.offset === 0) {\n // Cannot skip modifier, no preceding emoji base.\n return undefined;\n }\n codePoint = iterator.prevCodePoint();\n }\n // Expect base emoji\n if (!isEmojiImprecise(codePoint)) {\n // Unexpected code point, not a valid emoji.\n return undefined;\n }\n let resultOffset = iterator.offset;\n if (resultOffset > 0) {\n // Skip optional ZWJ code points that combine multiple emojis.\n // In theory, we should check if that ZWJ actually combines multiple emojis\n // to prevent deleting ZWJs in situations we didn't account for.\n const optionalZwjCodePoint = iterator.prevCodePoint();\n if (optionalZwjCodePoint === 8205 /* CodePoint.zwj */) {\n resultOffset = iterator.offset;\n }\n }\n return resultOffset;\n}\nfunction isEmojiModifier(codePoint) {\n return 0x1F3FB <= codePoint && codePoint <= 0x1F3FF;\n}\nexport const noBreakWhitespace = '\\xa0';\nexport class AmbiguousCharacters {\n static getInstance(locales) {\n return _a.cache.get(Array.from(locales));\n }\n static getLocales() {\n return _a._locales.value;\n }\n constructor(confusableDictionary) {\n this.confusableDictionary = confusableDictionary;\n }\n isAmbiguous(codePoint) {\n return this.confusableDictionary.has(codePoint);\n }\n /**\n * Returns the non basic ASCII code point that the given code point can be confused,\n * or undefined if such code point does note exist.\n */\n getPrimaryConfusable(codePoint) {\n return this.confusableDictionary.get(codePoint);\n }\n getConfusableCodePoints() {\n return new Set(this.confusableDictionary.keys());\n }\n}\n_a = AmbiguousCharacters;\nAmbiguousCharacters.ambiguousCharacterData = new Lazy(() => {\n // Generated using https://github.com/hediet/vscode-unicode-data\n // Stored as key1, value1, key2, value2, ...\n return JSON.parse('{\\\"_common\\\":[8232,32,8233,32,5760,32,8192,32,8193,32,8194,32,8195,32,8196,32,8197,32,8198,32,8200,32,8201,32,8202,32,8287,32,8199,32,8239,32,2042,95,65101,95,65102,95,65103,95,8208,45,8209,45,8210,45,65112,45,1748,45,8259,45,727,45,8722,45,10134,45,11450,45,1549,44,1643,44,8218,44,184,44,42233,44,894,59,2307,58,2691,58,1417,58,1795,58,1796,58,5868,58,65072,58,6147,58,6153,58,8282,58,1475,58,760,58,42889,58,8758,58,720,58,42237,58,451,33,11601,33,660,63,577,63,2429,63,5038,63,42731,63,119149,46,8228,46,1793,46,1794,46,42510,46,68176,46,1632,46,1776,46,42232,46,1373,96,65287,96,8219,96,8242,96,1370,96,1523,96,8175,96,65344,96,900,96,8189,96,8125,96,8127,96,8190,96,697,96,884,96,712,96,714,96,715,96,756,96,699,96,701,96,700,96,702,96,42892,96,1497,96,2036,96,2037,96,5194,96,5836,96,94033,96,94034,96,65339,91,10088,40,10098,40,12308,40,64830,40,65341,93,10089,41,10099,41,12309,41,64831,41,10100,123,119060,123,10101,125,65342,94,8270,42,1645,42,8727,42,66335,42,5941,47,8257,47,8725,47,8260,47,9585,47,10187,47,10744,47,119354,47,12755,47,12339,47,11462,47,20031,47,12035,47,65340,92,65128,92,8726,92,10189,92,10741,92,10745,92,119311,92,119355,92,12756,92,20022,92,12034,92,42872,38,708,94,710,94,5869,43,10133,43,66203,43,8249,60,10094,60,706,60,119350,60,5176,60,5810,60,5120,61,11840,61,12448,61,42239,61,8250,62,10095,62,707,62,119351,62,5171,62,94015,62,8275,126,732,126,8128,126,8764,126,65372,124,65293,45,120784,50,120794,50,120804,50,120814,50,120824,50,130034,50,42842,50,423,50,1000,50,42564,50,5311,50,42735,50,119302,51,120785,51,120795,51,120805,51,120815,51,120825,51,130035,51,42923,51,540,51,439,51,42858,51,11468,51,1248,51,94011,51,71882,51,120786,52,120796,52,120806,52,120816,52,120826,52,130036,52,5070,52,71855,52,120787,53,120797,53,120807,53,120817,53,120827,53,130037,53,444,53,71867,53,120788,54,120798,54,120808,54,120818,54,120828,54,130038,54,11474,54,5102,54,71893,54,119314,55,120789,55,120799,55,120809,55,120819,55,120829,55,130039,55,66770,55,71878,55,2819,56,2538,56,2666,56,125131,56,120790,56,120800,56,120810,56,120820,56,120830,56,130040,56,547,56,546,56,66330,56,2663,57,2920,57,2541,57,3437,57,120791,57,120801,57,120811,57,120821,57,120831,57,130041,57,42862,57,11466,57,71884,57,71852,57,71894,57,9082,97,65345,97,119834,97,119886,97,119938,97,119990,97,120042,97,120094,97,120146,97,120198,97,120250,97,120302,97,120354,97,120406,97,120458,97,593,97,945,97,120514,97,120572,97,120630,97,120688,97,120746,97,65313,65,119808,65,119860,65,119912,65,119964,65,120016,65,120068,65,120120,65,120172,65,120224,65,120276,65,120328,65,120380,65,120432,65,913,65,120488,65,120546,65,120604,65,120662,65,120720,65,5034,65,5573,65,42222,65,94016,65,66208,65,119835,98,119887,98,119939,98,119991,98,120043,98,120095,98,120147,98,120199,98,120251,98,120303,98,120355,98,120407,98,120459,98,388,98,5071,98,5234,98,5551,98,65314,66,8492,66,119809,66,119861,66,119913,66,120017,66,120069,66,120121,66,120173,66,120225,66,120277,66,120329,66,120381,66,120433,66,42932,66,914,66,120489,66,120547,66,120605,66,120663,66,120721,66,5108,66,5623,66,42192,66,66178,66,66209,66,66305,66,65347,99,8573,99,119836,99,119888,99,119940,99,119992,99,120044,99,120096,99,120148,99,120200,99,120252,99,120304,99,120356,99,120408,99,120460,99,7428,99,1010,99,11429,99,43951,99,66621,99,128844,67,71922,67,71913,67,65315,67,8557,67,8450,67,8493,67,119810,67,119862,67,119914,67,119966,67,120018,67,120174,67,120226,67,120278,67,120330,67,120382,67,120434,67,1017,67,11428,67,5087,67,42202,67,66210,67,66306,67,66581,67,66844,67,8574,100,8518,100,119837,100,119889,100,119941,100,119993,100,120045,100,120097,100,120149,100,120201,100,120253,100,120305,100,120357,100,120409,100,120461,100,1281,100,5095,100,5231,100,42194,100,8558,68,8517,68,119811,68,119863,68,119915,68,119967,68,120019,68,120071,68,120123,68,120175,68,120227,68,120279,68,120331,68,120383,68,120435,68,5024,68,5598,68,5610,68,42195,68,8494,101,65349,101,8495,101,8519,101,119838,101,119890,101,119942,101,120046,101,120098,101,120150,101,120202,101,120254,101,120306,101,120358,101,120410,101,120462,101,43826,101,1213,101,8959,69,65317,69,8496,69,119812,69,119864,69,119916,69,120020,69,120072,69,120124,69,120176,69,120228,69,120280,69,120332,69,120384,69,120436,69,917,69,120492,69,120550,69,120608,69,120666,69,120724,69,11577,69,5036,69,42224,69,71846,69,71854,69,66182,69,119839,102,119891,102,119943,102,119995,102,120047,102,120099,102,120151,102,120203,102,120255,102,120307,102,120359,102,120411,102,120463,102,43829,102,42905,102,383,102,7837,102,1412,102,119315,70,8497,70,119813,70,119865,70,119917,70,120021,70,120073,70,120125,70,120177,70,120229,70,120281,70,120333,70,120385,70,120437,70,42904,70,988,70,120778,70,5556,70,42205,70,71874,70,71842,70,66183,70,66213,70,66853,70,65351,103,8458,103,119840,103,119892,103,119944,103,120048,103,120100,103,120152,103,120204,103,120256,103,120308,103,120360,103,120412,103,120464,103,609,103,7555,103,397,103,1409,103,119814,71,119866,71,119918,71,119970,71,120022,71,120074,71,120126,71,120178,71,120230,71,120282,71,120334,71,120386,71,120438,71,1292,71,5056,71,5107,71,42198,71,65352,104,8462,104,119841,104,119945,104,119997,104,120049,104,120101,104,120153,104,120205,104,120257,104,120309,104,120361,104,120413,104,120465,104,1211,104,1392,104,5058,104,65320,72,8459,72,8460,72,8461,72,119815,72,119867,72,119919,72,120023,72,120179,72,120231,72,120283,72,120335,72,120387,72,120439,72,919,72,120494,72,120552,72,120610,72,120668,72,120726,72,11406,72,5051,72,5500,72,42215,72,66255,72,731,105,9075,105,65353,105,8560,105,8505,105,8520,105,119842,105,119894,105,119946,105,119998,105,120050,105,120102,105,120154,105,120206,105,120258,105,120310,105,120362,105,120414,105,120466,105,120484,105,618,105,617,105,953,105,8126,105,890,105,120522,105,120580,105,120638,105,120696,105,120754,105,1110,105,42567,105,1231,105,43893,105,5029,105,71875,105,65354,106,8521,106,119843,106,119895,106,119947,106,119999,106,120051,106,120103,106,120155,106,120207,106,120259,106,120311,106,120363,106,120415,106,120467,106,1011,106,1112,106,65322,74,119817,74,119869,74,119921,74,119973,74,120025,74,120077,74,120129,74,120181,74,120233,74,120285,74,120337,74,120389,74,120441,74,42930,74,895,74,1032,74,5035,74,5261,74,42201,74,119844,107,119896,107,119948,107,120000,107,120052,107,120104,107,120156,107,120208,107,120260,107,120312,107,120364,107,120416,107,120468,107,8490,75,65323,75,119818,75,119870,75,119922,75,119974,75,120026,75,120078,75,120130,75,120182,75,120234,75,120286,75,120338,75,120390,75,120442,75,922,75,120497,75,120555,75,120613,75,120671,75,120729,75,11412,75,5094,75,5845,75,42199,75,66840,75,1472,108,8739,73,9213,73,65512,73,1633,108,1777,73,66336,108,125127,108,120783,73,120793,73,120803,73,120813,73,120823,73,130033,73,65321,73,8544,73,8464,73,8465,73,119816,73,119868,73,119920,73,120024,73,120128,73,120180,73,120232,73,120284,73,120336,73,120388,73,120440,73,65356,108,8572,73,8467,108,119845,108,119897,108,119949,108,120001,108,120053,108,120105,73,120157,73,120209,73,120261,73,120313,73,120365,73,120417,73,120469,73,448,73,120496,73,120554,73,120612,73,120670,73,120728,73,11410,73,1030,73,1216,73,1493,108,1503,108,1575,108,126464,108,126592,108,65166,108,65165,108,1994,108,11599,73,5825,73,42226,73,93992,73,66186,124,66313,124,119338,76,8556,76,8466,76,119819,76,119871,76,119923,76,120027,76,120079,76,120131,76,120183,76,120235,76,120287,76,120339,76,120391,76,120443,76,11472,76,5086,76,5290,76,42209,76,93974,76,71843,76,71858,76,66587,76,66854,76,65325,77,8559,77,8499,77,119820,77,119872,77,119924,77,120028,77,120080,77,120132,77,120184,77,120236,77,120288,77,120340,77,120392,77,120444,77,924,77,120499,77,120557,77,120615,77,120673,77,120731,77,1018,77,11416,77,5047,77,5616,77,5846,77,42207,77,66224,77,66321,77,119847,110,119899,110,119951,110,120003,110,120055,110,120107,110,120159,110,120211,110,120263,110,120315,110,120367,110,120419,110,120471,110,1400,110,1404,110,65326,78,8469,78,119821,78,119873,78,119925,78,119977,78,120029,78,120081,78,120185,78,120237,78,120289,78,120341,78,120393,78,120445,78,925,78,120500,78,120558,78,120616,78,120674,78,120732,78,11418,78,42208,78,66835,78,3074,111,3202,111,3330,111,3458,111,2406,111,2662,111,2790,111,3046,111,3174,111,3302,111,3430,111,3664,111,3792,111,4160,111,1637,111,1781,111,65359,111,8500,111,119848,111,119900,111,119952,111,120056,111,120108,111,120160,111,120212,111,120264,111,120316,111,120368,111,120420,111,120472,111,7439,111,7441,111,43837,111,959,111,120528,111,120586,111,120644,111,120702,111,120760,111,963,111,120532,111,120590,111,120648,111,120706,111,120764,111,11423,111,4351,111,1413,111,1505,111,1607,111,126500,111,126564,111,126596,111,65259,111,65260,111,65258,111,65257,111,1726,111,64428,111,64429,111,64427,111,64426,111,1729,111,64424,111,64425,111,64423,111,64422,111,1749,111,3360,111,4125,111,66794,111,71880,111,71895,111,66604,111,1984,79,2534,79,2918,79,12295,79,70864,79,71904,79,120782,79,120792,79,120802,79,120812,79,120822,79,130032,79,65327,79,119822,79,119874,79,119926,79,119978,79,120030,79,120082,79,120134,79,120186,79,120238,79,120290,79,120342,79,120394,79,120446,79,927,79,120502,79,120560,79,120618,79,120676,79,120734,79,11422,79,1365,79,11604,79,4816,79,2848,79,66754,79,42227,79,71861,79,66194,79,66219,79,66564,79,66838,79,9076,112,65360,112,119849,112,119901,112,119953,112,120005,112,120057,112,120109,112,120161,112,120213,112,120265,112,120317,112,120369,112,120421,112,120473,112,961,112,120530,112,120544,112,120588,112,120602,112,120646,112,120660,112,120704,112,120718,112,120762,112,120776,112,11427,112,65328,80,8473,80,119823,80,119875,80,119927,80,119979,80,120031,80,120083,80,120187,80,120239,80,120291,80,120343,80,120395,80,120447,80,929,80,120504,80,120562,80,120620,80,120678,80,120736,80,11426,80,5090,80,5229,80,42193,80,66197,80,119850,113,119902,113,119954,113,120006,113,120058,113,120110,113,120162,113,120214,113,120266,113,120318,113,120370,113,120422,113,120474,113,1307,113,1379,113,1382,113,8474,81,119824,81,119876,81,119928,81,119980,81,120032,81,120084,81,120188,81,120240,81,120292,81,120344,81,120396,81,120448,81,11605,81,119851,114,119903,114,119955,114,120007,114,120059,114,120111,114,120163,114,120215,114,120267,114,120319,114,120371,114,120423,114,120475,114,43847,114,43848,114,7462,114,11397,114,43905,114,119318,82,8475,82,8476,82,8477,82,119825,82,119877,82,119929,82,120033,82,120189,82,120241,82,120293,82,120345,82,120397,82,120449,82,422,82,5025,82,5074,82,66740,82,5511,82,42211,82,94005,82,65363,115,119852,115,119904,115,119956,115,120008,115,120060,115,120112,115,120164,115,120216,115,120268,115,120320,115,120372,115,120424,115,120476,115,42801,115,445,115,1109,115,43946,115,71873,115,66632,115,65331,83,119826,83,119878,83,119930,83,119982,83,120034,83,120086,83,120138,83,120190,83,120242,83,120294,83,120346,83,120398,83,120450,83,1029,83,1359,83,5077,83,5082,83,42210,83,94010,83,66198,83,66592,83,119853,116,119905,116,119957,116,120009,116,120061,116,120113,116,120165,116,120217,116,120269,116,120321,116,120373,116,120425,116,120477,116,8868,84,10201,84,128872,84,65332,84,119827,84,119879,84,119931,84,119983,84,120035,84,120087,84,120139,84,120191,84,120243,84,120295,84,120347,84,120399,84,120451,84,932,84,120507,84,120565,84,120623,84,120681,84,120739,84,11430,84,5026,84,42196,84,93962,84,71868,84,66199,84,66225,84,66325,84,119854,117,119906,117,119958,117,120010,117,120062,117,120114,117,120166,117,120218,117,120270,117,120322,117,120374,117,120426,117,120478,117,42911,117,7452,117,43854,117,43858,117,651,117,965,117,120534,117,120592,117,120650,117,120708,117,120766,117,1405,117,66806,117,71896,117,8746,85,8899,85,119828,85,119880,85,119932,85,119984,85,120036,85,120088,85,120140,85,120192,85,120244,85,120296,85,120348,85,120400,85,120452,85,1357,85,4608,85,66766,85,5196,85,42228,85,94018,85,71864,85,8744,118,8897,118,65366,118,8564,118,119855,118,119907,118,119959,118,120011,118,120063,118,120115,118,120167,118,120219,118,120271,118,120323,118,120375,118,120427,118,120479,118,7456,118,957,118,120526,118,120584,118,120642,118,120700,118,120758,118,1141,118,1496,118,71430,118,43945,118,71872,118,119309,86,1639,86,1783,86,8548,86,119829,86,119881,86,119933,86,119985,86,120037,86,120089,86,120141,86,120193,86,120245,86,120297,86,120349,86,120401,86,120453,86,1140,86,11576,86,5081,86,5167,86,42719,86,42214,86,93960,86,71840,86,66845,86,623,119,119856,119,119908,119,119960,119,120012,119,120064,119,120116,119,120168,119,120220,119,120272,119,120324,119,120376,119,120428,119,120480,119,7457,119,1121,119,1309,119,1377,119,71434,119,71438,119,71439,119,43907,119,71919,87,71910,87,119830,87,119882,87,119934,87,119986,87,120038,87,120090,87,120142,87,120194,87,120246,87,120298,87,120350,87,120402,87,120454,87,1308,87,5043,87,5076,87,42218,87,5742,120,10539,120,10540,120,10799,120,65368,120,8569,120,119857,120,119909,120,119961,120,120013,120,120065,120,120117,120,120169,120,120221,120,120273,120,120325,120,120377,120,120429,120,120481,120,5441,120,5501,120,5741,88,9587,88,66338,88,71916,88,65336,88,8553,88,119831,88,119883,88,119935,88,119987,88,120039,88,120091,88,120143,88,120195,88,120247,88,120299,88,120351,88,120403,88,120455,88,42931,88,935,88,120510,88,120568,88,120626,88,120684,88,120742,88,11436,88,11613,88,5815,88,42219,88,66192,88,66228,88,66327,88,66855,88,611,121,7564,121,65369,121,119858,121,119910,121,119962,121,120014,121,120066,121,120118,121,120170,121,120222,121,120274,121,120326,121,120378,121,120430,121,120482,121,655,121,7935,121,43866,121,947,121,8509,121,120516,121,120574,121,120632,121,120690,121,120748,121,1199,121,4327,121,71900,121,65337,89,119832,89,119884,89,119936,89,119988,89,120040,89,120092,89,120144,89,120196,89,120248,89,120300,89,120352,89,120404,89,120456,89,933,89,978,89,120508,89,120566,89,120624,89,120682,89,120740,89,11432,89,1198,89,5033,89,5053,89,42220,89,94019,89,71844,89,66226,89,119859,122,119911,122,119963,122,120015,122,120067,122,120119,122,120171,122,120223,122,120275,122,120327,122,120379,122,120431,122,120483,122,7458,122,43923,122,71876,122,66293,90,71909,90,65338,90,8484,90,8488,90,119833,90,119885,90,119937,90,119989,90,120041,90,120197,90,120249,90,120301,90,120353,90,120405,90,120457,90,918,90,120493,90,120551,90,120609,90,120667,90,120725,90,5059,90,42204,90,71849,90,65282,34,65284,36,65285,37,65286,38,65290,42,65291,43,65294,46,65295,47,65296,48,65297,49,65298,50,65299,51,65300,52,65301,53,65302,54,65303,55,65304,56,65305,57,65308,60,65309,61,65310,62,65312,64,65316,68,65318,70,65319,71,65324,76,65329,81,65330,82,65333,85,65334,86,65335,87,65343,95,65346,98,65348,100,65350,102,65355,107,65357,109,65358,110,65361,113,65362,114,65364,116,65365,117,65367,119,65370,122,65371,123,65373,125,119846,109],\\\"_default\\\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"cs\\\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"de\\\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"es\\\":[8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"fr\\\":[65374,126,65306,58,65281,33,8216,96,8245,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"it\\\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"ja\\\":[8211,45,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65292,44,65307,59],\\\"ko\\\":[8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"pl\\\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"pt-BR\\\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"qps-ploc\\\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"ru\\\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,305,105,921,73,1009,112,215,120,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"tr\\\":[160,32,8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\\\"zh-hans\\\":[65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41],\\\"zh-hant\\\":[8211,45,65374,126,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65307,59]}');\n});\nAmbiguousCharacters.cache = new LRUCachedFunction((locales) => {\n function arrayToMap(arr) {\n const result = new Map();\n for (let i = 0; i < arr.length; i += 2) {\n result.set(arr[i], arr[i + 1]);\n }\n return result;\n }\n function mergeMaps(map1, map2) {\n const result = new Map(map1);\n for (const [key, value] of map2) {\n result.set(key, value);\n }\n return result;\n }\n function intersectMaps(map1, map2) {\n if (!map1) {\n return map2;\n }\n const result = new Map();\n for (const [key, value] of map1) {\n if (map2.has(key)) {\n result.set(key, value);\n }\n }\n return result;\n }\n const data = _a.ambiguousCharacterData.value;\n let filteredLocales = locales.filter((l) => !l.startsWith('_') && l in data);\n if (filteredLocales.length === 0) {\n filteredLocales = ['_default'];\n }\n let languageSpecificMap = undefined;\n for (const locale of filteredLocales) {\n const map = arrayToMap(data[locale]);\n languageSpecificMap = intersectMaps(languageSpecificMap, map);\n }\n const commonMap = arrayToMap(data['_common']);\n const map = mergeMaps(commonMap, languageSpecificMap);\n return new _a(map);\n});\nAmbiguousCharacters._locales = new Lazy(() => Object.keys(_a.ambiguousCharacterData.value).filter((k) => !k.startsWith('_')));\nexport class InvisibleCharacters {\n static getRawData() {\n // Generated using https://github.com/hediet/vscode-unicode-data\n return JSON.parse('[9,10,11,12,13,32,127,160,173,847,1564,4447,4448,6068,6069,6155,6156,6157,6158,7355,7356,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8203,8204,8205,8206,8207,8234,8235,8236,8237,8238,8239,8287,8288,8289,8290,8291,8292,8293,8294,8295,8296,8297,8298,8299,8300,8301,8302,8303,10240,12288,12644,65024,65025,65026,65027,65028,65029,65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65279,65440,65520,65521,65522,65523,65524,65525,65526,65527,65528,65532,78844,119155,119156,119157,119158,119159,119160,119161,119162,917504,917505,917506,917507,917508,917509,917510,917511,917512,917513,917514,917515,917516,917517,917518,917519,917520,917521,917522,917523,917524,917525,917526,917527,917528,917529,917530,917531,917532,917533,917534,917535,917536,917537,917538,917539,917540,917541,917542,917543,917544,917545,917546,917547,917548,917549,917550,917551,917552,917553,917554,917555,917556,917557,917558,917559,917560,917561,917562,917563,917564,917565,917566,917567,917568,917569,917570,917571,917572,917573,917574,917575,917576,917577,917578,917579,917580,917581,917582,917583,917584,917585,917586,917587,917588,917589,917590,917591,917592,917593,917594,917595,917596,917597,917598,917599,917600,917601,917602,917603,917604,917605,917606,917607,917608,917609,917610,917611,917612,917613,917614,917615,917616,917617,917618,917619,917620,917621,917622,917623,917624,917625,917626,917627,917628,917629,917630,917631,917760,917761,917762,917763,917764,917765,917766,917767,917768,917769,917770,917771,917772,917773,917774,917775,917776,917777,917778,917779,917780,917781,917782,917783,917784,917785,917786,917787,917788,917789,917790,917791,917792,917793,917794,917795,917796,917797,917798,917799,917800,917801,917802,917803,917804,917805,917806,917807,917808,917809,917810,917811,917812,917813,917814,917815,917816,917817,917818,917819,917820,917821,917822,917823,917824,917825,917826,917827,917828,917829,917830,917831,917832,917833,917834,917835,917836,917837,917838,917839,917840,917841,917842,917843,917844,917845,917846,917847,917848,917849,917850,917851,917852,917853,917854,917855,917856,917857,917858,917859,917860,917861,917862,917863,917864,917865,917866,917867,917868,917869,917870,917871,917872,917873,917874,917875,917876,917877,917878,917879,917880,917881,917882,917883,917884,917885,917886,917887,917888,917889,917890,917891,917892,917893,917894,917895,917896,917897,917898,917899,917900,917901,917902,917903,917904,917905,917906,917907,917908,917909,917910,917911,917912,917913,917914,917915,917916,917917,917918,917919,917920,917921,917922,917923,917924,917925,917926,917927,917928,917929,917930,917931,917932,917933,917934,917935,917936,917937,917938,917939,917940,917941,917942,917943,917944,917945,917946,917947,917948,917949,917950,917951,917952,917953,917954,917955,917956,917957,917958,917959,917960,917961,917962,917963,917964,917965,917966,917967,917968,917969,917970,917971,917972,917973,917974,917975,917976,917977,917978,917979,917980,917981,917982,917983,917984,917985,917986,917987,917988,917989,917990,917991,917992,917993,917994,917995,917996,917997,917998,917999]');\n }\n static getData() {\n if (!this._data) {\n this._data = new Set(InvisibleCharacters.getRawData());\n }\n return this._data;\n }\n static isInvisibleCharacter(codePoint) {\n return InvisibleCharacters.getData().has(codePoint);\n }\n static get codePoints() {\n return InvisibleCharacters.getData();\n }\n}\nInvisibleCharacters._data = undefined;\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * @returns whether the provided parameter is a JavaScript String or not.\n */\nexport function isString(str) {\n return (typeof str === 'string');\n}\n/**\n * @returns whether the provided parameter is of type `object` but **not**\n *\t`null`, an `array`, a `regexp`, nor a `date`.\n */\nexport function isObject(obj) {\n // The method can't do a type cast since there are type (like strings) which\n // are subclasses of any put not positvely matched by the function. Hence type\n // narrowing results in wrong results.\n return typeof obj === 'object'\n && obj !== null\n && !Array.isArray(obj)\n && !(obj instanceof RegExp)\n && !(obj instanceof Date);\n}\n/**\n * @returns whether the provided parameter is of type `Buffer` or Uint8Array dervived type\n */\nexport function isTypedArray(obj) {\n const TypedArray = Object.getPrototypeOf(Uint8Array);\n return typeof obj === 'object'\n && obj instanceof TypedArray;\n}\n/**\n * In **contrast** to just checking `typeof` this will return `false` for `NaN`.\n * @returns whether the provided parameter is a JavaScript Number or not.\n */\nexport function isNumber(obj) {\n return (typeof obj === 'number' && !isNaN(obj));\n}\n/**\n * @returns whether the provided parameter is an Iterable, casting to the given generic\n */\nexport function isIterable(obj) {\n return !!obj && typeof obj[Symbol.iterator] === 'function';\n}\n/**\n * @returns whether the provided parameter is a JavaScript Boolean or not.\n */\nexport function isBoolean(obj) {\n return (obj === true || obj === false);\n}\n/**\n * @returns whether the provided parameter is undefined.\n */\nexport function isUndefined(obj) {\n return (typeof obj === 'undefined');\n}\n/**\n * @returns whether the provided parameter is defined.\n */\nexport function isDefined(arg) {\n return !isUndefinedOrNull(arg);\n}\n/**\n * @returns whether the provided parameter is undefined or null.\n */\nexport function isUndefinedOrNull(obj) {\n return (isUndefined(obj) || obj === null);\n}\nexport function assertType(condition, type) {\n if (!condition) {\n throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');\n }\n}\n/**\n * Asserts that the argument passed in is neither undefined nor null.\n */\nexport function assertIsDefined(arg) {\n if (isUndefinedOrNull(arg)) {\n throw new Error('Assertion Failed: argument is undefined or null');\n }\n return arg;\n}\n/**\n * @returns whether the provided parameter is a JavaScript Function or not.\n */\nexport function isFunction(obj) {\n return (typeof obj === 'function');\n}\nexport function validateConstraints(args, constraints) {\n const len = Math.min(args.length, constraints.length);\n for (let i = 0; i < len; i++) {\n validateConstraint(args[i], constraints[i]);\n }\n}\nexport function validateConstraint(arg, constraint) {\n if (isString(constraint)) {\n if (typeof arg !== constraint) {\n throw new Error(`argument does not match constraint: typeof ${constraint}`);\n }\n }\n else if (isFunction(constraint)) {\n try {\n if (arg instanceof constraint) {\n return;\n }\n }\n catch (_a) {\n // ignore\n }\n if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {\n return;\n }\n if (constraint.length === 1 && constraint.call(undefined, arg) === true) {\n return;\n }\n throw new Error(`argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true`);\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function toUint8(v) {\n if (v < 0) {\n return 0;\n }\n if (v > 255 /* Constants.MAX_UINT_8 */) {\n return 255 /* Constants.MAX_UINT_8 */;\n }\n return v | 0;\n}\nexport function toUint32(v) {\n if (v < 0) {\n return 0;\n }\n if (v > 4294967295 /* Constants.MAX_UINT_32 */) {\n return 4294967295 /* Constants.MAX_UINT_32 */;\n }\n return v | 0;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as paths from './path.js';\nimport { isWindows } from './platform.js';\nconst _schemePattern = /^\\w[\\w\\d+.-]*$/;\nconst _singleSlashStart = /^\\//;\nconst _doubleSlashStart = /^\\/\\//;\nfunction _validateUri(ret, _strict) {\n // scheme, must be set\n if (!ret.scheme && _strict) {\n throw new Error(`[UriError]: Scheme is missing: {scheme: \"\", authority: \"${ret.authority}\", path: \"${ret.path}\", query: \"${ret.query}\", fragment: \"${ret.fragment}\"}`);\n }\n // scheme, https://tools.ietf.org/html/rfc3986#section-3.1\n // ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n if (ret.scheme && !_schemePattern.test(ret.scheme)) {\n throw new Error('[UriError]: Scheme contains illegal characters.');\n }\n // path, http://tools.ietf.org/html/rfc3986#section-3.3\n // If a URI contains an authority component, then the path component\n // must either be empty or begin with a slash (\"/\") character. If a URI\n // does not contain an authority component, then the path cannot begin\n // with two slash characters (\"//\").\n if (ret.path) {\n if (ret.authority) {\n if (!_singleSlashStart.test(ret.path)) {\n throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash (\"/\") character');\n }\n }\n else {\n if (_doubleSlashStart.test(ret.path)) {\n throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\n }\n }\n }\n}\n// for a while we allowed uris *without* schemes and this is the migration\n// for them, e.g. an uri without scheme and without strict-mode warns and falls\n// back to the file-scheme. that should cause the least carnage and still be a\n// clear warning\nfunction _schemeFix(scheme, _strict) {\n if (!scheme && !_strict) {\n return 'file';\n }\n return scheme;\n}\n// implements a bit of https://tools.ietf.org/html/rfc3986#section-5\nfunction _referenceResolution(scheme, path) {\n // the slash-character is our 'default base' as we don't\n // support constructing URIs relative to other URIs. This\n // also means that we alter and potentially break paths.\n // see https://tools.ietf.org/html/rfc3986#section-5.1.4\n switch (scheme) {\n case 'https':\n case 'http':\n case 'file':\n if (!path) {\n path = _slash;\n }\n else if (path[0] !== _slash) {\n path = _slash + path;\n }\n break;\n }\n return path;\n}\nconst _empty = '';\nconst _slash = '/';\nconst _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\n/**\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\n * This class is a simple parser which creates the basic component parts\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\n * and encoding.\n *\n * ```txt\n * foo://example.com:8042/over/there?name=ferret#nose\n * \\_/ \\______________/\\_________/ \\_________/ \\__/\n * | | | | |\n * scheme authority path query fragment\n * | _____________________|__\n * / \\ / \\\n * urn:example:animal:ferret:nose\n * ```\n */\nexport class URI {\n static isUri(thing) {\n if (thing instanceof URI) {\n return true;\n }\n if (!thing) {\n return false;\n }\n return typeof thing.authority === 'string'\n && typeof thing.fragment === 'string'\n && typeof thing.path === 'string'\n && typeof thing.query === 'string'\n && typeof thing.scheme === 'string'\n && typeof thing.fsPath === 'string'\n && typeof thing.with === 'function'\n && typeof thing.toString === 'function';\n }\n /**\n * @internal\n */\n constructor(schemeOrData, authority, path, query, fragment, _strict = false) {\n if (typeof schemeOrData === 'object') {\n this.scheme = schemeOrData.scheme || _empty;\n this.authority = schemeOrData.authority || _empty;\n this.path = schemeOrData.path || _empty;\n this.query = schemeOrData.query || _empty;\n this.fragment = schemeOrData.fragment || _empty;\n // no validation because it's this URI\n // that creates uri components.\n // _validateUri(this);\n }\n else {\n this.scheme = _schemeFix(schemeOrData, _strict);\n this.authority = authority || _empty;\n this.path = _referenceResolution(this.scheme, path || _empty);\n this.query = query || _empty;\n this.fragment = fragment || _empty;\n _validateUri(this, _strict);\n }\n }\n // ---- filesystem path -----------------------\n /**\n * Returns a string representing the corresponding file system path of this URI.\n * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the\n * platform specific path separator.\n *\n * * Will *not* validate the path for invalid characters and semantics.\n * * Will *not* look at the scheme of this URI.\n * * The result shall *not* be used for display purposes but for accessing a file on disk.\n *\n *\n * The *difference* to `URI#path` is the use of the platform specific separator and the handling\n * of UNC paths. See the below sample of a file-uri with an authority (UNC path).\n *\n * ```ts\n const u = URI.parse('file://server/c$/folder/file.txt')\n u.authority === 'server'\n u.path === '/shares/c$/file.txt'\n u.fsPath === '\\\\server\\c$\\folder\\file.txt'\n ```\n *\n * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,\n * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working\n * with URIs that represent files on disk (`file` scheme).\n */\n get fsPath() {\n // if (this.scheme !== 'file') {\n // \tconsole.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);\n // }\n return uriToFsPath(this, false);\n }\n // ---- modify to new -------------------------\n with(change) {\n if (!change) {\n return this;\n }\n let { scheme, authority, path, query, fragment } = change;\n if (scheme === undefined) {\n scheme = this.scheme;\n }\n else if (scheme === null) {\n scheme = _empty;\n }\n if (authority === undefined) {\n authority = this.authority;\n }\n else if (authority === null) {\n authority = _empty;\n }\n if (path === undefined) {\n path = this.path;\n }\n else if (path === null) {\n path = _empty;\n }\n if (query === undefined) {\n query = this.query;\n }\n else if (query === null) {\n query = _empty;\n }\n if (fragment === undefined) {\n fragment = this.fragment;\n }\n else if (fragment === null) {\n fragment = _empty;\n }\n if (scheme === this.scheme\n && authority === this.authority\n && path === this.path\n && query === this.query\n && fragment === this.fragment) {\n return this;\n }\n return new Uri(scheme, authority, path, query, fragment);\n }\n // ---- parse & validate ------------------------\n /**\n * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,\n * `file:///usr/home`, or `scheme:with/path`.\n *\n * @param value A string which represents an URI (see `URI#toString`).\n */\n static parse(value, _strict = false) {\n const match = _regexp.exec(value);\n if (!match) {\n return new Uri(_empty, _empty, _empty, _empty, _empty);\n }\n return new Uri(match[2] || _empty, percentDecode(match[4] || _empty), percentDecode(match[5] || _empty), percentDecode(match[7] || _empty), percentDecode(match[9] || _empty), _strict);\n }\n /**\n * Creates a new URI from a file system path, e.g. `c:\\my\\files`,\n * `/usr/home`, or `\\\\server\\share\\some\\path`.\n *\n * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument\n * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**\n * `URI.parse('file://' + path)` because the path might contain characters that are\n * interpreted (# and ?). See the following sample:\n * ```ts\n const good = URI.file('/coding/c#/project1');\n good.scheme === 'file';\n good.path === '/coding/c#/project1';\n good.fragment === '';\n const bad = URI.parse('file://' + '/coding/c#/project1');\n bad.scheme === 'file';\n bad.path === '/coding/c'; // path is now broken\n bad.fragment === '/project1';\n ```\n *\n * @param path A file system path (see `URI#fsPath`)\n */\n static file(path) {\n let authority = _empty;\n // normalize to fwd-slashes on windows,\n // on other systems bwd-slashes are valid\n // filename character, eg /f\\oo/ba\\r.txt\n if (isWindows) {\n path = path.replace(/\\\\/g, _slash);\n }\n // check for authority as used in UNC shares\n // or use the path as given\n if (path[0] === _slash && path[1] === _slash) {\n const idx = path.indexOf(_slash, 2);\n if (idx === -1) {\n authority = path.substring(2);\n path = _slash;\n }\n else {\n authority = path.substring(2, idx);\n path = path.substring(idx) || _slash;\n }\n }\n return new Uri('file', authority, path, _empty, _empty);\n }\n /**\n * Creates new URI from uri components.\n *\n * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs\n * validation and should be used for untrusted uri components retrieved from storage,\n * user input, command arguments etc\n */\n static from(components, strict) {\n const result = new Uri(components.scheme, components.authority, components.path, components.query, components.fragment, strict);\n return result;\n }\n /**\n * Join a URI path with path fragments and normalizes the resulting path.\n *\n * @param uri The input URI.\n * @param pathFragment The path fragment to add to the URI path.\n * @returns The resulting URI.\n */\n static joinPath(uri, ...pathFragment) {\n if (!uri.path) {\n throw new Error(`[UriError]: cannot call joinPath on URI without path`);\n }\n let newPath;\n if (isWindows && uri.scheme === 'file') {\n newPath = URI.file(paths.win32.join(uriToFsPath(uri, true), ...pathFragment)).path;\n }\n else {\n newPath = paths.posix.join(uri.path, ...pathFragment);\n }\n return uri.with({ path: newPath });\n }\n // ---- printing/externalize ---------------------------\n /**\n * Creates a string representation for this URI. It's guaranteed that calling\n * `URI.parse` with the result of this function creates an URI which is equal\n * to this URI.\n *\n * * The result shall *not* be used for display purposes but for externalization or transport.\n * * The result will be encoded using the percentage encoding and encoding happens mostly\n * ignore the scheme-specific encoding rules.\n *\n * @param skipEncoding Do not encode the result, default is `false`\n */\n toString(skipEncoding = false) {\n return _asFormatted(this, skipEncoding);\n }\n toJSON() {\n return this;\n }\n static revive(data) {\n var _a, _b;\n if (!data) {\n return data;\n }\n else if (data instanceof URI) {\n return data;\n }\n else {\n const result = new Uri(data);\n result._formatted = (_a = data.external) !== null && _a !== void 0 ? _a : null;\n result._fsPath = data._sep === _pathSepMarker ? (_b = data.fsPath) !== null && _b !== void 0 ? _b : null : null;\n return result;\n }\n }\n}\nconst _pathSepMarker = isWindows ? 1 : undefined;\n// This class exists so that URI is compatible with vscode.Uri (API).\nclass Uri extends URI {\n constructor() {\n super(...arguments);\n this._formatted = null;\n this._fsPath = null;\n }\n get fsPath() {\n if (!this._fsPath) {\n this._fsPath = uriToFsPath(this, false);\n }\n return this._fsPath;\n }\n toString(skipEncoding = false) {\n if (!skipEncoding) {\n if (!this._formatted) {\n this._formatted = _asFormatted(this, false);\n }\n return this._formatted;\n }\n else {\n // we don't cache that\n return _asFormatted(this, true);\n }\n }\n toJSON() {\n const res = {\n $mid: 1 /* MarshalledId.Uri */\n };\n // cached state\n if (this._fsPath) {\n res.fsPath = this._fsPath;\n res._sep = _pathSepMarker;\n }\n if (this._formatted) {\n res.external = this._formatted;\n }\n //--- uri components\n if (this.path) {\n res.path = this.path;\n }\n // TODO\n // this isn't correct and can violate the UriComponents contract but\n // this is part of the vscode.Uri API and we shouldn't change how that\n // works anymore\n if (this.scheme) {\n res.scheme = this.scheme;\n }\n if (this.authority) {\n res.authority = this.authority;\n }\n if (this.query) {\n res.query = this.query;\n }\n if (this.fragment) {\n res.fragment = this.fragment;\n }\n return res;\n }\n}\n// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2\nconst encodeTable = {\n [58 /* CharCode.Colon */]: '%3A', // gen-delims\n [47 /* CharCode.Slash */]: '%2F',\n [63 /* CharCode.QuestionMark */]: '%3F',\n [35 /* CharCode.Hash */]: '%23',\n [91 /* CharCode.OpenSquareBracket */]: '%5B',\n [93 /* CharCode.CloseSquareBracket */]: '%5D',\n [64 /* CharCode.AtSign */]: '%40',\n [33 /* CharCode.ExclamationMark */]: '%21', // sub-delims\n [36 /* CharCode.DollarSign */]: '%24',\n [38 /* CharCode.Ampersand */]: '%26',\n [39 /* CharCode.SingleQuote */]: '%27',\n [40 /* CharCode.OpenParen */]: '%28',\n [41 /* CharCode.CloseParen */]: '%29',\n [42 /* CharCode.Asterisk */]: '%2A',\n [43 /* CharCode.Plus */]: '%2B',\n [44 /* CharCode.Comma */]: '%2C',\n [59 /* CharCode.Semicolon */]: '%3B',\n [61 /* CharCode.Equals */]: '%3D',\n [32 /* CharCode.Space */]: '%20',\n};\nfunction encodeURIComponentFast(uriComponent, isPath, isAuthority) {\n let res = undefined;\n let nativeEncodePos = -1;\n for (let pos = 0; pos < uriComponent.length; pos++) {\n const code = uriComponent.charCodeAt(pos);\n // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3\n if ((code >= 97 /* CharCode.a */ && code <= 122 /* CharCode.z */)\n || (code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */)\n || (code >= 48 /* CharCode.Digit0 */ && code <= 57 /* CharCode.Digit9 */)\n || code === 45 /* CharCode.Dash */\n || code === 46 /* CharCode.Period */\n || code === 95 /* CharCode.Underline */\n || code === 126 /* CharCode.Tilde */\n || (isPath && code === 47 /* CharCode.Slash */)\n || (isAuthority && code === 91 /* CharCode.OpenSquareBracket */)\n || (isAuthority && code === 93 /* CharCode.CloseSquareBracket */)\n || (isAuthority && code === 58 /* CharCode.Colon */)) {\n // check if we are delaying native encode\n if (nativeEncodePos !== -1) {\n res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n nativeEncodePos = -1;\n }\n // check if we write into a new string (by default we try to return the param)\n if (res !== undefined) {\n res += uriComponent.charAt(pos);\n }\n }\n else {\n // encoding needed, we need to allocate a new string\n if (res === undefined) {\n res = uriComponent.substr(0, pos);\n }\n // check with default table first\n const escaped = encodeTable[code];\n if (escaped !== undefined) {\n // check if we are delaying native encode\n if (nativeEncodePos !== -1) {\n res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n nativeEncodePos = -1;\n }\n // append escaped variant to result\n res += escaped;\n }\n else if (nativeEncodePos === -1) {\n // use native encode only when needed\n nativeEncodePos = pos;\n }\n }\n }\n if (nativeEncodePos !== -1) {\n res += encodeURIComponent(uriComponent.substring(nativeEncodePos));\n }\n return res !== undefined ? res : uriComponent;\n}\nfunction encodeURIComponentMinimal(path) {\n let res = undefined;\n for (let pos = 0; pos < path.length; pos++) {\n const code = path.charCodeAt(pos);\n if (code === 35 /* CharCode.Hash */ || code === 63 /* CharCode.QuestionMark */) {\n if (res === undefined) {\n res = path.substr(0, pos);\n }\n res += encodeTable[code];\n }\n else {\n if (res !== undefined) {\n res += path[pos];\n }\n }\n }\n return res !== undefined ? res : path;\n}\n/**\n * Compute `fsPath` for the given uri\n */\nexport function uriToFsPath(uri, keepDriveLetterCasing) {\n let value;\n if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {\n // unc path: file://shares/c$/far/boo\n value = `//${uri.authority}${uri.path}`;\n }\n else if (uri.path.charCodeAt(0) === 47 /* CharCode.Slash */\n && (uri.path.charCodeAt(1) >= 65 /* CharCode.A */ && uri.path.charCodeAt(1) <= 90 /* CharCode.Z */ || uri.path.charCodeAt(1) >= 97 /* CharCode.a */ && uri.path.charCodeAt(1) <= 122 /* CharCode.z */)\n && uri.path.charCodeAt(2) === 58 /* CharCode.Colon */) {\n if (!keepDriveLetterCasing) {\n // windows drive letter: file:///c:/far/boo\n value = uri.path[1].toLowerCase() + uri.path.substr(2);\n }\n else {\n value = uri.path.substr(1);\n }\n }\n else {\n // other path\n value = uri.path;\n }\n if (isWindows) {\n value = value.replace(/\\//g, '\\\\');\n }\n return value;\n}\n/**\n * Create the external version of a uri\n */\nfunction _asFormatted(uri, skipEncoding) {\n const encoder = !skipEncoding\n ? encodeURIComponentFast\n : encodeURIComponentMinimal;\n let res = '';\n let { scheme, authority, path, query, fragment } = uri;\n if (scheme) {\n res += scheme;\n res += ':';\n }\n if (authority || scheme === 'file') {\n res += _slash;\n res += _slash;\n }\n if (authority) {\n let idx = authority.indexOf('@');\n if (idx !== -1) {\n // @\n const userinfo = authority.substr(0, idx);\n authority = authority.substr(idx + 1);\n idx = userinfo.lastIndexOf(':');\n if (idx === -1) {\n res += encoder(userinfo, false, false);\n }\n else {\n // :@\n res += encoder(userinfo.substr(0, idx), false, false);\n res += ':';\n res += encoder(userinfo.substr(idx + 1), false, true);\n }\n res += '@';\n }\n authority = authority.toLowerCase();\n idx = authority.lastIndexOf(':');\n if (idx === -1) {\n res += encoder(authority, false, true);\n }\n else {\n // :\n res += encoder(authority.substr(0, idx), false, true);\n res += authority.substr(idx);\n }\n }\n if (path) {\n // lower-case windows drive letters in /C:/fff or C:/fff\n if (path.length >= 3 && path.charCodeAt(0) === 47 /* CharCode.Slash */ && path.charCodeAt(2) === 58 /* CharCode.Colon */) {\n const code = path.charCodeAt(1);\n if (code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */) {\n path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`; // \"/c:\".length === 3\n }\n }\n else if (path.length >= 2 && path.charCodeAt(1) === 58 /* CharCode.Colon */) {\n const code = path.charCodeAt(0);\n if (code >= 65 /* CharCode.A */ && code <= 90 /* CharCode.Z */) {\n path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // \"/c:\".length === 3\n }\n }\n // encode the rest of the path\n res += encoder(path, true, false);\n }\n if (query) {\n res += '?';\n res += encoder(query, false, false);\n }\n if (fragment) {\n res += '#';\n res += !skipEncoding ? encodeURIComponentFast(fragment, false, false) : fragment;\n }\n return res;\n}\n// --- decode\nfunction decodeURIComponentGraceful(str) {\n try {\n return decodeURIComponent(str);\n }\n catch (_a) {\n if (str.length > 3) {\n return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3));\n }\n else {\n return str;\n }\n }\n}\nconst _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;\nfunction percentDecode(str) {\n if (!str.match(_rEncodedAsHex)) {\n return str;\n }\n return str.replace(_rEncodedAsHex, (match) => decodeURIComponentGraceful(match));\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { transformErrorForSerialization } from '../errors.js';\nimport { Emitter } from '../event.js';\nimport { Disposable } from '../lifecycle.js';\nimport { getAllMethodNames } from '../objects.js';\nimport { isWeb } from '../platform.js';\nimport * as strings from '../strings.js';\nconst INITIALIZE = '$initialize';\nlet webWorkerWarningLogged = false;\nexport function logOnceWebWorkerWarning(err) {\n if (!isWeb) {\n // running tests\n return;\n }\n if (!webWorkerWarningLogged) {\n webWorkerWarningLogged = true;\n console.warn('Could not create web worker(s). Falling back to loading web worker code in main thread, which might cause UI freezes. Please see https://github.com/microsoft/monaco-editor#faq');\n }\n console.warn(err.message);\n}\nclass RequestMessage {\n constructor(vsWorker, req, method, args) {\n this.vsWorker = vsWorker;\n this.req = req;\n this.method = method;\n this.args = args;\n this.type = 0 /* MessageType.Request */;\n }\n}\nclass ReplyMessage {\n constructor(vsWorker, seq, res, err) {\n this.vsWorker = vsWorker;\n this.seq = seq;\n this.res = res;\n this.err = err;\n this.type = 1 /* MessageType.Reply */;\n }\n}\nclass SubscribeEventMessage {\n constructor(vsWorker, req, eventName, arg) {\n this.vsWorker = vsWorker;\n this.req = req;\n this.eventName = eventName;\n this.arg = arg;\n this.type = 2 /* MessageType.SubscribeEvent */;\n }\n}\nclass EventMessage {\n constructor(vsWorker, req, event) {\n this.vsWorker = vsWorker;\n this.req = req;\n this.event = event;\n this.type = 3 /* MessageType.Event */;\n }\n}\nclass UnsubscribeEventMessage {\n constructor(vsWorker, req) {\n this.vsWorker = vsWorker;\n this.req = req;\n this.type = 4 /* MessageType.UnsubscribeEvent */;\n }\n}\nclass SimpleWorkerProtocol {\n constructor(handler) {\n this._workerId = -1;\n this._handler = handler;\n this._lastSentReq = 0;\n this._pendingReplies = Object.create(null);\n this._pendingEmitters = new Map();\n this._pendingEvents = new Map();\n }\n setWorkerId(workerId) {\n this._workerId = workerId;\n }\n sendMessage(method, args) {\n const req = String(++this._lastSentReq);\n return new Promise((resolve, reject) => {\n this._pendingReplies[req] = {\n resolve: resolve,\n reject: reject\n };\n this._send(new RequestMessage(this._workerId, req, method, args));\n });\n }\n listen(eventName, arg) {\n let req = null;\n const emitter = new Emitter({\n onWillAddFirstListener: () => {\n req = String(++this._lastSentReq);\n this._pendingEmitters.set(req, emitter);\n this._send(new SubscribeEventMessage(this._workerId, req, eventName, arg));\n },\n onDidRemoveLastListener: () => {\n this._pendingEmitters.delete(req);\n this._send(new UnsubscribeEventMessage(this._workerId, req));\n req = null;\n }\n });\n return emitter.event;\n }\n handleMessage(message) {\n if (!message || !message.vsWorker) {\n return;\n }\n if (this._workerId !== -1 && message.vsWorker !== this._workerId) {\n return;\n }\n this._handleMessage(message);\n }\n _handleMessage(msg) {\n switch (msg.type) {\n case 1 /* MessageType.Reply */:\n return this._handleReplyMessage(msg);\n case 0 /* MessageType.Request */:\n return this._handleRequestMessage(msg);\n case 2 /* MessageType.SubscribeEvent */:\n return this._handleSubscribeEventMessage(msg);\n case 3 /* MessageType.Event */:\n return this._handleEventMessage(msg);\n case 4 /* MessageType.UnsubscribeEvent */:\n return this._handleUnsubscribeEventMessage(msg);\n }\n }\n _handleReplyMessage(replyMessage) {\n if (!this._pendingReplies[replyMessage.seq]) {\n console.warn('Got reply to unknown seq');\n return;\n }\n const reply = this._pendingReplies[replyMessage.seq];\n delete this._pendingReplies[replyMessage.seq];\n if (replyMessage.err) {\n let err = replyMessage.err;\n if (replyMessage.err.$isError) {\n err = new Error();\n err.name = replyMessage.err.name;\n err.message = replyMessage.err.message;\n err.stack = replyMessage.err.stack;\n }\n reply.reject(err);\n return;\n }\n reply.resolve(replyMessage.res);\n }\n _handleRequestMessage(requestMessage) {\n const req = requestMessage.req;\n const result = this._handler.handleMessage(requestMessage.method, requestMessage.args);\n result.then((r) => {\n this._send(new ReplyMessage(this._workerId, req, r, undefined));\n }, (e) => {\n if (e.detail instanceof Error) {\n // Loading errors have a detail property that points to the actual error\n e.detail = transformErrorForSerialization(e.detail);\n }\n this._send(new ReplyMessage(this._workerId, req, undefined, transformErrorForSerialization(e)));\n });\n }\n _handleSubscribeEventMessage(msg) {\n const req = msg.req;\n const disposable = this._handler.handleEvent(msg.eventName, msg.arg)((event) => {\n this._send(new EventMessage(this._workerId, req, event));\n });\n this._pendingEvents.set(req, disposable);\n }\n _handleEventMessage(msg) {\n if (!this._pendingEmitters.has(msg.req)) {\n console.warn('Got event for unknown req');\n return;\n }\n this._pendingEmitters.get(msg.req).fire(msg.event);\n }\n _handleUnsubscribeEventMessage(msg) {\n if (!this._pendingEvents.has(msg.req)) {\n console.warn('Got unsubscribe for unknown req');\n return;\n }\n this._pendingEvents.get(msg.req).dispose();\n this._pendingEvents.delete(msg.req);\n }\n _send(msg) {\n const transfer = [];\n if (msg.type === 0 /* MessageType.Request */) {\n for (let i = 0; i < msg.args.length; i++) {\n if (msg.args[i] instanceof ArrayBuffer) {\n transfer.push(msg.args[i]);\n }\n }\n }\n else if (msg.type === 1 /* MessageType.Reply */) {\n if (msg.res instanceof ArrayBuffer) {\n transfer.push(msg.res);\n }\n }\n this._handler.sendMessage(msg, transfer);\n }\n}\n/**\n * Main thread side\n */\nexport class SimpleWorkerClient extends Disposable {\n constructor(workerFactory, moduleId, host) {\n super();\n let lazyProxyReject = null;\n this._worker = this._register(workerFactory.create('vs/base/common/worker/simpleWorker', (msg) => {\n this._protocol.handleMessage(msg);\n }, (err) => {\n // in Firefox, web workers fail lazily :(\n // we will reject the proxy\n lazyProxyReject === null || lazyProxyReject === void 0 ? void 0 : lazyProxyReject(err);\n }));\n this._protocol = new SimpleWorkerProtocol({\n sendMessage: (msg, transfer) => {\n this._worker.postMessage(msg, transfer);\n },\n handleMessage: (method, args) => {\n if (typeof host[method] !== 'function') {\n return Promise.reject(new Error('Missing method ' + method + ' on main thread host.'));\n }\n try {\n return Promise.resolve(host[method].apply(host, args));\n }\n catch (e) {\n return Promise.reject(e);\n }\n },\n handleEvent: (eventName, arg) => {\n if (propertyIsDynamicEvent(eventName)) {\n const event = host[eventName].call(host, arg);\n if (typeof event !== 'function') {\n throw new Error(`Missing dynamic event ${eventName} on main thread host.`);\n }\n return event;\n }\n if (propertyIsEvent(eventName)) {\n const event = host[eventName];\n if (typeof event !== 'function') {\n throw new Error(`Missing event ${eventName} on main thread host.`);\n }\n return event;\n }\n throw new Error(`Malformed event name ${eventName}`);\n }\n });\n this._protocol.setWorkerId(this._worker.getId());\n // Gather loader configuration\n let loaderConfiguration = null;\n const globalRequire = globalThis.require;\n if (typeof globalRequire !== 'undefined' && typeof globalRequire.getConfig === 'function') {\n // Get the configuration from the Monaco AMD Loader\n loaderConfiguration = globalRequire.getConfig();\n }\n else if (typeof globalThis.requirejs !== 'undefined') {\n // Get the configuration from requirejs\n loaderConfiguration = globalThis.requirejs.s.contexts._.config;\n }\n const hostMethods = getAllMethodNames(host);\n // Send initialize message\n this._onModuleLoaded = this._protocol.sendMessage(INITIALIZE, [\n this._worker.getId(),\n JSON.parse(JSON.stringify(loaderConfiguration)),\n moduleId,\n hostMethods,\n ]);\n // Create proxy to loaded code\n const proxyMethodRequest = (method, args) => {\n return this._request(method, args);\n };\n const proxyListen = (eventName, arg) => {\n return this._protocol.listen(eventName, arg);\n };\n this._lazyProxy = new Promise((resolve, reject) => {\n lazyProxyReject = reject;\n this._onModuleLoaded.then((availableMethods) => {\n resolve(createProxyObject(availableMethods, proxyMethodRequest, proxyListen));\n }, (e) => {\n reject(e);\n this._onError('Worker failed to load ' + moduleId, e);\n });\n });\n }\n getProxyObject() {\n return this._lazyProxy;\n }\n _request(method, args) {\n return new Promise((resolve, reject) => {\n this._onModuleLoaded.then(() => {\n this._protocol.sendMessage(method, args).then(resolve, reject);\n }, reject);\n });\n }\n _onError(message, error) {\n console.error(message);\n console.info(error);\n }\n}\nfunction propertyIsEvent(name) {\n // Assume a property is an event if it has a form of \"onSomething\"\n return name[0] === 'o' && name[1] === 'n' && strings.isUpperAsciiLetter(name.charCodeAt(2));\n}\nfunction propertyIsDynamicEvent(name) {\n // Assume a property is a dynamic event (a method that returns an event) if it has a form of \"onDynamicSomething\"\n return /^onDynamic/.test(name) && strings.isUpperAsciiLetter(name.charCodeAt(9));\n}\nfunction createProxyObject(methodNames, invoke, proxyListen) {\n const createProxyMethod = (method) => {\n return function () {\n const args = Array.prototype.slice.call(arguments, 0);\n return invoke(method, args);\n };\n };\n const createProxyDynamicEvent = (eventName) => {\n return function (arg) {\n return proxyListen(eventName, arg);\n };\n };\n const result = {};\n for (const methodName of methodNames) {\n if (propertyIsDynamicEvent(methodName)) {\n result[methodName] = createProxyDynamicEvent(methodName);\n continue;\n }\n if (propertyIsEvent(methodName)) {\n result[methodName] = proxyListen(methodName, undefined);\n continue;\n }\n result[methodName] = createProxyMethod(methodName);\n }\n return result;\n}\n/**\n * Worker side\n */\nexport class SimpleWorkerServer {\n constructor(postMessage, requestHandlerFactory) {\n this._requestHandlerFactory = requestHandlerFactory;\n this._requestHandler = null;\n this._protocol = new SimpleWorkerProtocol({\n sendMessage: (msg, transfer) => {\n postMessage(msg, transfer);\n },\n handleMessage: (method, args) => this._handleMessage(method, args),\n handleEvent: (eventName, arg) => this._handleEvent(eventName, arg)\n });\n }\n onmessage(msg) {\n this._protocol.handleMessage(msg);\n }\n _handleMessage(method, args) {\n if (method === INITIALIZE) {\n return this.initialize(args[0], args[1], args[2], args[3]);\n }\n if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {\n return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n }\n try {\n return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));\n }\n catch (e) {\n return Promise.reject(e);\n }\n }\n _handleEvent(eventName, arg) {\n if (!this._requestHandler) {\n throw new Error(`Missing requestHandler`);\n }\n if (propertyIsDynamicEvent(eventName)) {\n const event = this._requestHandler[eventName].call(this._requestHandler, arg);\n if (typeof event !== 'function') {\n throw new Error(`Missing dynamic event ${eventName} on request handler.`);\n }\n return event;\n }\n if (propertyIsEvent(eventName)) {\n const event = this._requestHandler[eventName];\n if (typeof event !== 'function') {\n throw new Error(`Missing event ${eventName} on request handler.`);\n }\n return event;\n }\n throw new Error(`Malformed event name ${eventName}`);\n }\n initialize(workerId, loaderConfig, moduleId, hostMethods) {\n this._protocol.setWorkerId(workerId);\n const proxyMethodRequest = (method, args) => {\n return this._protocol.sendMessage(method, args);\n };\n const proxyListen = (eventName, arg) => {\n return this._protocol.listen(eventName, arg);\n };\n const hostProxy = createProxyObject(hostMethods, proxyMethodRequest, proxyListen);\n if (this._requestHandlerFactory) {\n // static request handler\n this._requestHandler = this._requestHandlerFactory(hostProxy);\n return Promise.resolve(getAllMethodNames(this._requestHandler));\n }\n if (loaderConfig) {\n // Remove 'baseUrl', handling it is beyond scope for now\n if (typeof loaderConfig.baseUrl !== 'undefined') {\n delete loaderConfig['baseUrl'];\n }\n if (typeof loaderConfig.paths !== 'undefined') {\n if (typeof loaderConfig.paths.vs !== 'undefined') {\n delete loaderConfig.paths['vs'];\n }\n }\n if (typeof loaderConfig.trustedTypesPolicy !== undefined) {\n // don't use, it has been destroyed during serialize\n delete loaderConfig['trustedTypesPolicy'];\n }\n // Since this is in a web worker, enable catching errors\n loaderConfig.catchError = true;\n globalThis.require.config(loaderConfig);\n }\n return new Promise((resolve, reject) => {\n // Use the global require to be sure to get the global config\n // ESM-comment-begin\n // \t\t\tconst req = (globalThis.require || require);\n // ESM-comment-end\n // ESM-uncomment-begin\n const req = globalThis.require;\n // ESM-uncomment-end\n req([moduleId], (module) => {\n this._requestHandler = module.create(hostProxy);\n if (!this._requestHandler) {\n reject(new Error(`No RequestHandler!`));\n return;\n }\n resolve(getAllMethodNames(this._requestHandler));\n }, reject);\n });\n }\n}\n/**\n * Called on the worker side\n * @skipMangle\n */\nexport function create(postMessage) {\n return new SimpleWorkerServer(postMessage, null);\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { toUint8 } from '../../../base/common/uint.js';\n/**\n * A fast character classifier that uses a compact array for ASCII values.\n */\nexport class CharacterClassifier {\n constructor(_defaultValue) {\n const defaultValue = toUint8(_defaultValue);\n this._defaultValue = defaultValue;\n this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\n this._map = new Map();\n }\n static _createAsciiMap(defaultValue) {\n const asciiMap = new Uint8Array(256);\n asciiMap.fill(defaultValue);\n return asciiMap;\n }\n set(charCode, _value) {\n const value = toUint8(_value);\n if (charCode >= 0 && charCode < 256) {\n this._asciiMap[charCode] = value;\n }\n else {\n this._map.set(charCode, value);\n }\n }\n get(charCode) {\n if (charCode >= 0 && charCode < 256) {\n return this._asciiMap[charCode];\n }\n else {\n return (this._map.get(charCode) || this._defaultValue);\n }\n }\n clear() {\n this._asciiMap.fill(this._defaultValue);\n this._map.clear();\n }\n}\nexport class CharacterSet {\n constructor() {\n this._actual = new CharacterClassifier(0 /* Boolean.False */);\n }\n add(charCode) {\n this._actual.set(charCode, 1 /* Boolean.True */);\n }\n has(charCode) {\n return (this._actual.get(charCode) === 1 /* Boolean.True */);\n }\n clear() {\n return this._actual.clear();\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError } from '../../../base/common/errors.js';\nimport { OffsetRange } from './offsetRange.js';\nimport { Range } from './range.js';\nimport { findFirstIdxMonotonousOrArrLen, findLastIdxMonotonous, findLastMonotonous } from '../../../base/common/arraysFind.js';\n/**\n * A range of lines (1-based).\n */\nexport class LineRange {\n static fromRange(range) {\n return new LineRange(range.startLineNumber, range.endLineNumber);\n }\n static fromRangeInclusive(range) {\n return new LineRange(range.startLineNumber, range.endLineNumber + 1);\n }\n /**\n * @param lineRanges An array of sorted line ranges.\n */\n static joinMany(lineRanges) {\n if (lineRanges.length === 0) {\n return [];\n }\n let result = new LineRangeSet(lineRanges[0].slice());\n for (let i = 1; i < lineRanges.length; i++) {\n result = result.getUnion(new LineRangeSet(lineRanges[i].slice()));\n }\n return result.ranges;\n }\n static ofLength(startLineNumber, length) {\n return new LineRange(startLineNumber, startLineNumber + length);\n }\n /**\n * @internal\n */\n static deserialize(lineRange) {\n return new LineRange(lineRange[0], lineRange[1]);\n }\n constructor(startLineNumber, endLineNumberExclusive) {\n if (startLineNumber > endLineNumberExclusive) {\n throw new BugIndicatingError(`startLineNumber ${startLineNumber} cannot be after endLineNumberExclusive ${endLineNumberExclusive}`);\n }\n this.startLineNumber = startLineNumber;\n this.endLineNumberExclusive = endLineNumberExclusive;\n }\n /**\n * Indicates if this line range contains the given line number.\n */\n contains(lineNumber) {\n return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;\n }\n /**\n * Indicates if this line range is empty.\n */\n get isEmpty() {\n return this.startLineNumber === this.endLineNumberExclusive;\n }\n /**\n * Moves this line range by the given offset of line numbers.\n */\n delta(offset) {\n return new LineRange(this.startLineNumber + offset, this.endLineNumberExclusive + offset);\n }\n deltaLength(offset) {\n return new LineRange(this.startLineNumber, this.endLineNumberExclusive + offset);\n }\n /**\n * The number of lines this line range spans.\n */\n get length() {\n return this.endLineNumberExclusive - this.startLineNumber;\n }\n /**\n * Creates a line range that combines this and the given line range.\n */\n join(other) {\n return new LineRange(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));\n }\n toString() {\n return `[${this.startLineNumber},${this.endLineNumberExclusive})`;\n }\n /**\n * The resulting range is empty if the ranges do not intersect, but touch.\n * If the ranges don't even touch, the result is undefined.\n */\n intersect(other) {\n const startLineNumber = Math.max(this.startLineNumber, other.startLineNumber);\n const endLineNumberExclusive = Math.min(this.endLineNumberExclusive, other.endLineNumberExclusive);\n if (startLineNumber <= endLineNumberExclusive) {\n return new LineRange(startLineNumber, endLineNumberExclusive);\n }\n return undefined;\n }\n intersectsStrict(other) {\n return this.startLineNumber < other.endLineNumberExclusive && other.startLineNumber < this.endLineNumberExclusive;\n }\n overlapOrTouch(other) {\n return this.startLineNumber <= other.endLineNumberExclusive && other.startLineNumber <= this.endLineNumberExclusive;\n }\n equals(b) {\n return this.startLineNumber === b.startLineNumber && this.endLineNumberExclusive === b.endLineNumberExclusive;\n }\n toInclusiveRange() {\n if (this.isEmpty) {\n return null;\n }\n return new Range(this.startLineNumber, 1, this.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER);\n }\n toExclusiveRange() {\n return new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1);\n }\n mapToLineArray(f) {\n const result = [];\n for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {\n result.push(f(lineNumber));\n }\n return result;\n }\n forEach(f) {\n for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {\n f(lineNumber);\n }\n }\n /**\n * @internal\n */\n serialize() {\n return [this.startLineNumber, this.endLineNumberExclusive];\n }\n includes(lineNumber) {\n return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;\n }\n /**\n * Converts this 1-based line range to a 0-based offset range (subtracts 1!).\n * @internal\n */\n toOffsetRange() {\n return new OffsetRange(this.startLineNumber - 1, this.endLineNumberExclusive - 1);\n }\n}\nexport class LineRangeSet {\n constructor(\n /**\n * Sorted by start line number.\n * No two line ranges are touching or intersecting.\n */\n _normalizedRanges = []) {\n this._normalizedRanges = _normalizedRanges;\n }\n get ranges() {\n return this._normalizedRanges;\n }\n addRange(range) {\n if (range.length === 0) {\n return;\n }\n // Idea: Find joinRange such that:\n // replaceRange = _normalizedRanges.replaceRange(joinRange, range.joinAll(joinRange.map(idx => this._normalizedRanges[idx])))\n // idx of first element that touches range or that is after range\n const joinRangeStartIdx = findFirstIdxMonotonousOrArrLen(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber);\n // idx of element after { last element that touches range or that is before range }\n const joinRangeEndIdxExclusive = findLastIdxMonotonous(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;\n if (joinRangeStartIdx === joinRangeEndIdxExclusive) {\n // If there is no element that touches range, then joinRangeStartIdx === joinRangeEndIdxExclusive and that value is the index of the element after range\n this._normalizedRanges.splice(joinRangeStartIdx, 0, range);\n }\n else if (joinRangeStartIdx === joinRangeEndIdxExclusive - 1) {\n // Else, there is an element that touches range and in this case it is both the first and last element. Thus we can replace it\n const joinRange = this._normalizedRanges[joinRangeStartIdx];\n this._normalizedRanges[joinRangeStartIdx] = joinRange.join(range);\n }\n else {\n // First and last element are different - we need to replace the entire range\n const joinRange = this._normalizedRanges[joinRangeStartIdx].join(this._normalizedRanges[joinRangeEndIdxExclusive - 1]).join(range);\n this._normalizedRanges.splice(joinRangeStartIdx, joinRangeEndIdxExclusive - joinRangeStartIdx, joinRange);\n }\n }\n contains(lineNumber) {\n const rangeThatStartsBeforeEnd = findLastMonotonous(this._normalizedRanges, r => r.startLineNumber <= lineNumber);\n return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > lineNumber;\n }\n intersects(range) {\n const rangeThatStartsBeforeEnd = findLastMonotonous(this._normalizedRanges, r => r.startLineNumber < range.endLineNumberExclusive);\n return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > range.startLineNumber;\n }\n getUnion(other) {\n if (this._normalizedRanges.length === 0) {\n return other;\n }\n if (other._normalizedRanges.length === 0) {\n return this;\n }\n const result = [];\n let i1 = 0;\n let i2 = 0;\n let current = null;\n while (i1 < this._normalizedRanges.length || i2 < other._normalizedRanges.length) {\n let next = null;\n if (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) {\n const lineRange1 = this._normalizedRanges[i1];\n const lineRange2 = other._normalizedRanges[i2];\n if (lineRange1.startLineNumber < lineRange2.startLineNumber) {\n next = lineRange1;\n i1++;\n }\n else {\n next = lineRange2;\n i2++;\n }\n }\n else if (i1 < this._normalizedRanges.length) {\n next = this._normalizedRanges[i1];\n i1++;\n }\n else {\n next = other._normalizedRanges[i2];\n i2++;\n }\n if (current === null) {\n current = next;\n }\n else {\n if (current.endLineNumberExclusive >= next.startLineNumber) {\n // merge\n current = new LineRange(current.startLineNumber, Math.max(current.endLineNumberExclusive, next.endLineNumberExclusive));\n }\n else {\n // push\n result.push(current);\n current = next;\n }\n }\n }\n if (current !== null) {\n result.push(current);\n }\n return new LineRangeSet(result);\n }\n /**\n * Subtracts all ranges in this set from `range` and returns the result.\n */\n subtractFrom(range) {\n // idx of first element that touches range or that is after range\n const joinRangeStartIdx = findFirstIdxMonotonousOrArrLen(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber);\n // idx of element after { last element that touches range or that is before range }\n const joinRangeEndIdxExclusive = findLastIdxMonotonous(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;\n if (joinRangeStartIdx === joinRangeEndIdxExclusive) {\n return new LineRangeSet([range]);\n }\n const result = [];\n let startLineNumber = range.startLineNumber;\n for (let i = joinRangeStartIdx; i < joinRangeEndIdxExclusive; i++) {\n const r = this._normalizedRanges[i];\n if (r.startLineNumber > startLineNumber) {\n result.push(new LineRange(startLineNumber, r.startLineNumber));\n }\n startLineNumber = r.endLineNumberExclusive;\n }\n if (startLineNumber < range.endLineNumberExclusive) {\n result.push(new LineRange(startLineNumber, range.endLineNumberExclusive));\n }\n return new LineRangeSet(result);\n }\n toString() {\n return this._normalizedRanges.map(r => r.toString()).join(', ');\n }\n getIntersection(other) {\n const result = [];\n let i1 = 0;\n let i2 = 0;\n while (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) {\n const r1 = this._normalizedRanges[i1];\n const r2 = other._normalizedRanges[i2];\n const i = r1.intersect(r2);\n if (i && !i.isEmpty) {\n result.push(i);\n }\n if (r1.endLineNumberExclusive < r2.endLineNumberExclusive) {\n i1++;\n }\n else {\n i2++;\n }\n }\n return new LineRangeSet(result);\n }\n getWithDelta(value) {\n return new LineRangeSet(this._normalizedRanges.map(r => r.delta(value)));\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError } from '../../../base/common/errors.js';\n/**\n * A range of offsets (0-based).\n*/\nexport class OffsetRange {\n static addRange(range, sortedRanges) {\n let i = 0;\n while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) {\n i++;\n }\n let j = i;\n while (j < sortedRanges.length && sortedRanges[j].start <= range.endExclusive) {\n j++;\n }\n if (i === j) {\n sortedRanges.splice(i, 0, range);\n }\n else {\n const start = Math.min(range.start, sortedRanges[i].start);\n const end = Math.max(range.endExclusive, sortedRanges[j - 1].endExclusive);\n sortedRanges.splice(i, j - i, new OffsetRange(start, end));\n }\n }\n static tryCreate(start, endExclusive) {\n if (start > endExclusive) {\n return undefined;\n }\n return new OffsetRange(start, endExclusive);\n }\n static ofLength(length) {\n return new OffsetRange(0, length);\n }\n static ofStartAndLength(start, length) {\n return new OffsetRange(start, start + length);\n }\n constructor(start, endExclusive) {\n this.start = start;\n this.endExclusive = endExclusive;\n if (start > endExclusive) {\n throw new BugIndicatingError(`Invalid range: ${this.toString()}`);\n }\n }\n get isEmpty() {\n return this.start === this.endExclusive;\n }\n delta(offset) {\n return new OffsetRange(this.start + offset, this.endExclusive + offset);\n }\n deltaStart(offset) {\n return new OffsetRange(this.start + offset, this.endExclusive);\n }\n deltaEnd(offset) {\n return new OffsetRange(this.start, this.endExclusive + offset);\n }\n get length() {\n return this.endExclusive - this.start;\n }\n toString() {\n return `[${this.start}, ${this.endExclusive})`;\n }\n equals(other) {\n return this.start === other.start && this.endExclusive === other.endExclusive;\n }\n containsRange(other) {\n return this.start <= other.start && other.endExclusive <= this.endExclusive;\n }\n contains(offset) {\n return this.start <= offset && offset < this.endExclusive;\n }\n /**\n * for all numbers n: range1.contains(n) or range2.contains(n) => range1.join(range2).contains(n)\n * The joined range is the smallest range that contains both ranges.\n */\n join(other) {\n return new OffsetRange(Math.min(this.start, other.start), Math.max(this.endExclusive, other.endExclusive));\n }\n /**\n * for all numbers n: range1.contains(n) and range2.contains(n) <=> range1.intersect(range2).contains(n)\n *\n * The resulting range is empty if the ranges do not intersect, but touch.\n * If the ranges don't even touch, the result is undefined.\n */\n intersect(other) {\n const start = Math.max(this.start, other.start);\n const end = Math.min(this.endExclusive, other.endExclusive);\n if (start <= end) {\n return new OffsetRange(start, end);\n }\n return undefined;\n }\n isBefore(other) {\n return this.endExclusive <= other.start;\n }\n isAfter(other) {\n return this.start >= other.endExclusive;\n }\n slice(arr) {\n return arr.slice(this.start, this.endExclusive);\n }\n /**\n * Returns the given value if it is contained in this instance, otherwise the closest value that is contained.\n * The range must not be empty.\n */\n clip(value) {\n if (this.isEmpty) {\n throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);\n }\n return Math.max(this.start, Math.min(this.endExclusive - 1, value));\n }\n /**\n * Returns `r := value + k * length` such that `r` is contained in this range.\n * The range must not be empty.\n *\n * E.g. `[5, 10).clipCyclic(10) === 5`, `[5, 10).clipCyclic(11) === 6` and `[5, 10).clipCyclic(4) === 9`.\n */\n clipCyclic(value) {\n if (this.isEmpty) {\n throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);\n }\n if (value < this.start) {\n return this.endExclusive - ((this.start - value) % this.length);\n }\n if (value >= this.endExclusive) {\n return this.start + ((value - this.start) % this.length);\n }\n return value;\n }\n forEach(f) {\n for (let i = this.start; i < this.endExclusive; i++) {\n f(i);\n }\n }\n}\nexport class OffsetRangeSet {\n constructor() {\n this._sortedRanges = [];\n }\n addRange(range) {\n let i = 0;\n while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive < range.start) {\n i++;\n }\n let j = i;\n while (j < this._sortedRanges.length && this._sortedRanges[j].start <= range.endExclusive) {\n j++;\n }\n if (i === j) {\n this._sortedRanges.splice(i, 0, range);\n }\n else {\n const start = Math.min(range.start, this._sortedRanges[i].start);\n const end = Math.max(range.endExclusive, this._sortedRanges[j - 1].endExclusive);\n this._sortedRanges.splice(i, j - i, new OffsetRange(start, end));\n }\n }\n toString() {\n return this._sortedRanges.map(r => r.toString()).join(', ');\n }\n /**\n * Returns of there is a value that is contained in this instance and the given range.\n */\n intersectsStrict(other) {\n // TODO use binary search\n let i = 0;\n while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive <= other.start) {\n i++;\n }\n return i < this._sortedRanges.length && this._sortedRanges[i].start < other.endExclusive;\n }\n intersectWithRange(other) {\n // TODO use binary search + slice\n const result = new OffsetRangeSet();\n for (const range of this._sortedRanges) {\n const intersection = range.intersect(other);\n if (intersection) {\n result.addRange(intersection);\n }\n }\n return result;\n }\n intersectWithRangeLength(other) {\n return this.intersectWithRange(other).length;\n }\n get length() {\n return this._sortedRanges.reduce((prev, cur) => prev + cur.length, 0);\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * A position in the editor.\n */\nexport class Position {\n constructor(lineNumber, column) {\n this.lineNumber = lineNumber;\n this.column = column;\n }\n /**\n * Create a new position from this position.\n *\n * @param newLineNumber new line number\n * @param newColumn new column\n */\n with(newLineNumber = this.lineNumber, newColumn = this.column) {\n if (newLineNumber === this.lineNumber && newColumn === this.column) {\n return this;\n }\n else {\n return new Position(newLineNumber, newColumn);\n }\n }\n /**\n * Derive a new position from this position.\n *\n * @param deltaLineNumber line number delta\n * @param deltaColumn column delta\n */\n delta(deltaLineNumber = 0, deltaColumn = 0) {\n return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);\n }\n /**\n * Test if this position equals other position\n */\n equals(other) {\n return Position.equals(this, other);\n }\n /**\n * Test if position `a` equals position `b`\n */\n static equals(a, b) {\n if (!a && !b) {\n return true;\n }\n return (!!a &&\n !!b &&\n a.lineNumber === b.lineNumber &&\n a.column === b.column);\n }\n /**\n * Test if this position is before other position.\n * If the two positions are equal, the result will be false.\n */\n isBefore(other) {\n return Position.isBefore(this, other);\n }\n /**\n * Test if position `a` is before position `b`.\n * If the two positions are equal, the result will be false.\n */\n static isBefore(a, b) {\n if (a.lineNumber < b.lineNumber) {\n return true;\n }\n if (b.lineNumber < a.lineNumber) {\n return false;\n }\n return a.column < b.column;\n }\n /**\n * Test if this position is before other position.\n * If the two positions are equal, the result will be true.\n */\n isBeforeOrEqual(other) {\n return Position.isBeforeOrEqual(this, other);\n }\n /**\n * Test if position `a` is before position `b`.\n * If the two positions are equal, the result will be true.\n */\n static isBeforeOrEqual(a, b) {\n if (a.lineNumber < b.lineNumber) {\n return true;\n }\n if (b.lineNumber < a.lineNumber) {\n return false;\n }\n return a.column <= b.column;\n }\n /**\n * A function that compares positions, useful for sorting\n */\n static compare(a, b) {\n const aLineNumber = a.lineNumber | 0;\n const bLineNumber = b.lineNumber | 0;\n if (aLineNumber === bLineNumber) {\n const aColumn = a.column | 0;\n const bColumn = b.column | 0;\n return aColumn - bColumn;\n }\n return aLineNumber - bLineNumber;\n }\n /**\n * Clone this position.\n */\n clone() {\n return new Position(this.lineNumber, this.column);\n }\n /**\n * Convert to a human-readable representation.\n */\n toString() {\n return '(' + this.lineNumber + ',' + this.column + ')';\n }\n // ---\n /**\n * Create a `Position` from an `IPosition`.\n */\n static lift(pos) {\n return new Position(pos.lineNumber, pos.column);\n }\n /**\n * Test if `obj` is an `IPosition`.\n */\n static isIPosition(obj) {\n return (obj\n && (typeof obj.lineNumber === 'number')\n && (typeof obj.column === 'number'));\n }\n toJSON() {\n return {\n lineNumber: this.lineNumber,\n column: this.column\n };\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\n/**\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\n */\nexport class Range {\n constructor(startLineNumber, startColumn, endLineNumber, endColumn) {\n if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\n this.startLineNumber = endLineNumber;\n this.startColumn = endColumn;\n this.endLineNumber = startLineNumber;\n this.endColumn = startColumn;\n }\n else {\n this.startLineNumber = startLineNumber;\n this.startColumn = startColumn;\n this.endLineNumber = endLineNumber;\n this.endColumn = endColumn;\n }\n }\n /**\n * Test if this range is empty.\n */\n isEmpty() {\n return Range.isEmpty(this);\n }\n /**\n * Test if `range` is empty.\n */\n static isEmpty(range) {\n return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\n }\n /**\n * Test if position is in this range. If the position is at the edges, will return true.\n */\n containsPosition(position) {\n return Range.containsPosition(this, position);\n }\n /**\n * Test if `position` is in `range`. If the position is at the edges, will return true.\n */\n static containsPosition(range, position) {\n if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n return false;\n }\n if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\n return false;\n }\n if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\n return false;\n }\n return true;\n }\n /**\n * Test if `position` is in `range`. If the position is at the edges, will return false.\n * @internal\n */\n static strictContainsPosition(range, position) {\n if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n return false;\n }\n if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) {\n return false;\n }\n if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {\n return false;\n }\n return true;\n }\n /**\n * Test if range is in this range. If the range is equal to this range, will return true.\n */\n containsRange(range) {\n return Range.containsRange(this, range);\n }\n /**\n * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\n */\n static containsRange(range, otherRange) {\n if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n return false;\n }\n if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n return false;\n }\n if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\n return false;\n }\n if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\n return false;\n }\n return true;\n }\n /**\n * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.\n */\n strictContainsRange(range) {\n return Range.strictContainsRange(this, range);\n }\n /**\n * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.\n */\n static strictContainsRange(range, otherRange) {\n if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n return false;\n }\n if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n return false;\n }\n if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {\n return false;\n }\n if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {\n return false;\n }\n return true;\n }\n /**\n * A reunion of the two ranges.\n * The smallest position will be used as the start point, and the largest one as the end point.\n */\n plusRange(range) {\n return Range.plusRange(this, range);\n }\n /**\n * A reunion of the two ranges.\n * The smallest position will be used as the start point, and the largest one as the end point.\n */\n static plusRange(a, b) {\n let startLineNumber;\n let startColumn;\n let endLineNumber;\n let endColumn;\n if (b.startLineNumber < a.startLineNumber) {\n startLineNumber = b.startLineNumber;\n startColumn = b.startColumn;\n }\n else if (b.startLineNumber === a.startLineNumber) {\n startLineNumber = b.startLineNumber;\n startColumn = Math.min(b.startColumn, a.startColumn);\n }\n else {\n startLineNumber = a.startLineNumber;\n startColumn = a.startColumn;\n }\n if (b.endLineNumber > a.endLineNumber) {\n endLineNumber = b.endLineNumber;\n endColumn = b.endColumn;\n }\n else if (b.endLineNumber === a.endLineNumber) {\n endLineNumber = b.endLineNumber;\n endColumn = Math.max(b.endColumn, a.endColumn);\n }\n else {\n endLineNumber = a.endLineNumber;\n endColumn = a.endColumn;\n }\n return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n }\n /**\n * A intersection of the two ranges.\n */\n intersectRanges(range) {\n return Range.intersectRanges(this, range);\n }\n /**\n * A intersection of the two ranges.\n */\n static intersectRanges(a, b) {\n let resultStartLineNumber = a.startLineNumber;\n let resultStartColumn = a.startColumn;\n let resultEndLineNumber = a.endLineNumber;\n let resultEndColumn = a.endColumn;\n const otherStartLineNumber = b.startLineNumber;\n const otherStartColumn = b.startColumn;\n const otherEndLineNumber = b.endLineNumber;\n const otherEndColumn = b.endColumn;\n if (resultStartLineNumber < otherStartLineNumber) {\n resultStartLineNumber = otherStartLineNumber;\n resultStartColumn = otherStartColumn;\n }\n else if (resultStartLineNumber === otherStartLineNumber) {\n resultStartColumn = Math.max(resultStartColumn, otherStartColumn);\n }\n if (resultEndLineNumber > otherEndLineNumber) {\n resultEndLineNumber = otherEndLineNumber;\n resultEndColumn = otherEndColumn;\n }\n else if (resultEndLineNumber === otherEndLineNumber) {\n resultEndColumn = Math.min(resultEndColumn, otherEndColumn);\n }\n // Check if selection is now empty\n if (resultStartLineNumber > resultEndLineNumber) {\n return null;\n }\n if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\n return null;\n }\n return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\n }\n /**\n * Test if this range equals other.\n */\n equalsRange(other) {\n return Range.equalsRange(this, other);\n }\n /**\n * Test if range `a` equals `b`.\n */\n static equalsRange(a, b) {\n if (!a && !b) {\n return true;\n }\n return (!!a &&\n !!b &&\n a.startLineNumber === b.startLineNumber &&\n a.startColumn === b.startColumn &&\n a.endLineNumber === b.endLineNumber &&\n a.endColumn === b.endColumn);\n }\n /**\n * Return the end position (which will be after or equal to the start position)\n */\n getEndPosition() {\n return Range.getEndPosition(this);\n }\n /**\n * Return the end position (which will be after or equal to the start position)\n */\n static getEndPosition(range) {\n return new Position(range.endLineNumber, range.endColumn);\n }\n /**\n * Return the start position (which will be before or equal to the end position)\n */\n getStartPosition() {\n return Range.getStartPosition(this);\n }\n /**\n * Return the start position (which will be before or equal to the end position)\n */\n static getStartPosition(range) {\n return new Position(range.startLineNumber, range.startColumn);\n }\n /**\n * Transform to a user presentable string representation.\n */\n toString() {\n return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\n }\n /**\n * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\n */\n setEndPosition(endLineNumber, endColumn) {\n return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n }\n /**\n * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\n */\n setStartPosition(startLineNumber, startColumn) {\n return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n }\n /**\n * Create a new empty range using this range's start position.\n */\n collapseToStart() {\n return Range.collapseToStart(this);\n }\n /**\n * Create a new empty range using this range's start position.\n */\n static collapseToStart(range) {\n return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n }\n /**\n * Create a new empty range using this range's end position.\n */\n collapseToEnd() {\n return Range.collapseToEnd(this);\n }\n /**\n * Create a new empty range using this range's end position.\n */\n static collapseToEnd(range) {\n return new Range(range.endLineNumber, range.endColumn, range.endLineNumber, range.endColumn);\n }\n /**\n * Moves the range by the given amount of lines.\n */\n delta(lineCount) {\n return new Range(this.startLineNumber + lineCount, this.startColumn, this.endLineNumber + lineCount, this.endColumn);\n }\n // ---\n static fromPositions(start, end = start) {\n return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n }\n static lift(range) {\n if (!range) {\n return null;\n }\n return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n }\n /**\n * Test if `obj` is an `IRange`.\n */\n static isIRange(obj) {\n return (obj\n && (typeof obj.startLineNumber === 'number')\n && (typeof obj.startColumn === 'number')\n && (typeof obj.endLineNumber === 'number')\n && (typeof obj.endColumn === 'number'));\n }\n /**\n * Test if the two ranges are touching in any way.\n */\n static areIntersectingOrTouching(a, b) {\n // Check if `a` is before `b`\n if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\n return false;\n }\n // Check if `b` is before `a`\n if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\n return false;\n }\n // These ranges must intersect\n return true;\n }\n /**\n * Test if the two ranges are intersecting. If the ranges are touching it returns true.\n */\n static areIntersecting(a, b) {\n // Check if `a` is before `b`\n if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {\n return false;\n }\n // Check if `b` is before `a`\n if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {\n return false;\n }\n // These ranges must intersect\n return true;\n }\n /**\n * A function that compares ranges, useful for sorting ranges\n * It will first compare ranges on the startPosition and then on the endPosition\n */\n static compareRangesUsingStarts(a, b) {\n if (a && b) {\n const aStartLineNumber = a.startLineNumber | 0;\n const bStartLineNumber = b.startLineNumber | 0;\n if (aStartLineNumber === bStartLineNumber) {\n const aStartColumn = a.startColumn | 0;\n const bStartColumn = b.startColumn | 0;\n if (aStartColumn === bStartColumn) {\n const aEndLineNumber = a.endLineNumber | 0;\n const bEndLineNumber = b.endLineNumber | 0;\n if (aEndLineNumber === bEndLineNumber) {\n const aEndColumn = a.endColumn | 0;\n const bEndColumn = b.endColumn | 0;\n return aEndColumn - bEndColumn;\n }\n return aEndLineNumber - bEndLineNumber;\n }\n return aStartColumn - bStartColumn;\n }\n return aStartLineNumber - bStartLineNumber;\n }\n const aExists = (a ? 1 : 0);\n const bExists = (b ? 1 : 0);\n return aExists - bExists;\n }\n /**\n * A function that compares ranges, useful for sorting ranges\n * It will first compare ranges on the endPosition and then on the startPosition\n */\n static compareRangesUsingEnds(a, b) {\n if (a.endLineNumber === b.endLineNumber) {\n if (a.endColumn === b.endColumn) {\n if (a.startLineNumber === b.startLineNumber) {\n return a.startColumn - b.startColumn;\n }\n return a.startLineNumber - b.startLineNumber;\n }\n return a.endColumn - b.endColumn;\n }\n return a.endLineNumber - b.endLineNumber;\n }\n /**\n * Test if the range spans multiple lines.\n */\n static spansMultipleLines(range) {\n return range.endLineNumber > range.startLineNumber;\n }\n toJSON() {\n return this;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\nimport { Range } from './range.js';\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nexport class Selection extends Range {\n constructor(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {\n super(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);\n this.selectionStartLineNumber = selectionStartLineNumber;\n this.selectionStartColumn = selectionStartColumn;\n this.positionLineNumber = positionLineNumber;\n this.positionColumn = positionColumn;\n }\n /**\n * Transform to a human-readable representation.\n */\n toString() {\n return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\n }\n /**\n * Test if equals other selection.\n */\n equalsSelection(other) {\n return (Selection.selectionsEqual(this, other));\n }\n /**\n * Test if the two selections are equal.\n */\n static selectionsEqual(a, b) {\n return (a.selectionStartLineNumber === b.selectionStartLineNumber &&\n a.selectionStartColumn === b.selectionStartColumn &&\n a.positionLineNumber === b.positionLineNumber &&\n a.positionColumn === b.positionColumn);\n }\n /**\n * Get directions (LTR or RTL).\n */\n getDirection() {\n if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\n return 0 /* SelectionDirection.LTR */;\n }\n return 1 /* SelectionDirection.RTL */;\n }\n /**\n * Create a new selection with a different `positionLineNumber` and `positionColumn`.\n */\n setEndPosition(endLineNumber, endColumn) {\n if (this.getDirection() === 0 /* SelectionDirection.LTR */) {\n return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n }\n return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\n }\n /**\n * Get the position at `positionLineNumber` and `positionColumn`.\n */\n getPosition() {\n return new Position(this.positionLineNumber, this.positionColumn);\n }\n /**\n * Get the position at the start of the selection.\n */\n getSelectionStart() {\n return new Position(this.selectionStartLineNumber, this.selectionStartColumn);\n }\n /**\n * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\n */\n setStartPosition(startLineNumber, startColumn) {\n if (this.getDirection() === 0 /* SelectionDirection.LTR */) {\n return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n }\n return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\n }\n // ----\n /**\n * Create a `Selection` from one or two positions\n */\n static fromPositions(start, end = start) {\n return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\n }\n /**\n * Creates a `Selection` from a range, given a direction.\n */\n static fromRange(range, direction) {\n if (direction === 0 /* SelectionDirection.LTR */) {\n return new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n }\n else {\n return new Selection(range.endLineNumber, range.endColumn, range.startLineNumber, range.startColumn);\n }\n }\n /**\n * Create a `Selection` from an `ISelection`.\n */\n static liftSelection(sel) {\n return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\n }\n /**\n * `a` equals `b`.\n */\n static selectionsArrEqual(a, b) {\n if (a && !b || !a && b) {\n return false;\n }\n if (!a && !b) {\n return true;\n }\n if (a.length !== b.length) {\n return false;\n }\n for (let i = 0, len = a.length; i < len; i++) {\n if (!this.selectionsEqual(a[i], b[i])) {\n return false;\n }\n }\n return true;\n }\n /**\n * Test if `obj` is an `ISelection`.\n */\n static isISelection(obj) {\n return (obj\n && (typeof obj.selectionStartLineNumber === 'number')\n && (typeof obj.selectionStartColumn === 'number')\n && (typeof obj.positionLineNumber === 'number')\n && (typeof obj.positionColumn === 'number'));\n }\n /**\n * Create with a direction.\n */\n static createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) {\n if (direction === 0 /* SelectionDirection.LTR */) {\n return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\n }\n return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CharacterClassifier } from './characterClassifier.js';\nexport class WordCharacterClassifier extends CharacterClassifier {\n constructor(wordSeparators) {\n super(0 /* WordCharacterClass.Regular */);\n for (let i = 0, len = wordSeparators.length; i < len; i++) {\n this.set(wordSeparators.charCodeAt(i), 2 /* WordCharacterClass.WordSeparator */);\n }\n this.set(32 /* CharCode.Space */, 1 /* WordCharacterClass.Whitespace */);\n this.set(9 /* CharCode.Tab */, 1 /* WordCharacterClass.Whitespace */);\n }\n}\nfunction once(computeFn) {\n const cache = {}; // TODO@Alex unbounded cache\n return (input) => {\n if (!cache.hasOwnProperty(input)) {\n cache[input] = computeFn(input);\n }\n return cache[input];\n };\n}\nexport const getMapForWordSeparators = once((input) => new WordCharacterClassifier(input));\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Iterable } from '../../../base/common/iterator.js';\nimport { LinkedList } from '../../../base/common/linkedList.js';\nexport const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\n/**\n * Create a word definition regular expression based on default word separators.\n * Optionally provide allowed separators that should be included in words.\n *\n * The default would look like this:\n * /(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)/g\n */\nfunction createWordRegExp(allowInWords = '') {\n let source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\n for (const sep of USUAL_WORD_SEPARATORS) {\n if (allowInWords.indexOf(sep) >= 0) {\n continue;\n }\n source += '\\\\' + sep;\n }\n source += '\\\\s]+)';\n return new RegExp(source, 'g');\n}\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\nexport const DEFAULT_WORD_REGEXP = createWordRegExp();\nexport function ensureValidWordDefinition(wordDefinition) {\n let result = DEFAULT_WORD_REGEXP;\n if (wordDefinition && (wordDefinition instanceof RegExp)) {\n if (!wordDefinition.global) {\n let flags = 'g';\n if (wordDefinition.ignoreCase) {\n flags += 'i';\n }\n if (wordDefinition.multiline) {\n flags += 'm';\n }\n if (wordDefinition.unicode) {\n flags += 'u';\n }\n result = new RegExp(wordDefinition.source, flags);\n }\n else {\n result = wordDefinition;\n }\n }\n result.lastIndex = 0;\n return result;\n}\nconst _defaultConfig = new LinkedList();\n_defaultConfig.unshift({\n maxLen: 1000,\n windowSize: 15,\n timeBudget: 150\n});\nexport function getWordAtText(column, wordDefinition, text, textOffset, config) {\n // Ensure the regex has the 'g' flag, otherwise this will loop forever\n wordDefinition = ensureValidWordDefinition(wordDefinition);\n if (!config) {\n config = Iterable.first(_defaultConfig);\n }\n if (text.length > config.maxLen) {\n // don't throw strings that long at the regexp\n // but use a sub-string in which a word must occur\n let start = column - config.maxLen / 2;\n if (start < 0) {\n start = 0;\n }\n else {\n textOffset += start;\n }\n text = text.substring(start, column + config.maxLen / 2);\n return getWordAtText(column, wordDefinition, text, textOffset, config);\n }\n const t1 = Date.now();\n const pos = column - 1 - textOffset;\n let prevRegexIndex = -1;\n let match = null;\n for (let i = 1;; i++) {\n // check time budget\n if (Date.now() - t1 >= config.timeBudget) {\n break;\n }\n // reset the index at which the regexp should start matching, also know where it\n // should stop so that subsequent search don't repeat previous searches\n const regexIndex = pos - config.windowSize * i;\n wordDefinition.lastIndex = Math.max(0, regexIndex);\n const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);\n if (!thisMatch && match) {\n // stop: we have something\n break;\n }\n match = thisMatch;\n // stop: searched at start\n if (regexIndex <= 0) {\n break;\n }\n prevRegexIndex = regexIndex;\n }\n if (match) {\n const result = {\n word: match[0],\n startColumn: textOffset + 1 + match.index,\n endColumn: textOffset + 1 + match.index + match[0].length\n };\n wordDefinition.lastIndex = 0;\n return result;\n }\n return null;\n}\nfunction _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) {\n let match;\n while (match = wordDefinition.exec(text)) {\n const matchIndex = match.index || 0;\n if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {\n return match;\n }\n else if (stopPos > 0 && matchIndex > stopPos) {\n return null;\n }\n }\n return null;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { forEachAdjacent } from '../../../../../base/common/arrays.js';\nimport { BugIndicatingError } from '../../../../../base/common/errors.js';\nimport { OffsetRange } from '../../../core/offsetRange.js';\nexport class DiffAlgorithmResult {\n static trivial(seq1, seq2) {\n return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], false);\n }\n static trivialTimedOut(seq1, seq2) {\n return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], true);\n }\n constructor(diffs, \n /**\n * Indicates if the time out was reached.\n * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.\n */\n hitTimeout) {\n this.diffs = diffs;\n this.hitTimeout = hitTimeout;\n }\n}\nexport class SequenceDiff {\n static invert(sequenceDiffs, doc1Length) {\n const result = [];\n forEachAdjacent(sequenceDiffs, (a, b) => {\n result.push(SequenceDiff.fromOffsetPairs(a ? a.getEndExclusives() : OffsetPair.zero, b ? b.getStarts() : new OffsetPair(doc1Length, (a ? a.seq2Range.endExclusive - a.seq1Range.endExclusive : 0) + doc1Length)));\n });\n return result;\n }\n static fromOffsetPairs(start, endExclusive) {\n return new SequenceDiff(new OffsetRange(start.offset1, endExclusive.offset1), new OffsetRange(start.offset2, endExclusive.offset2));\n }\n constructor(seq1Range, seq2Range) {\n this.seq1Range = seq1Range;\n this.seq2Range = seq2Range;\n }\n swap() {\n return new SequenceDiff(this.seq2Range, this.seq1Range);\n }\n toString() {\n return `${this.seq1Range} <-> ${this.seq2Range}`;\n }\n join(other) {\n return new SequenceDiff(this.seq1Range.join(other.seq1Range), this.seq2Range.join(other.seq2Range));\n }\n delta(offset) {\n if (offset === 0) {\n return this;\n }\n return new SequenceDiff(this.seq1Range.delta(offset), this.seq2Range.delta(offset));\n }\n deltaStart(offset) {\n if (offset === 0) {\n return this;\n }\n return new SequenceDiff(this.seq1Range.deltaStart(offset), this.seq2Range.deltaStart(offset));\n }\n deltaEnd(offset) {\n if (offset === 0) {\n return this;\n }\n return new SequenceDiff(this.seq1Range.deltaEnd(offset), this.seq2Range.deltaEnd(offset));\n }\n intersect(other) {\n const i1 = this.seq1Range.intersect(other.seq1Range);\n const i2 = this.seq2Range.intersect(other.seq2Range);\n if (!i1 || !i2) {\n return undefined;\n }\n return new SequenceDiff(i1, i2);\n }\n getStarts() {\n return new OffsetPair(this.seq1Range.start, this.seq2Range.start);\n }\n getEndExclusives() {\n return new OffsetPair(this.seq1Range.endExclusive, this.seq2Range.endExclusive);\n }\n}\nexport class OffsetPair {\n constructor(offset1, offset2) {\n this.offset1 = offset1;\n this.offset2 = offset2;\n }\n toString() {\n return `${this.offset1} <-> ${this.offset2}`;\n }\n}\nOffsetPair.zero = new OffsetPair(0, 0);\nOffsetPair.max = new OffsetPair(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);\nexport class InfiniteTimeout {\n isValid() {\n return true;\n }\n}\nInfiniteTimeout.instance = new InfiniteTimeout();\nexport class DateTimeout {\n constructor(timeout) {\n this.timeout = timeout;\n this.startTime = Date.now();\n this.valid = true;\n if (timeout <= 0) {\n throw new BugIndicatingError('timeout must be positive');\n }\n }\n // Recommendation: Set a log-point `{this.disable()}` in the body\n isValid() {\n const valid = Date.now() - this.startTime < this.timeout;\n if (!valid && this.valid) {\n this.valid = false; // timeout reached\n // eslint-disable-next-line no-debugger\n debugger; // WARNING: Most likely debugging caused the timeout. Call `this.disable()` to continue without timing out.\n }\n return this.valid;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { OffsetRange } from '../../../core/offsetRange.js';\nimport { SequenceDiff, InfiniteTimeout, DiffAlgorithmResult } from './diffAlgorithm.js';\nimport { Array2D } from '../utils.js';\n/**\n * A O(MN) diffing algorithm that supports a score function.\n * The algorithm can be improved by processing the 2d array diagonally.\n*/\nexport class DynamicProgrammingDiffing {\n compute(sequence1, sequence2, timeout = InfiniteTimeout.instance, equalityScore) {\n if (sequence1.length === 0 || sequence2.length === 0) {\n return DiffAlgorithmResult.trivial(sequence1, sequence2);\n }\n /**\n * lcsLengths.get(i, j): Length of the longest common subsequence of sequence1.substring(0, i + 1) and sequence2.substring(0, j + 1).\n */\n const lcsLengths = new Array2D(sequence1.length, sequence2.length);\n const directions = new Array2D(sequence1.length, sequence2.length);\n const lengths = new Array2D(sequence1.length, sequence2.length);\n // ==== Initializing lcsLengths ====\n for (let s1 = 0; s1 < sequence1.length; s1++) {\n for (let s2 = 0; s2 < sequence2.length; s2++) {\n if (!timeout.isValid()) {\n return DiffAlgorithmResult.trivialTimedOut(sequence1, sequence2);\n }\n const horizontalLen = s1 === 0 ? 0 : lcsLengths.get(s1 - 1, s2);\n const verticalLen = s2 === 0 ? 0 : lcsLengths.get(s1, s2 - 1);\n let extendedSeqScore;\n if (sequence1.getElement(s1) === sequence2.getElement(s2)) {\n if (s1 === 0 || s2 === 0) {\n extendedSeqScore = 0;\n }\n else {\n extendedSeqScore = lcsLengths.get(s1 - 1, s2 - 1);\n }\n if (s1 > 0 && s2 > 0 && directions.get(s1 - 1, s2 - 1) === 3) {\n // Prefer consecutive diagonals\n extendedSeqScore += lengths.get(s1 - 1, s2 - 1);\n }\n extendedSeqScore += (equalityScore ? equalityScore(s1, s2) : 1);\n }\n else {\n extendedSeqScore = -1;\n }\n const newValue = Math.max(horizontalLen, verticalLen, extendedSeqScore);\n if (newValue === extendedSeqScore) {\n // Prefer diagonals\n const prevLen = s1 > 0 && s2 > 0 ? lengths.get(s1 - 1, s2 - 1) : 0;\n lengths.set(s1, s2, prevLen + 1);\n directions.set(s1, s2, 3);\n }\n else if (newValue === horizontalLen) {\n lengths.set(s1, s2, 0);\n directions.set(s1, s2, 1);\n }\n else if (newValue === verticalLen) {\n lengths.set(s1, s2, 0);\n directions.set(s1, s2, 2);\n }\n lcsLengths.set(s1, s2, newValue);\n }\n }\n // ==== Backtracking ====\n const result = [];\n let lastAligningPosS1 = sequence1.length;\n let lastAligningPosS2 = sequence2.length;\n function reportDecreasingAligningPositions(s1, s2) {\n if (s1 + 1 !== lastAligningPosS1 || s2 + 1 !== lastAligningPosS2) {\n result.push(new SequenceDiff(new OffsetRange(s1 + 1, lastAligningPosS1), new OffsetRange(s2 + 1, lastAligningPosS2)));\n }\n lastAligningPosS1 = s1;\n lastAligningPosS2 = s2;\n }\n let s1 = sequence1.length - 1;\n let s2 = sequence2.length - 1;\n while (s1 >= 0 && s2 >= 0) {\n if (directions.get(s1, s2) === 3) {\n reportDecreasingAligningPositions(s1, s2);\n s1--;\n s2--;\n }\n else {\n if (directions.get(s1, s2) === 1) {\n s1--;\n }\n else {\n s2--;\n }\n }\n }\n reportDecreasingAligningPositions(-1, -1);\n result.reverse();\n return new DiffAlgorithmResult(result, false);\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { OffsetRange } from '../../../core/offsetRange.js';\nimport { DiffAlgorithmResult, InfiniteTimeout, SequenceDiff } from './diffAlgorithm.js';\n/**\n * An O(ND) diff algorithm that has a quadratic space worst-case complexity.\n*/\nexport class MyersDiffAlgorithm {\n compute(seq1, seq2, timeout = InfiniteTimeout.instance) {\n // These are common special cases.\n // The early return improves performance dramatically.\n if (seq1.length === 0 || seq2.length === 0) {\n return DiffAlgorithmResult.trivial(seq1, seq2);\n }\n const seqX = seq1; // Text on the x axis\n const seqY = seq2; // Text on the y axis\n function getXAfterSnake(x, y) {\n while (x < seqX.length && y < seqY.length && seqX.getElement(x) === seqY.getElement(y)) {\n x++;\n y++;\n }\n return x;\n }\n let d = 0;\n // V[k]: X value of longest d-line that ends in diagonal k.\n // d-line: path from (0,0) to (x,y) that uses exactly d non-diagonals.\n // diagonal k: Set of points (x,y) with x-y = k.\n // k=1 -> (1,0),(2,1)\n const V = new FastInt32Array();\n V.set(0, getXAfterSnake(0, 0));\n const paths = new FastArrayNegativeIndices();\n paths.set(0, V.get(0) === 0 ? null : new SnakePath(null, 0, 0, V.get(0)));\n let k = 0;\n loop: while (true) {\n d++;\n if (!timeout.isValid()) {\n return DiffAlgorithmResult.trivialTimedOut(seqX, seqY);\n }\n // The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result.\n const lowerBound = -Math.min(d, seqY.length + (d % 2));\n const upperBound = Math.min(d, seqX.length + (d % 2));\n for (k = lowerBound; k <= upperBound; k += 2) {\n let step = 0;\n // We can use the X values of (d-1)-lines to compute X value of the longest d-lines.\n const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // We take a vertical non-diagonal (add a symbol in seqX)\n const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x) (delete a symbol in seqX)\n step++;\n const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seqX.length);\n const y = x - k;\n step++;\n if (x > seqX.length || y > seqY.length) {\n // This diagonal is irrelevant for the result.\n // TODO: Don't pay the cost for this in the next iteration.\n continue;\n }\n const newMaxX = getXAfterSnake(x, y);\n V.set(k, newMaxX);\n const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1);\n paths.set(k, newMaxX !== x ? new SnakePath(lastPath, x, y, newMaxX - x) : lastPath);\n if (V.get(k) === seqX.length && V.get(k) - k === seqY.length) {\n break loop;\n }\n }\n }\n let path = paths.get(k);\n const result = [];\n let lastAligningPosS1 = seqX.length;\n let lastAligningPosS2 = seqY.length;\n while (true) {\n const endX = path ? path.x + path.length : 0;\n const endY = path ? path.y + path.length : 0;\n if (endX !== lastAligningPosS1 || endY !== lastAligningPosS2) {\n result.push(new SequenceDiff(new OffsetRange(endX, lastAligningPosS1), new OffsetRange(endY, lastAligningPosS2)));\n }\n if (!path) {\n break;\n }\n lastAligningPosS1 = path.x;\n lastAligningPosS2 = path.y;\n path = path.prev;\n }\n result.reverse();\n return new DiffAlgorithmResult(result, false);\n }\n}\nclass SnakePath {\n constructor(prev, x, y, length) {\n this.prev = prev;\n this.x = x;\n this.y = y;\n this.length = length;\n }\n}\n/**\n * An array that supports fast negative indices.\n*/\nclass FastInt32Array {\n constructor() {\n this.positiveArr = new Int32Array(10);\n this.negativeArr = new Int32Array(10);\n }\n get(idx) {\n if (idx < 0) {\n idx = -idx - 1;\n return this.negativeArr[idx];\n }\n else {\n return this.positiveArr[idx];\n }\n }\n set(idx, value) {\n if (idx < 0) {\n idx = -idx - 1;\n if (idx >= this.negativeArr.length) {\n const arr = this.negativeArr;\n this.negativeArr = new Int32Array(arr.length * 2);\n this.negativeArr.set(arr);\n }\n this.negativeArr[idx] = value;\n }\n else {\n if (idx >= this.positiveArr.length) {\n const arr = this.positiveArr;\n this.positiveArr = new Int32Array(arr.length * 2);\n this.positiveArr.set(arr);\n }\n this.positiveArr[idx] = value;\n }\n }\n}\n/**\n * An array that supports fast negative indices.\n*/\nclass FastArrayNegativeIndices {\n constructor() {\n this.positiveArr = [];\n this.negativeArr = [];\n }\n get(idx) {\n if (idx < 0) {\n idx = -idx - 1;\n return this.negativeArr[idx];\n }\n else {\n return this.positiveArr[idx];\n }\n }\n set(idx, value) {\n if (idx < 0) {\n idx = -idx - 1;\n this.negativeArr[idx] = value;\n }\n else {\n this.positiveArr[idx] = value;\n }\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { SequenceDiff } from './algorithms/diffAlgorithm.js';\nimport { LineRangeMapping } from '../rangeMapping.js';\nimport { pushMany, compareBy, numberComparator, reverseOrder } from '../../../../base/common/arrays.js';\nimport { MonotonousArray, findLastMonotonous } from '../../../../base/common/arraysFind.js';\nimport { SetMap } from '../../../../base/common/map.js';\nimport { LineRange, LineRangeSet } from '../../core/lineRange.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { LinesSliceCharSequence } from './linesSliceCharSequence.js';\nimport { LineRangeFragment, isSpace } from './utils.js';\nimport { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';\nexport function computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout) {\n let { moves, excludedChanges } = computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout);\n if (!timeout.isValid()) {\n return [];\n }\n const filteredChanges = changes.filter(c => !excludedChanges.has(c));\n const unchangedMoves = computeUnchangedMoves(filteredChanges, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout);\n pushMany(moves, unchangedMoves);\n moves = joinCloseConsecutiveMoves(moves);\n // Ignore too short moves\n moves = moves.filter(current => {\n const lines = current.original.toOffsetRange().slice(originalLines).map(l => l.trim());\n const originalText = lines.join('\\n');\n return originalText.length >= 15 && countWhere(lines, l => l.length >= 2) >= 2;\n });\n moves = removeMovesInSameDiff(changes, moves);\n return moves;\n}\nfunction countWhere(arr, predicate) {\n let count = 0;\n for (const t of arr) {\n if (predicate(t)) {\n count++;\n }\n }\n return count;\n}\nfunction computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout) {\n const moves = [];\n const deletions = changes\n .filter(c => c.modified.isEmpty && c.original.length >= 3)\n .map(d => new LineRangeFragment(d.original, originalLines, d));\n const insertions = new Set(changes\n .filter(c => c.original.isEmpty && c.modified.length >= 3)\n .map(d => new LineRangeFragment(d.modified, modifiedLines, d)));\n const excludedChanges = new Set();\n for (const deletion of deletions) {\n let highestSimilarity = -1;\n let best;\n for (const insertion of insertions) {\n const similarity = deletion.computeSimilarity(insertion);\n if (similarity > highestSimilarity) {\n highestSimilarity = similarity;\n best = insertion;\n }\n }\n if (highestSimilarity > 0.90 && best) {\n insertions.delete(best);\n moves.push(new LineRangeMapping(deletion.range, best.range));\n excludedChanges.add(deletion.source);\n excludedChanges.add(best.source);\n }\n if (!timeout.isValid()) {\n return { moves, excludedChanges };\n }\n }\n return { moves, excludedChanges };\n}\nfunction computeUnchangedMoves(changes, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout) {\n const moves = [];\n const original3LineHashes = new SetMap();\n for (const change of changes) {\n for (let i = change.original.startLineNumber; i < change.original.endLineNumberExclusive - 2; i++) {\n const key = `${hashedOriginalLines[i - 1]}:${hashedOriginalLines[i + 1 - 1]}:${hashedOriginalLines[i + 2 - 1]}`;\n original3LineHashes.add(key, { range: new LineRange(i, i + 3) });\n }\n }\n const possibleMappings = [];\n changes.sort(compareBy(c => c.modified.startLineNumber, numberComparator));\n for (const change of changes) {\n let lastMappings = [];\n for (let i = change.modified.startLineNumber; i < change.modified.endLineNumberExclusive - 2; i++) {\n const key = `${hashedModifiedLines[i - 1]}:${hashedModifiedLines[i + 1 - 1]}:${hashedModifiedLines[i + 2 - 1]}`;\n const currentModifiedRange = new LineRange(i, i + 3);\n const nextMappings = [];\n original3LineHashes.forEach(key, ({ range }) => {\n for (const lastMapping of lastMappings) {\n // does this match extend some last match?\n if (lastMapping.originalLineRange.endLineNumberExclusive + 1 === range.endLineNumberExclusive &&\n lastMapping.modifiedLineRange.endLineNumberExclusive + 1 === currentModifiedRange.endLineNumberExclusive) {\n lastMapping.originalLineRange = new LineRange(lastMapping.originalLineRange.startLineNumber, range.endLineNumberExclusive);\n lastMapping.modifiedLineRange = new LineRange(lastMapping.modifiedLineRange.startLineNumber, currentModifiedRange.endLineNumberExclusive);\n nextMappings.push(lastMapping);\n return;\n }\n }\n const mapping = {\n modifiedLineRange: currentModifiedRange,\n originalLineRange: range,\n };\n possibleMappings.push(mapping);\n nextMappings.push(mapping);\n });\n lastMappings = nextMappings;\n }\n if (!timeout.isValid()) {\n return [];\n }\n }\n possibleMappings.sort(reverseOrder(compareBy(m => m.modifiedLineRange.length, numberComparator)));\n const modifiedSet = new LineRangeSet();\n const originalSet = new LineRangeSet();\n for (const mapping of possibleMappings) {\n const diffOrigToMod = mapping.modifiedLineRange.startLineNumber - mapping.originalLineRange.startLineNumber;\n const modifiedSections = modifiedSet.subtractFrom(mapping.modifiedLineRange);\n const originalTranslatedSections = originalSet.subtractFrom(mapping.originalLineRange).getWithDelta(diffOrigToMod);\n const modifiedIntersectedSections = modifiedSections.getIntersection(originalTranslatedSections);\n for (const s of modifiedIntersectedSections.ranges) {\n if (s.length < 3) {\n continue;\n }\n const modifiedLineRange = s;\n const originalLineRange = s.delta(-diffOrigToMod);\n moves.push(new LineRangeMapping(originalLineRange, modifiedLineRange));\n modifiedSet.addRange(modifiedLineRange);\n originalSet.addRange(originalLineRange);\n }\n }\n moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));\n const monotonousChanges = new MonotonousArray(changes);\n for (let i = 0; i < moves.length; i++) {\n const move = moves[i];\n const firstTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber <= move.original.startLineNumber);\n const firstTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber <= move.modified.startLineNumber);\n const linesAbove = Math.max(move.original.startLineNumber - firstTouchingChangeOrig.original.startLineNumber, move.modified.startLineNumber - firstTouchingChangeMod.modified.startLineNumber);\n const lastTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber < move.original.endLineNumberExclusive);\n const lastTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber < move.modified.endLineNumberExclusive);\n const linesBelow = Math.max(lastTouchingChangeOrig.original.endLineNumberExclusive - move.original.endLineNumberExclusive, lastTouchingChangeMod.modified.endLineNumberExclusive - move.modified.endLineNumberExclusive);\n let extendToTop;\n for (extendToTop = 0; extendToTop < linesAbove; extendToTop++) {\n const origLine = move.original.startLineNumber - extendToTop - 1;\n const modLine = move.modified.startLineNumber - extendToTop - 1;\n if (origLine > originalLines.length || modLine > modifiedLines.length) {\n break;\n }\n if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {\n break;\n }\n if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {\n break;\n }\n }\n if (extendToTop > 0) {\n originalSet.addRange(new LineRange(move.original.startLineNumber - extendToTop, move.original.startLineNumber));\n modifiedSet.addRange(new LineRange(move.modified.startLineNumber - extendToTop, move.modified.startLineNumber));\n }\n let extendToBottom;\n for (extendToBottom = 0; extendToBottom < linesBelow; extendToBottom++) {\n const origLine = move.original.endLineNumberExclusive + extendToBottom;\n const modLine = move.modified.endLineNumberExclusive + extendToBottom;\n if (origLine > originalLines.length || modLine > modifiedLines.length) {\n break;\n }\n if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {\n break;\n }\n if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {\n break;\n }\n }\n if (extendToBottom > 0) {\n originalSet.addRange(new LineRange(move.original.endLineNumberExclusive, move.original.endLineNumberExclusive + extendToBottom));\n modifiedSet.addRange(new LineRange(move.modified.endLineNumberExclusive, move.modified.endLineNumberExclusive + extendToBottom));\n }\n if (extendToTop > 0 || extendToBottom > 0) {\n moves[i] = new LineRangeMapping(new LineRange(move.original.startLineNumber - extendToTop, move.original.endLineNumberExclusive + extendToBottom), new LineRange(move.modified.startLineNumber - extendToTop, move.modified.endLineNumberExclusive + extendToBottom));\n }\n }\n return moves;\n}\nfunction areLinesSimilar(line1, line2, timeout) {\n if (line1.trim() === line2.trim()) {\n return true;\n }\n if (line1.length > 300 && line2.length > 300) {\n return false;\n }\n const myersDiffingAlgorithm = new MyersDiffAlgorithm();\n const result = myersDiffingAlgorithm.compute(new LinesSliceCharSequence([line1], new OffsetRange(0, 1), false), new LinesSliceCharSequence([line2], new OffsetRange(0, 1), false), timeout);\n let commonNonSpaceCharCount = 0;\n const inverted = SequenceDiff.invert(result.diffs, line1.length);\n for (const seq of inverted) {\n seq.seq1Range.forEach(idx => {\n if (!isSpace(line1.charCodeAt(idx))) {\n commonNonSpaceCharCount++;\n }\n });\n }\n function countNonWsChars(str) {\n let count = 0;\n for (let i = 0; i < line1.length; i++) {\n if (!isSpace(str.charCodeAt(i))) {\n count++;\n }\n }\n return count;\n }\n const longerLineLength = countNonWsChars(line1.length > line2.length ? line1 : line2);\n const r = commonNonSpaceCharCount / longerLineLength > 0.6 && longerLineLength > 10;\n return r;\n}\nfunction joinCloseConsecutiveMoves(moves) {\n if (moves.length === 0) {\n return moves;\n }\n moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));\n const result = [moves[0]];\n for (let i = 1; i < moves.length; i++) {\n const last = result[result.length - 1];\n const current = moves[i];\n const originalDist = current.original.startLineNumber - last.original.endLineNumberExclusive;\n const modifiedDist = current.modified.startLineNumber - last.modified.endLineNumberExclusive;\n const currentMoveAfterLast = originalDist >= 0 && modifiedDist >= 0;\n if (currentMoveAfterLast && originalDist + modifiedDist <= 2) {\n result[result.length - 1] = last.join(current);\n continue;\n }\n result.push(current);\n }\n return result;\n}\nfunction removeMovesInSameDiff(changes, moves) {\n const changesMonotonous = new MonotonousArray(changes);\n moves = moves.filter(m => {\n const diffBeforeEndOfMoveOriginal = changesMonotonous.findLastMonotonous(c => c.original.startLineNumber < m.original.endLineNumberExclusive)\n || new LineRangeMapping(new LineRange(1, 1), new LineRange(1, 1));\n const diffBeforeEndOfMoveModified = findLastMonotonous(changes, c => c.modified.startLineNumber < m.modified.endLineNumberExclusive);\n const differentDiffs = diffBeforeEndOfMoveOriginal !== diffBeforeEndOfMoveModified;\n return differentDiffs;\n });\n return moves;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { equals, groupAdjacentBy } from '../../../../base/common/arrays.js';\nimport { assertFn, checkAdjacentItems } from '../../../../base/common/assert.js';\nimport { LineRange } from '../../core/lineRange.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { Range } from '../../core/range.js';\nimport { DateTimeout, InfiniteTimeout, SequenceDiff } from './algorithms/diffAlgorithm.js';\nimport { DynamicProgrammingDiffing } from './algorithms/dynamicProgrammingDiffing.js';\nimport { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';\nimport { computeMovedLines } from './computeMovedLines.js';\nimport { extendDiffsToEntireWordIfAppropriate, optimizeSequenceDiffs, removeVeryShortMatchingLinesBetweenDiffs, removeVeryShortMatchingTextBetweenLongDiffs, removeShortMatches } from './heuristicSequenceOptimizations.js';\nimport { LinesDiff, MovedText } from '../linesDiffComputer.js';\nimport { DetailedLineRangeMapping, RangeMapping } from '../rangeMapping.js';\nimport { LinesSliceCharSequence } from './linesSliceCharSequence.js';\nimport { LineSequence } from './lineSequence.js';\nexport class DefaultLinesDiffComputer {\n constructor() {\n this.dynamicProgrammingDiffing = new DynamicProgrammingDiffing();\n this.myersDiffingAlgorithm = new MyersDiffAlgorithm();\n }\n computeDiff(originalLines, modifiedLines, options) {\n if (originalLines.length <= 1 && equals(originalLines, modifiedLines, (a, b) => a === b)) {\n return new LinesDiff([], [], false);\n }\n if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {\n return new LinesDiff([\n new DetailedLineRangeMapping(new LineRange(1, originalLines.length + 1), new LineRange(1, modifiedLines.length + 1), [\n new RangeMapping(new Range(1, 1, originalLines.length, originalLines[0].length + 1), new Range(1, 1, modifiedLines.length, modifiedLines[0].length + 1))\n ])\n ], [], false);\n }\n const timeout = options.maxComputationTimeMs === 0 ? InfiniteTimeout.instance : new DateTimeout(options.maxComputationTimeMs);\n const considerWhitespaceChanges = !options.ignoreTrimWhitespace;\n const perfectHashes = new Map();\n function getOrCreateHash(text) {\n let hash = perfectHashes.get(text);\n if (hash === undefined) {\n hash = perfectHashes.size;\n perfectHashes.set(text, hash);\n }\n return hash;\n }\n const originalLinesHashes = originalLines.map((l) => getOrCreateHash(l.trim()));\n const modifiedLinesHashes = modifiedLines.map((l) => getOrCreateHash(l.trim()));\n const sequence1 = new LineSequence(originalLinesHashes, originalLines);\n const sequence2 = new LineSequence(modifiedLinesHashes, modifiedLines);\n const lineAlignmentResult = (() => {\n if (sequence1.length + sequence2.length < 1700) {\n // Use the improved algorithm for small files\n return this.dynamicProgrammingDiffing.compute(sequence1, sequence2, timeout, (offset1, offset2) => originalLines[offset1] === modifiedLines[offset2]\n ? modifiedLines[offset2].length === 0\n ? 0.1\n : 1 + Math.log(1 + modifiedLines[offset2].length)\n : 0.99);\n }\n return this.myersDiffingAlgorithm.compute(sequence1, sequence2);\n })();\n let lineAlignments = lineAlignmentResult.diffs;\n let hitTimeout = lineAlignmentResult.hitTimeout;\n lineAlignments = optimizeSequenceDiffs(sequence1, sequence2, lineAlignments);\n lineAlignments = removeVeryShortMatchingLinesBetweenDiffs(sequence1, sequence2, lineAlignments);\n const alignments = [];\n const scanForWhitespaceChanges = (equalLinesCount) => {\n if (!considerWhitespaceChanges) {\n return;\n }\n for (let i = 0; i < equalLinesCount; i++) {\n const seq1Offset = seq1LastStart + i;\n const seq2Offset = seq2LastStart + i;\n if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) {\n // This is because of whitespace changes, diff these lines\n const characterDiffs = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(new OffsetRange(seq1Offset, seq1Offset + 1), new OffsetRange(seq2Offset, seq2Offset + 1)), timeout, considerWhitespaceChanges);\n for (const a of characterDiffs.mappings) {\n alignments.push(a);\n }\n if (characterDiffs.hitTimeout) {\n hitTimeout = true;\n }\n }\n }\n };\n let seq1LastStart = 0;\n let seq2LastStart = 0;\n for (const diff of lineAlignments) {\n assertFn(() => diff.seq1Range.start - seq1LastStart === diff.seq2Range.start - seq2LastStart);\n const equalLinesCount = diff.seq1Range.start - seq1LastStart;\n scanForWhitespaceChanges(equalLinesCount);\n seq1LastStart = diff.seq1Range.endExclusive;\n seq2LastStart = diff.seq2Range.endExclusive;\n const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges);\n if (characterDiffs.hitTimeout) {\n hitTimeout = true;\n }\n for (const a of characterDiffs.mappings) {\n alignments.push(a);\n }\n }\n scanForWhitespaceChanges(originalLines.length - seq1LastStart);\n const changes = lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines);\n let moves = [];\n if (options.computeMoves) {\n moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges);\n }\n // Make sure all ranges are valid\n assertFn(() => {\n function validatePosition(pos, lines) {\n if (pos.lineNumber < 1 || pos.lineNumber > lines.length) {\n return false;\n }\n const line = lines[pos.lineNumber - 1];\n if (pos.column < 1 || pos.column > line.length + 1) {\n return false;\n }\n return true;\n }\n function validateRange(range, lines) {\n if (range.startLineNumber < 1 || range.startLineNumber > lines.length + 1) {\n return false;\n }\n if (range.endLineNumberExclusive < 1 || range.endLineNumberExclusive > lines.length + 1) {\n return false;\n }\n return true;\n }\n for (const c of changes) {\n if (!c.innerChanges) {\n return false;\n }\n for (const ic of c.innerChanges) {\n const valid = validatePosition(ic.modifiedRange.getStartPosition(), modifiedLines) && validatePosition(ic.modifiedRange.getEndPosition(), modifiedLines) &&\n validatePosition(ic.originalRange.getStartPosition(), originalLines) && validatePosition(ic.originalRange.getEndPosition(), originalLines);\n if (!valid) {\n return false;\n }\n }\n if (!validateRange(c.modified, modifiedLines) || !validateRange(c.original, originalLines)) {\n return false;\n }\n }\n return true;\n });\n return new LinesDiff(changes, moves, hitTimeout);\n }\n computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges) {\n const moves = computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout);\n const movesWithDiffs = moves.map(m => {\n const moveChanges = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange()), timeout, considerWhitespaceChanges);\n const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, originalLines, modifiedLines, true);\n return new MovedText(m, mappings);\n });\n return movesWithDiffs;\n }\n refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges) {\n const slice1 = new LinesSliceCharSequence(originalLines, diff.seq1Range, considerWhitespaceChanges);\n const slice2 = new LinesSliceCharSequence(modifiedLines, diff.seq2Range, considerWhitespaceChanges);\n const diffResult = slice1.length + slice2.length < 500\n ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout)\n : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);\n let diffs = diffResult.diffs;\n diffs = optimizeSequenceDiffs(slice1, slice2, diffs);\n diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs);\n diffs = removeShortMatches(slice1, slice2, diffs);\n diffs = removeVeryShortMatchingTextBetweenLongDiffs(slice1, slice2, diffs);\n const result = diffs.map((d) => new RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)));\n // Assert: result applied on original should be the same as diff applied to original\n return {\n mappings: result,\n hitTimeout: diffResult.hitTimeout,\n };\n }\n}\nexport function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines, dontAssertStartLine = false) {\n const changes = [];\n for (const g of groupAdjacentBy(alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines)), (a1, a2) => a1.original.overlapOrTouch(a2.original)\n || a1.modified.overlapOrTouch(a2.modified))) {\n const first = g[0];\n const last = g[g.length - 1];\n changes.push(new DetailedLineRangeMapping(first.original.join(last.original), first.modified.join(last.modified), g.map(a => a.innerChanges[0])));\n }\n assertFn(() => {\n if (!dontAssertStartLine) {\n if (changes.length > 0 && changes[0].original.startLineNumber !== changes[0].modified.startLineNumber) {\n return false;\n }\n }\n return checkAdjacentItems(changes, (m1, m2) => m2.original.startLineNumber - m1.original.endLineNumberExclusive === m2.modified.startLineNumber - m1.modified.endLineNumberExclusive &&\n // There has to be an unchanged line in between (otherwise both diffs should have been joined)\n m1.original.endLineNumberExclusive < m2.original.startLineNumber &&\n m1.modified.endLineNumberExclusive < m2.modified.startLineNumber);\n });\n return changes;\n}\nexport function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) {\n let lineStartDelta = 0;\n let lineEndDelta = 0;\n // rangeMapping describes the edit that replaces `rangeMapping.originalRange` with `newText := getText(modifiedLines, rangeMapping.modifiedRange)`.\n // original: ]xxx \\n <- this line is not modified\n // modified: ]xx \\n\n if (rangeMapping.modifiedRange.endColumn === 1 && rangeMapping.originalRange.endColumn === 1\n && rangeMapping.originalRange.startLineNumber + lineStartDelta <= rangeMapping.originalRange.endLineNumber\n && rangeMapping.modifiedRange.startLineNumber + lineStartDelta <= rangeMapping.modifiedRange.endLineNumber) {\n // We can only do this if the range is not empty yet\n lineEndDelta = -1;\n }\n // original: xxx[ \\n <- this line is not modified\n // modified: xxx[ \\n\n if (rangeMapping.modifiedRange.startColumn - 1 >= modifiedLines[rangeMapping.modifiedRange.startLineNumber - 1].length\n && rangeMapping.originalRange.startColumn - 1 >= originalLines[rangeMapping.originalRange.startLineNumber - 1].length\n && rangeMapping.originalRange.startLineNumber <= rangeMapping.originalRange.endLineNumber + lineEndDelta\n && rangeMapping.modifiedRange.startLineNumber <= rangeMapping.modifiedRange.endLineNumber + lineEndDelta) {\n // We can only do this if the range is not empty yet\n lineStartDelta = 1;\n }\n const originalLineRange = new LineRange(rangeMapping.originalRange.startLineNumber + lineStartDelta, rangeMapping.originalRange.endLineNumber + 1 + lineEndDelta);\n const modifiedLineRange = new LineRange(rangeMapping.modifiedRange.startLineNumber + lineStartDelta, rangeMapping.modifiedRange.endLineNumber + 1 + lineEndDelta);\n return new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]);\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { forEachWithNeighbors } from '../../../../base/common/arrays.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { OffsetPair, SequenceDiff } from './algorithms/diffAlgorithm.js';\nexport function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) {\n let result = sequenceDiffs;\n result = joinSequenceDiffsByShifting(sequence1, sequence2, result);\n // Sometimes, calling this function twice improves the result.\n // Uncomment the second invocation and run the tests to see the difference.\n result = joinSequenceDiffsByShifting(sequence1, sequence2, result);\n result = shiftSequenceDiffs(sequence1, sequence2, result);\n return result;\n}\n/**\n * This function fixes issues like this:\n * ```\n * import { Baz, Bar } from \"foo\";\n * ```\n * <->\n * ```\n * import { Baz, Bar, Foo } from \"foo\";\n * ```\n * Computed diff: [ {Add \",\" after Bar}, {Add \"Foo \" after space} }\n * Improved diff: [{Add \", Foo\" after Bar}]\n */\nfunction joinSequenceDiffsByShifting(sequence1, sequence2, sequenceDiffs) {\n if (sequenceDiffs.length === 0) {\n return sequenceDiffs;\n }\n const result = [];\n result.push(sequenceDiffs[0]);\n // First move them all to the left as much as possible and join them if possible\n for (let i = 1; i < sequenceDiffs.length; i++) {\n const prevResult = result[result.length - 1];\n let cur = sequenceDiffs[i];\n if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {\n const length = cur.seq1Range.start - prevResult.seq1Range.endExclusive;\n let d;\n for (d = 1; d <= length; d++) {\n if (sequence1.getElement(cur.seq1Range.start - d) !== sequence1.getElement(cur.seq1Range.endExclusive - d) ||\n sequence2.getElement(cur.seq2Range.start - d) !== sequence2.getElement(cur.seq2Range.endExclusive - d)) {\n break;\n }\n }\n d--;\n if (d === length) {\n // Merge previous and current diff\n result[result.length - 1] = new SequenceDiff(new OffsetRange(prevResult.seq1Range.start, cur.seq1Range.endExclusive - length), new OffsetRange(prevResult.seq2Range.start, cur.seq2Range.endExclusive - length));\n continue;\n }\n cur = cur.delta(-d);\n }\n result.push(cur);\n }\n const result2 = [];\n // Then move them all to the right and join them again if possible\n for (let i = 0; i < result.length - 1; i++) {\n const nextResult = result[i + 1];\n let cur = result[i];\n if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {\n const length = nextResult.seq1Range.start - cur.seq1Range.endExclusive;\n let d;\n for (d = 0; d < length; d++) {\n if (!sequence1.isStronglyEqual(cur.seq1Range.start + d, cur.seq1Range.endExclusive + d) ||\n !sequence2.isStronglyEqual(cur.seq2Range.start + d, cur.seq2Range.endExclusive + d)) {\n break;\n }\n }\n if (d === length) {\n // Merge previous and current diff, write to result!\n result[i + 1] = new SequenceDiff(new OffsetRange(cur.seq1Range.start + length, nextResult.seq1Range.endExclusive), new OffsetRange(cur.seq2Range.start + length, nextResult.seq2Range.endExclusive));\n continue;\n }\n if (d > 0) {\n cur = cur.delta(d);\n }\n }\n result2.push(cur);\n }\n if (result.length > 0) {\n result2.push(result[result.length - 1]);\n }\n return result2;\n}\n// align character level diffs at whitespace characters\n// import { IBar } from \"foo\";\n// import { I[Arr, I]Bar } from \"foo\";\n// ->\n// import { [IArr, ]IBar } from \"foo\";\n// import { ITransaction, observableValue, transaction } from 'vs/base/common/observable';\n// import { ITransaction, observable[FromEvent, observable]Value, transaction } from 'vs/base/common/observable';\n// ->\n// import { ITransaction, [observableFromEvent, ]observableValue, transaction } from 'vs/base/common/observable';\n// collectBrackets(level + 1, levelPerBracketType);\n// collectBrackets(level + 1, levelPerBracket[ + 1, levelPerBracket]Type);\n// ->\n// collectBrackets(level + 1, [levelPerBracket + 1, ]levelPerBracketType);\nfunction shiftSequenceDiffs(sequence1, sequence2, sequenceDiffs) {\n if (!sequence1.getBoundaryScore || !sequence2.getBoundaryScore) {\n return sequenceDiffs;\n }\n for (let i = 0; i < sequenceDiffs.length; i++) {\n const prevDiff = (i > 0 ? sequenceDiffs[i - 1] : undefined);\n const diff = sequenceDiffs[i];\n const nextDiff = (i + 1 < sequenceDiffs.length ? sequenceDiffs[i + 1] : undefined);\n const seq1ValidRange = new OffsetRange(prevDiff ? prevDiff.seq1Range.start + 1 : 0, nextDiff ? nextDiff.seq1Range.endExclusive - 1 : sequence1.length);\n const seq2ValidRange = new OffsetRange(prevDiff ? prevDiff.seq2Range.start + 1 : 0, nextDiff ? nextDiff.seq2Range.endExclusive - 1 : sequence2.length);\n if (diff.seq1Range.isEmpty) {\n sequenceDiffs[i] = shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange);\n }\n else if (diff.seq2Range.isEmpty) {\n sequenceDiffs[i] = shiftDiffToBetterPosition(diff.swap(), sequence2, sequence1, seq2ValidRange, seq1ValidRange).swap();\n }\n }\n return sequenceDiffs;\n}\nfunction shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange) {\n const maxShiftLimit = 100; // To prevent performance issues\n // don't touch previous or next!\n let deltaBefore = 1;\n while (diff.seq1Range.start - deltaBefore >= seq1ValidRange.start &&\n diff.seq2Range.start - deltaBefore >= seq2ValidRange.start &&\n sequence2.isStronglyEqual(diff.seq2Range.start - deltaBefore, diff.seq2Range.endExclusive - deltaBefore) && deltaBefore < maxShiftLimit) {\n deltaBefore++;\n }\n deltaBefore--;\n let deltaAfter = 0;\n while (diff.seq1Range.start + deltaAfter < seq1ValidRange.endExclusive &&\n diff.seq2Range.endExclusive + deltaAfter < seq2ValidRange.endExclusive &&\n sequence2.isStronglyEqual(diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter) && deltaAfter < maxShiftLimit) {\n deltaAfter++;\n }\n if (deltaBefore === 0 && deltaAfter === 0) {\n return diff;\n }\n // Visualize `[sequence1.text, diff.seq1Range.start + deltaAfter]`\n // and `[sequence2.text, diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter]`\n let bestDelta = 0;\n let bestScore = -1;\n // find best scored delta\n for (let delta = -deltaBefore; delta <= deltaAfter; delta++) {\n const seq2OffsetStart = diff.seq2Range.start + delta;\n const seq2OffsetEndExclusive = diff.seq2Range.endExclusive + delta;\n const seq1Offset = diff.seq1Range.start + delta;\n const score = sequence1.getBoundaryScore(seq1Offset) + sequence2.getBoundaryScore(seq2OffsetStart) + sequence2.getBoundaryScore(seq2OffsetEndExclusive);\n if (score > bestScore) {\n bestScore = score;\n bestDelta = delta;\n }\n }\n return diff.delta(bestDelta);\n}\nexport function removeShortMatches(sequence1, sequence2, sequenceDiffs) {\n const result = [];\n for (const s of sequenceDiffs) {\n const last = result[result.length - 1];\n if (!last) {\n result.push(s);\n continue;\n }\n if (s.seq1Range.start - last.seq1Range.endExclusive <= 2 || s.seq2Range.start - last.seq2Range.endExclusive <= 2) {\n result[result.length - 1] = new SequenceDiff(last.seq1Range.join(s.seq1Range), last.seq2Range.join(s.seq2Range));\n }\n else {\n result.push(s);\n }\n }\n return result;\n}\nexport function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs) {\n const additional = [];\n let lastModifiedWord = undefined;\n function maybePushWordToAdditional() {\n if (!lastModifiedWord) {\n return;\n }\n const originalLength1 = lastModifiedWord.s1Range.length - lastModifiedWord.deleted;\n const originalLength2 = lastModifiedWord.s2Range.length - lastModifiedWord.added;\n if (originalLength1 !== originalLength2) {\n // TODO figure out why this happens\n }\n if (Math.max(lastModifiedWord.deleted, lastModifiedWord.added) + (lastModifiedWord.count - 1) > originalLength1) {\n additional.push(new SequenceDiff(lastModifiedWord.s1Range, lastModifiedWord.s2Range));\n }\n lastModifiedWord = undefined;\n }\n for (const s of sequenceDiffs) {\n function processWord(s1Range, s2Range) {\n var _a, _b, _c, _d;\n if (!lastModifiedWord || !lastModifiedWord.s1Range.containsRange(s1Range) || !lastModifiedWord.s2Range.containsRange(s2Range)) {\n if (lastModifiedWord && !(lastModifiedWord.s1Range.endExclusive < s1Range.start && lastModifiedWord.s2Range.endExclusive < s2Range.start)) {\n const s1Added = OffsetRange.tryCreate(lastModifiedWord.s1Range.endExclusive, s1Range.start);\n const s2Added = OffsetRange.tryCreate(lastModifiedWord.s2Range.endExclusive, s2Range.start);\n lastModifiedWord.deleted += (_a = s1Added === null || s1Added === void 0 ? void 0 : s1Added.length) !== null && _a !== void 0 ? _a : 0;\n lastModifiedWord.added += (_b = s2Added === null || s2Added === void 0 ? void 0 : s2Added.length) !== null && _b !== void 0 ? _b : 0;\n lastModifiedWord.s1Range = lastModifiedWord.s1Range.join(s1Range);\n lastModifiedWord.s2Range = lastModifiedWord.s2Range.join(s2Range);\n }\n else {\n maybePushWordToAdditional();\n lastModifiedWord = { added: 0, deleted: 0, count: 0, s1Range: s1Range, s2Range: s2Range };\n }\n }\n const changedS1 = s1Range.intersect(s.seq1Range);\n const changedS2 = s2Range.intersect(s.seq2Range);\n lastModifiedWord.count++;\n lastModifiedWord.deleted += (_c = changedS1 === null || changedS1 === void 0 ? void 0 : changedS1.length) !== null && _c !== void 0 ? _c : 0;\n lastModifiedWord.added += (_d = changedS2 === null || changedS2 === void 0 ? void 0 : changedS2.length) !== null && _d !== void 0 ? _d : 0;\n }\n const w1Before = sequence1.findWordContaining(s.seq1Range.start - 1);\n const w2Before = sequence2.findWordContaining(s.seq2Range.start - 1);\n const w1After = sequence1.findWordContaining(s.seq1Range.endExclusive);\n const w2After = sequence2.findWordContaining(s.seq2Range.endExclusive);\n if (w1Before && w1After && w2Before && w2After && w1Before.equals(w1After) && w2Before.equals(w2After)) {\n processWord(w1Before, w2Before);\n }\n else {\n if (w1Before && w2Before) {\n processWord(w1Before, w2Before);\n }\n if (w1After && w2After) {\n processWord(w1After, w2After);\n }\n }\n }\n maybePushWordToAdditional();\n const merged = mergeSequenceDiffs(sequenceDiffs, additional);\n return merged;\n}\nfunction mergeSequenceDiffs(sequenceDiffs1, sequenceDiffs2) {\n const result = [];\n while (sequenceDiffs1.length > 0 || sequenceDiffs2.length > 0) {\n const sd1 = sequenceDiffs1[0];\n const sd2 = sequenceDiffs2[0];\n let next;\n if (sd1 && (!sd2 || sd1.seq1Range.start < sd2.seq1Range.start)) {\n next = sequenceDiffs1.shift();\n }\n else {\n next = sequenceDiffs2.shift();\n }\n if (result.length > 0 && result[result.length - 1].seq1Range.endExclusive >= next.seq1Range.start) {\n result[result.length - 1] = result[result.length - 1].join(next);\n }\n else {\n result.push(next);\n }\n }\n return result;\n}\nexport function removeVeryShortMatchingLinesBetweenDiffs(sequence1, _sequence2, sequenceDiffs) {\n let diffs = sequenceDiffs;\n if (diffs.length === 0) {\n return diffs;\n }\n let counter = 0;\n let shouldRepeat;\n do {\n shouldRepeat = false;\n const result = [\n diffs[0]\n ];\n for (let i = 1; i < diffs.length; i++) {\n const cur = diffs[i];\n const lastResult = result[result.length - 1];\n function shouldJoinDiffs(before, after) {\n const unchangedRange = new OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);\n const unchangedText = sequence1.getText(unchangedRange);\n const unchangedTextWithoutWs = unchangedText.replace(/\\s/g, '');\n if (unchangedTextWithoutWs.length <= 4\n && (before.seq1Range.length + before.seq2Range.length > 5 || after.seq1Range.length + after.seq2Range.length > 5)) {\n return true;\n }\n return false;\n }\n const shouldJoin = shouldJoinDiffs(lastResult, cur);\n if (shouldJoin) {\n shouldRepeat = true;\n result[result.length - 1] = result[result.length - 1].join(cur);\n }\n else {\n result.push(cur);\n }\n }\n diffs = result;\n } while (counter++ < 10 && shouldRepeat);\n return diffs;\n}\nexport function removeVeryShortMatchingTextBetweenLongDiffs(sequence1, sequence2, sequenceDiffs) {\n let diffs = sequenceDiffs;\n if (diffs.length === 0) {\n return diffs;\n }\n let counter = 0;\n let shouldRepeat;\n do {\n shouldRepeat = false;\n const result = [\n diffs[0]\n ];\n for (let i = 1; i < diffs.length; i++) {\n const cur = diffs[i];\n const lastResult = result[result.length - 1];\n function shouldJoinDiffs(before, after) {\n const unchangedRange = new OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);\n const unchangedLineCount = sequence1.countLinesIn(unchangedRange);\n if (unchangedLineCount > 5 || unchangedRange.length > 500) {\n return false;\n }\n const unchangedText = sequence1.getText(unchangedRange).trim();\n if (unchangedText.length > 20 || unchangedText.split(/\\r\\n|\\r|\\n/).length > 1) {\n return false;\n }\n const beforeLineCount1 = sequence1.countLinesIn(before.seq1Range);\n const beforeSeq1Length = before.seq1Range.length;\n const beforeLineCount2 = sequence2.countLinesIn(before.seq2Range);\n const beforeSeq2Length = before.seq2Range.length;\n const afterLineCount1 = sequence1.countLinesIn(after.seq1Range);\n const afterSeq1Length = after.seq1Range.length;\n const afterLineCount2 = sequence2.countLinesIn(after.seq2Range);\n const afterSeq2Length = after.seq2Range.length;\n // TODO: Maybe a neural net can be used to derive the result from these numbers\n const max = 2 * 40 + 50;\n function cap(v) {\n return Math.min(v, max);\n }\n if (Math.pow(Math.pow(cap(beforeLineCount1 * 40 + beforeSeq1Length), 1.5) + Math.pow(cap(beforeLineCount2 * 40 + beforeSeq2Length), 1.5), 1.5)\n + Math.pow(Math.pow(cap(afterLineCount1 * 40 + afterSeq1Length), 1.5) + Math.pow(cap(afterLineCount2 * 40 + afterSeq2Length), 1.5), 1.5) > ((max ** 1.5) ** 1.5) * 1.3) {\n return true;\n }\n return false;\n }\n const shouldJoin = shouldJoinDiffs(lastResult, cur);\n if (shouldJoin) {\n shouldRepeat = true;\n result[result.length - 1] = result[result.length - 1].join(cur);\n }\n else {\n result.push(cur);\n }\n }\n diffs = result;\n } while (counter++ < 10 && shouldRepeat);\n const newDiffs = [];\n // Remove short suffixes/prefixes\n forEachWithNeighbors(diffs, (prev, cur, next) => {\n let newDiff = cur;\n function shouldMarkAsChanged(text) {\n return text.length > 0 && text.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100;\n }\n const fullRange1 = sequence1.extendToFullLines(cur.seq1Range);\n const prefix = sequence1.getText(new OffsetRange(fullRange1.start, cur.seq1Range.start));\n if (shouldMarkAsChanged(prefix)) {\n newDiff = newDiff.deltaStart(-prefix.length);\n }\n const suffix = sequence1.getText(new OffsetRange(cur.seq1Range.endExclusive, fullRange1.endExclusive));\n if (shouldMarkAsChanged(suffix)) {\n newDiff = newDiff.deltaEnd(suffix.length);\n }\n const availableSpace = SequenceDiff.fromOffsetPairs(prev ? prev.getEndExclusives() : OffsetPair.zero, next ? next.getStarts() : OffsetPair.max);\n const result = newDiff.intersect(availableSpace);\n newDiffs.push(result);\n });\n return newDiffs;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class LineSequence {\n constructor(trimmedHash, lines) {\n this.trimmedHash = trimmedHash;\n this.lines = lines;\n }\n getElement(offset) {\n return this.trimmedHash[offset];\n }\n get length() {\n return this.trimmedHash.length;\n }\n getBoundaryScore(length) {\n const indentationBefore = length === 0 ? 0 : getIndentation(this.lines[length - 1]);\n const indentationAfter = length === this.lines.length ? 0 : getIndentation(this.lines[length]);\n return 1000 - (indentationBefore + indentationAfter);\n }\n getText(range) {\n return this.lines.slice(range.start, range.endExclusive).join('\\n');\n }\n isStronglyEqual(offset1, offset2) {\n return this.lines[offset1] === this.lines[offset2];\n }\n}\nfunction getIndentation(str) {\n let i = 0;\n while (i < str.length && (str.charCodeAt(i) === 32 /* CharCode.Space */ || str.charCodeAt(i) === 9 /* CharCode.Tab */)) {\n i++;\n }\n return i;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { findLastIdxMonotonous, findLastMonotonous, findFirstMonotonous } from '../../../../base/common/arraysFind.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { Position } from '../../core/position.js';\nimport { Range } from '../../core/range.js';\nimport { isSpace } from './utils.js';\nexport class LinesSliceCharSequence {\n constructor(lines, lineRange, considerWhitespaceChanges) {\n // This slice has to have lineRange.length many \\n! (otherwise diffing against an empty slice will be problematic)\n // (Unless it covers the entire document, in that case the other slice also has to cover the entire document ands it's okay)\n this.lines = lines;\n this.considerWhitespaceChanges = considerWhitespaceChanges;\n this.elements = [];\n this.firstCharOffsetByLine = [];\n // To account for trimming\n this.additionalOffsetByLine = [];\n // If the slice covers the end, but does not start at the beginning, we include just the \\n of the previous line.\n let trimFirstLineFully = false;\n if (lineRange.start > 0 && lineRange.endExclusive >= lines.length) {\n lineRange = new OffsetRange(lineRange.start - 1, lineRange.endExclusive);\n trimFirstLineFully = true;\n }\n this.lineRange = lineRange;\n this.firstCharOffsetByLine[0] = 0;\n for (let i = this.lineRange.start; i < this.lineRange.endExclusive; i++) {\n let line = lines[i];\n let offset = 0;\n if (trimFirstLineFully) {\n offset = line.length;\n line = '';\n trimFirstLineFully = false;\n }\n else if (!considerWhitespaceChanges) {\n const trimmedStartLine = line.trimStart();\n offset = line.length - trimmedStartLine.length;\n line = trimmedStartLine.trimEnd();\n }\n this.additionalOffsetByLine.push(offset);\n for (let i = 0; i < line.length; i++) {\n this.elements.push(line.charCodeAt(i));\n }\n // Don't add an \\n that does not exist in the document.\n if (i < lines.length - 1) {\n this.elements.push('\\n'.charCodeAt(0));\n this.firstCharOffsetByLine[i - this.lineRange.start + 1] = this.elements.length;\n }\n }\n // To account for the last line\n this.additionalOffsetByLine.push(0);\n }\n toString() {\n return `Slice: \"${this.text}\"`;\n }\n get text() {\n return this.getText(new OffsetRange(0, this.length));\n }\n getText(range) {\n return this.elements.slice(range.start, range.endExclusive).map(e => String.fromCharCode(e)).join('');\n }\n getElement(offset) {\n return this.elements[offset];\n }\n get length() {\n return this.elements.length;\n }\n getBoundaryScore(length) {\n // a b c , d e f\n // 11 0 0 12 15 6 13 0 0 11\n const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1);\n const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1);\n if (prevCategory === 7 /* CharBoundaryCategory.LineBreakCR */ && nextCategory === 8 /* CharBoundaryCategory.LineBreakLF */) {\n // don't break between \\r and \\n\n return 0;\n }\n let score = 0;\n if (prevCategory !== nextCategory) {\n score += 10;\n if (prevCategory === 0 /* CharBoundaryCategory.WordLower */ && nextCategory === 1 /* CharBoundaryCategory.WordUpper */) {\n score += 1;\n }\n }\n score += getCategoryBoundaryScore(prevCategory);\n score += getCategoryBoundaryScore(nextCategory);\n return score;\n }\n translateOffset(offset) {\n // find smallest i, so that lineBreakOffsets[i] <= offset using binary search\n if (this.lineRange.isEmpty) {\n return new Position(this.lineRange.start + 1, 1);\n }\n const i = findLastIdxMonotonous(this.firstCharOffsetByLine, (value) => value <= offset);\n return new Position(this.lineRange.start + i + 1, offset - this.firstCharOffsetByLine[i] + this.additionalOffsetByLine[i] + 1);\n }\n translateRange(range) {\n return Range.fromPositions(this.translateOffset(range.start), this.translateOffset(range.endExclusive));\n }\n /**\n * Finds the word that contains the character at the given offset\n */\n findWordContaining(offset) {\n if (offset < 0 || offset >= this.elements.length) {\n return undefined;\n }\n if (!isWordChar(this.elements[offset])) {\n return undefined;\n }\n // find start\n let start = offset;\n while (start > 0 && isWordChar(this.elements[start - 1])) {\n start--;\n }\n // find end\n let end = offset;\n while (end < this.elements.length && isWordChar(this.elements[end])) {\n end++;\n }\n return new OffsetRange(start, end);\n }\n countLinesIn(range) {\n return this.translateOffset(range.endExclusive).lineNumber - this.translateOffset(range.start).lineNumber;\n }\n isStronglyEqual(offset1, offset2) {\n return this.elements[offset1] === this.elements[offset2];\n }\n extendToFullLines(range) {\n var _a, _b;\n const start = (_a = findLastMonotonous(this.firstCharOffsetByLine, x => x <= range.start)) !== null && _a !== void 0 ? _a : 0;\n const end = (_b = findFirstMonotonous(this.firstCharOffsetByLine, x => range.endExclusive <= x)) !== null && _b !== void 0 ? _b : this.elements.length;\n return new OffsetRange(start, end);\n }\n}\nfunction isWordChar(charCode) {\n return charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */\n || charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */\n || charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */;\n}\nconst score = {\n [0 /* CharBoundaryCategory.WordLower */]: 0,\n [1 /* CharBoundaryCategory.WordUpper */]: 0,\n [2 /* CharBoundaryCategory.WordNumber */]: 0,\n [3 /* CharBoundaryCategory.End */]: 10,\n [4 /* CharBoundaryCategory.Other */]: 2,\n [5 /* CharBoundaryCategory.Separator */]: 3,\n [6 /* CharBoundaryCategory.Space */]: 3,\n [7 /* CharBoundaryCategory.LineBreakCR */]: 10,\n [8 /* CharBoundaryCategory.LineBreakLF */]: 10,\n};\nfunction getCategoryBoundaryScore(category) {\n return score[category];\n}\nfunction getCategory(charCode) {\n if (charCode === 10 /* CharCode.LineFeed */) {\n return 8 /* CharBoundaryCategory.LineBreakLF */;\n }\n else if (charCode === 13 /* CharCode.CarriageReturn */) {\n return 7 /* CharBoundaryCategory.LineBreakCR */;\n }\n else if (isSpace(charCode)) {\n return 6 /* CharBoundaryCategory.Space */;\n }\n else if (charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */) {\n return 0 /* CharBoundaryCategory.WordLower */;\n }\n else if (charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */) {\n return 1 /* CharBoundaryCategory.WordUpper */;\n }\n else if (charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */) {\n return 2 /* CharBoundaryCategory.WordNumber */;\n }\n else if (charCode === -1) {\n return 3 /* CharBoundaryCategory.End */;\n }\n else if (charCode === 44 /* CharCode.Comma */ || charCode === 59 /* CharCode.Semicolon */) {\n return 5 /* CharBoundaryCategory.Separator */;\n }\n else {\n return 4 /* CharBoundaryCategory.Other */;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class Array2D {\n constructor(width, height) {\n this.width = width;\n this.height = height;\n this.array = [];\n this.array = new Array(width * height);\n }\n get(x, y) {\n return this.array[x + y * this.width];\n }\n set(x, y, value) {\n this.array[x + y * this.width] = value;\n }\n}\nexport function isSpace(charCode) {\n return charCode === 32 /* CharCode.Space */ || charCode === 9 /* CharCode.Tab */;\n}\nexport class LineRangeFragment {\n static getKey(chr) {\n let key = this.chrKeys.get(chr);\n if (key === undefined) {\n key = this.chrKeys.size;\n this.chrKeys.set(chr, key);\n }\n return key;\n }\n constructor(range, lines, source) {\n this.range = range;\n this.lines = lines;\n this.source = source;\n this.histogram = [];\n let counter = 0;\n for (let i = range.startLineNumber - 1; i < range.endLineNumberExclusive - 1; i++) {\n const line = lines[i];\n for (let j = 0; j < line.length; j++) {\n counter++;\n const chr = line[j];\n const key = LineRangeFragment.getKey(chr);\n this.histogram[key] = (this.histogram[key] || 0) + 1;\n }\n counter++;\n const key = LineRangeFragment.getKey('\\n');\n this.histogram[key] = (this.histogram[key] || 0) + 1;\n }\n this.totalCount = counter;\n }\n computeSimilarity(other) {\n var _a, _b;\n let sumDifferences = 0;\n const maxLength = Math.max(this.histogram.length, other.histogram.length);\n for (let i = 0; i < maxLength; i++) {\n sumDifferences += Math.abs(((_a = this.histogram[i]) !== null && _a !== void 0 ? _a : 0) - ((_b = other.histogram[i]) !== null && _b !== void 0 ? _b : 0));\n }\n return 1 - (sumDifferences / (this.totalCount + other.totalCount));\n }\n}\nLineRangeFragment.chrKeys = new Map();\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { LcsDiff } from '../../../base/common/diff/diff.js';\nimport { LinesDiff } from './linesDiffComputer.js';\nimport { RangeMapping, DetailedLineRangeMapping } from './rangeMapping.js';\nimport * as strings from '../../../base/common/strings.js';\nimport { Range } from '../core/range.js';\nimport { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';\nimport { LineRange } from '../core/lineRange.js';\nconst MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\nexport class LegacyLinesDiffComputer {\n computeDiff(originalLines, modifiedLines, options) {\n var _a;\n const diffComputer = new DiffComputer(originalLines, modifiedLines, {\n maxComputationTime: options.maxComputationTimeMs,\n shouldIgnoreTrimWhitespace: options.ignoreTrimWhitespace,\n shouldComputeCharChanges: true,\n shouldMakePrettyDiff: true,\n shouldPostProcessCharChanges: true,\n });\n const result = diffComputer.computeDiff();\n const changes = [];\n let lastChange = null;\n for (const c of result.changes) {\n let originalRange;\n if (c.originalEndLineNumber === 0) {\n // Insertion\n originalRange = new LineRange(c.originalStartLineNumber + 1, c.originalStartLineNumber + 1);\n }\n else {\n originalRange = new LineRange(c.originalStartLineNumber, c.originalEndLineNumber + 1);\n }\n let modifiedRange;\n if (c.modifiedEndLineNumber === 0) {\n // Deletion\n modifiedRange = new LineRange(c.modifiedStartLineNumber + 1, c.modifiedStartLineNumber + 1);\n }\n else {\n modifiedRange = new LineRange(c.modifiedStartLineNumber, c.modifiedEndLineNumber + 1);\n }\n let change = new DetailedLineRangeMapping(originalRange, modifiedRange, (_a = c.charChanges) === null || _a === void 0 ? void 0 : _a.map(c => new RangeMapping(new Range(c.originalStartLineNumber, c.originalStartColumn, c.originalEndLineNumber, c.originalEndColumn), new Range(c.modifiedStartLineNumber, c.modifiedStartColumn, c.modifiedEndLineNumber, c.modifiedEndColumn))));\n if (lastChange) {\n if (lastChange.modified.endLineNumberExclusive === change.modified.startLineNumber\n || lastChange.original.endLineNumberExclusive === change.original.startLineNumber) {\n // join touching diffs. Probably moving diffs up/down in the algorithm causes touching diffs.\n change = new DetailedLineRangeMapping(lastChange.original.join(change.original), lastChange.modified.join(change.modified), lastChange.innerChanges && change.innerChanges ?\n lastChange.innerChanges.concat(change.innerChanges) : undefined);\n changes.pop();\n }\n }\n changes.push(change);\n lastChange = change;\n }\n assertFn(() => {\n return checkAdjacentItems(changes, (m1, m2) => m2.original.startLineNumber - m1.original.endLineNumberExclusive === m2.modified.startLineNumber - m1.modified.endLineNumberExclusive &&\n // There has to be an unchanged line in between (otherwise both diffs should have been joined)\n m1.original.endLineNumberExclusive < m2.original.startLineNumber &&\n m1.modified.endLineNumberExclusive < m2.modified.startLineNumber);\n });\n return new LinesDiff(changes, [], result.quitEarly);\n }\n}\nfunction computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {\n const diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);\n return diffAlgo.ComputeDiff(pretty);\n}\nclass LineSequence {\n constructor(lines) {\n const startColumns = [];\n const endColumns = [];\n for (let i = 0, length = lines.length; i < length; i++) {\n startColumns[i] = getFirstNonBlankColumn(lines[i], 1);\n endColumns[i] = getLastNonBlankColumn(lines[i], 1);\n }\n this.lines = lines;\n this._startColumns = startColumns;\n this._endColumns = endColumns;\n }\n getElements() {\n const elements = [];\n for (let i = 0, len = this.lines.length; i < len; i++) {\n elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);\n }\n return elements;\n }\n getStrictElement(index) {\n return this.lines[index];\n }\n getStartLineNumber(i) {\n return i + 1;\n }\n getEndLineNumber(i) {\n return i + 1;\n }\n createCharSequence(shouldIgnoreTrimWhitespace, startIndex, endIndex) {\n const charCodes = [];\n const lineNumbers = [];\n const columns = [];\n let len = 0;\n for (let index = startIndex; index <= endIndex; index++) {\n const lineContent = this.lines[index];\n const startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);\n const endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);\n for (let col = startColumn; col < endColumn; col++) {\n charCodes[len] = lineContent.charCodeAt(col - 1);\n lineNumbers[len] = index + 1;\n columns[len] = col;\n len++;\n }\n if (!shouldIgnoreTrimWhitespace && index < endIndex) {\n // Add \\n if trim whitespace is not ignored\n charCodes[len] = 10 /* CharCode.LineFeed */;\n lineNumbers[len] = index + 1;\n columns[len] = lineContent.length + 1;\n len++;\n }\n }\n return new CharSequence(charCodes, lineNumbers, columns);\n }\n}\nclass CharSequence {\n constructor(charCodes, lineNumbers, columns) {\n this._charCodes = charCodes;\n this._lineNumbers = lineNumbers;\n this._columns = columns;\n }\n toString() {\n return ('[' + this._charCodes.map((s, idx) => (s === 10 /* CharCode.LineFeed */ ? '\\\\n' : String.fromCharCode(s)) + `-(${this._lineNumbers[idx]},${this._columns[idx]})`).join(', ') + ']');\n }\n _assertIndex(index, arr) {\n if (index < 0 || index >= arr.length) {\n throw new Error(`Illegal index`);\n }\n }\n getElements() {\n return this._charCodes;\n }\n getStartLineNumber(i) {\n if (i > 0 && i === this._lineNumbers.length) {\n // the start line number of the element after the last element\n // is the end line number of the last element\n return this.getEndLineNumber(i - 1);\n }\n this._assertIndex(i, this._lineNumbers);\n return this._lineNumbers[i];\n }\n getEndLineNumber(i) {\n if (i === -1) {\n // the end line number of the element before the first element\n // is the start line number of the first element\n return this.getStartLineNumber(i + 1);\n }\n this._assertIndex(i, this._lineNumbers);\n if (this._charCodes[i] === 10 /* CharCode.LineFeed */) {\n return this._lineNumbers[i] + 1;\n }\n return this._lineNumbers[i];\n }\n getStartColumn(i) {\n if (i > 0 && i === this._columns.length) {\n // the start column of the element after the last element\n // is the end column of the last element\n return this.getEndColumn(i - 1);\n }\n this._assertIndex(i, this._columns);\n return this._columns[i];\n }\n getEndColumn(i) {\n if (i === -1) {\n // the end column of the element before the first element\n // is the start column of the first element\n return this.getStartColumn(i + 1);\n }\n this._assertIndex(i, this._columns);\n if (this._charCodes[i] === 10 /* CharCode.LineFeed */) {\n return 1;\n }\n return this._columns[i] + 1;\n }\n}\nclass CharChange {\n constructor(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {\n this.originalStartLineNumber = originalStartLineNumber;\n this.originalStartColumn = originalStartColumn;\n this.originalEndLineNumber = originalEndLineNumber;\n this.originalEndColumn = originalEndColumn;\n this.modifiedStartLineNumber = modifiedStartLineNumber;\n this.modifiedStartColumn = modifiedStartColumn;\n this.modifiedEndLineNumber = modifiedEndLineNumber;\n this.modifiedEndColumn = modifiedEndColumn;\n }\n static createFromDiffChange(diffChange, originalCharSequence, modifiedCharSequence) {\n const originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\n const originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\n const originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n const originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\n const modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\n const modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\n const modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n const modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);\n }\n}\nfunction postProcessCharChanges(rawChanges) {\n if (rawChanges.length <= 1) {\n return rawChanges;\n }\n const result = [rawChanges[0]];\n let prevChange = result[0];\n for (let i = 1, len = rawChanges.length; i < len; i++) {\n const currChange = rawChanges[i];\n const originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\n const modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\n // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\n const matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\n if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\n // Merge the current change into the previous one\n prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\n prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\n }\n else {\n // Add the current change\n result.push(currChange);\n prevChange = currChange;\n }\n }\n return result;\n}\nclass LineChange {\n constructor(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {\n this.originalStartLineNumber = originalStartLineNumber;\n this.originalEndLineNumber = originalEndLineNumber;\n this.modifiedStartLineNumber = modifiedStartLineNumber;\n this.modifiedEndLineNumber = modifiedEndLineNumber;\n this.charChanges = charChanges;\n }\n static createFromDiffResult(shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) {\n let originalStartLineNumber;\n let originalEndLineNumber;\n let modifiedStartLineNumber;\n let modifiedEndLineNumber;\n let charChanges = undefined;\n if (diffChange.originalLength === 0) {\n originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\n originalEndLineNumber = 0;\n }\n else {\n originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\n originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n }\n if (diffChange.modifiedLength === 0) {\n modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\n modifiedEndLineNumber = 0;\n }\n else {\n modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\n modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n }\n if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) {\n // Compute character changes for diff chunks of at most 20 lines...\n const originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\n const modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\n if (originalCharSequence.getElements().length > 0 && modifiedCharSequence.getElements().length > 0) {\n let rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes;\n if (shouldPostProcessCharChanges) {\n rawChanges = postProcessCharChanges(rawChanges);\n }\n charChanges = [];\n for (let i = 0, length = rawChanges.length; i < length; i++) {\n charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\n }\n }\n }\n return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\n }\n}\nexport class DiffComputer {\n constructor(originalLines, modifiedLines, opts) {\n this.shouldComputeCharChanges = opts.shouldComputeCharChanges;\n this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\n this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\n this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\n this.originalLines = originalLines;\n this.modifiedLines = modifiedLines;\n this.original = new LineSequence(originalLines);\n this.modified = new LineSequence(modifiedLines);\n this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime);\n this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes...\n }\n computeDiff() {\n if (this.original.lines.length === 1 && this.original.lines[0].length === 0) {\n // empty original => fast path\n if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n return {\n quitEarly: false,\n changes: []\n };\n }\n return {\n quitEarly: false,\n changes: [{\n originalStartLineNumber: 1,\n originalEndLineNumber: 1,\n modifiedStartLineNumber: 1,\n modifiedEndLineNumber: this.modified.lines.length,\n charChanges: undefined\n }]\n };\n }\n if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n // empty modified => fast path\n return {\n quitEarly: false,\n changes: [{\n originalStartLineNumber: 1,\n originalEndLineNumber: this.original.lines.length,\n modifiedStartLineNumber: 1,\n modifiedEndLineNumber: 1,\n charChanges: undefined\n }]\n };\n }\n const diffResult = computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff);\n const rawChanges = diffResult.changes;\n const quitEarly = diffResult.quitEarly;\n // The diff is always computed with ignoring trim whitespace\n // This ensures we get the prettiest diff\n if (this.shouldIgnoreTrimWhitespace) {\n const lineChanges = [];\n for (let i = 0, length = rawChanges.length; i < length; i++) {\n lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n }\n return {\n quitEarly: quitEarly,\n changes: lineChanges\n };\n }\n // Need to post-process and introduce changes where the trim whitespace is different\n // Note that we are looping starting at -1 to also cover the lines before the first change\n const result = [];\n let originalLineIndex = 0;\n let modifiedLineIndex = 0;\n for (let i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\n const nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\n const originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\n const modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\n while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\n const originalLine = this.originalLines[originalLineIndex];\n const modifiedLine = this.modifiedLines[modifiedLineIndex];\n if (originalLine !== modifiedLine) {\n // These lines differ only in trim whitespace\n // Check the leading whitespace\n {\n let originalStartColumn = getFirstNonBlankColumn(originalLine, 1);\n let modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1);\n while (originalStartColumn > 1 && modifiedStartColumn > 1) {\n const originalChar = originalLine.charCodeAt(originalStartColumn - 2);\n const modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\n if (originalChar !== modifiedChar) {\n break;\n }\n originalStartColumn--;\n modifiedStartColumn--;\n }\n if (originalStartColumn > 1 || modifiedStartColumn > 1) {\n this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);\n }\n }\n // Check the trailing whitespace\n {\n let originalEndColumn = getLastNonBlankColumn(originalLine, 1);\n let modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1);\n const originalMaxColumn = originalLine.length + 1;\n const modifiedMaxColumn = modifiedLine.length + 1;\n while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\n const originalChar = originalLine.charCodeAt(originalEndColumn - 1);\n const modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\n if (originalChar !== modifiedChar) {\n break;\n }\n originalEndColumn++;\n modifiedEndColumn++;\n }\n if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\n this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);\n }\n }\n }\n originalLineIndex++;\n modifiedLineIndex++;\n }\n if (nextChange) {\n // Emit the actual change\n result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n originalLineIndex += nextChange.originalLength;\n modifiedLineIndex += nextChange.modifiedLength;\n }\n }\n return {\n quitEarly: quitEarly,\n changes: result\n };\n }\n _pushTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\n // Merged into previous\n return;\n }\n let charChanges = undefined;\n if (this.shouldComputeCharChanges) {\n charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];\n }\n result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));\n }\n _mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n const len = result.length;\n if (len === 0) {\n return false;\n }\n const prevChange = result[len - 1];\n if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\n // Don't merge with inserts/deletes\n return false;\n }\n if (prevChange.originalEndLineNumber === originalLineNumber && prevChange.modifiedEndLineNumber === modifiedLineNumber) {\n if (this.shouldComputeCharChanges && prevChange.charChanges) {\n prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n }\n return true;\n }\n if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\n prevChange.originalEndLineNumber = originalLineNumber;\n prevChange.modifiedEndLineNumber = modifiedLineNumber;\n if (this.shouldComputeCharChanges && prevChange.charChanges) {\n prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n }\n return true;\n }\n return false;\n }\n}\nfunction getFirstNonBlankColumn(txt, defaultValue) {\n const r = strings.firstNonWhitespaceIndex(txt);\n if (r === -1) {\n return defaultValue;\n }\n return r + 1;\n}\nfunction getLastNonBlankColumn(txt, defaultValue) {\n const r = strings.lastNonWhitespaceIndex(txt);\n if (r === -1) {\n return defaultValue;\n }\n return r + 2;\n}\nfunction createContinueProcessingPredicate(maximumRuntime) {\n if (maximumRuntime === 0) {\n return () => true;\n }\n const startTime = Date.now();\n return () => {\n return Date.now() - startTime < maximumRuntime;\n };\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class LinesDiff {\n constructor(changes, \n /**\n * Sorted by original line ranges.\n * The original line ranges and the modified line ranges must be disjoint (but can be touching).\n */\n moves, \n /**\n * Indicates if the time out was reached.\n * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.\n */\n hitTimeout) {\n this.changes = changes;\n this.moves = moves;\n this.hitTimeout = hitTimeout;\n }\n}\nexport class MovedText {\n constructor(lineRangeMapping, changes) {\n this.lineRangeMapping = lineRangeMapping;\n this.changes = changes;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { LegacyLinesDiffComputer } from './legacyLinesDiffComputer.js';\nimport { DefaultLinesDiffComputer } from './defaultLinesDiffComputer/defaultLinesDiffComputer.js';\nexport const linesDiffComputers = {\n getLegacy: () => new LegacyLinesDiffComputer(),\n getDefault: () => new DefaultLinesDiffComputer(),\n};\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { LineRange } from '../core/lineRange.js';\n/**\n * Maps a line range in the original text model to a line range in the modified text model.\n */\nexport class LineRangeMapping {\n static inverse(mapping, originalLineCount, modifiedLineCount) {\n const result = [];\n let lastOriginalEndLineNumber = 1;\n let lastModifiedEndLineNumber = 1;\n for (const m of mapping) {\n const r = new DetailedLineRangeMapping(new LineRange(lastOriginalEndLineNumber, m.original.startLineNumber), new LineRange(lastModifiedEndLineNumber, m.modified.startLineNumber), undefined);\n if (!r.modified.isEmpty) {\n result.push(r);\n }\n lastOriginalEndLineNumber = m.original.endLineNumberExclusive;\n lastModifiedEndLineNumber = m.modified.endLineNumberExclusive;\n }\n const r = new DetailedLineRangeMapping(new LineRange(lastOriginalEndLineNumber, originalLineCount + 1), new LineRange(lastModifiedEndLineNumber, modifiedLineCount + 1), undefined);\n if (!r.modified.isEmpty) {\n result.push(r);\n }\n return result;\n }\n constructor(originalRange, modifiedRange) {\n this.original = originalRange;\n this.modified = modifiedRange;\n }\n toString() {\n return `{${this.original.toString()}->${this.modified.toString()}}`;\n }\n flip() {\n return new LineRangeMapping(this.modified, this.original);\n }\n join(other) {\n return new LineRangeMapping(this.original.join(other.original), this.modified.join(other.modified));\n }\n}\n/**\n * Maps a line range in the original text model to a line range in the modified text model.\n * Also contains inner range mappings.\n */\nexport class DetailedLineRangeMapping extends LineRangeMapping {\n constructor(originalRange, modifiedRange, innerChanges) {\n super(originalRange, modifiedRange);\n this.innerChanges = innerChanges;\n }\n flip() {\n var _a;\n return new DetailedLineRangeMapping(this.modified, this.original, (_a = this.innerChanges) === null || _a === void 0 ? void 0 : _a.map(c => c.flip()));\n }\n}\n/**\n * Maps a range in the original text model to a range in the modified text model.\n */\nexport class RangeMapping {\n constructor(originalRange, modifiedRange) {\n this.originalRange = originalRange;\n this.modifiedRange = modifiedRange;\n }\n toString() {\n return `{${this.originalRange.toString()}->${this.modifiedRange.toString()}}`;\n }\n flip() {\n return new RangeMapping(this.modifiedRange, this.originalRange);\n }\n}\n","import { Codicon } from '../../base/common/codicons.js';\nimport { URI } from '../../base/common/uri.js';\nimport { Range } from './core/range.js';\nimport { TokenizationRegistry as TokenizationRegistryImpl } from './tokenizationRegistry.js';\nimport { localize } from '../../nls.js';\nexport class Token {\n constructor(offset, type, language) {\n this.offset = offset;\n this.type = type;\n this.language = language;\n this._tokenBrand = undefined;\n }\n toString() {\n return '(' + this.offset + ', ' + this.type + ')';\n }\n}\n/**\n * @internal\n */\nexport class TokenizationResult {\n constructor(tokens, endState) {\n this.tokens = tokens;\n this.endState = endState;\n this._tokenizationResultBrand = undefined;\n }\n}\n/**\n * @internal\n */\nexport class EncodedTokenizationResult {\n constructor(\n /**\n * The tokens in binary format. Each token occupies two array indices. For token i:\n * - at offset 2*i => startIndex\n * - at offset 2*i + 1 => metadata\n *\n */\n tokens, endState) {\n this.tokens = tokens;\n this.endState = endState;\n this._encodedTokenizationResultBrand = undefined;\n }\n}\n/**\n * @internal\n */\nexport var CompletionItemKinds;\n(function (CompletionItemKinds) {\n const byKind = new Map();\n byKind.set(0 /* CompletionItemKind.Method */, Codicon.symbolMethod);\n byKind.set(1 /* CompletionItemKind.Function */, Codicon.symbolFunction);\n byKind.set(2 /* CompletionItemKind.Constructor */, Codicon.symbolConstructor);\n byKind.set(3 /* CompletionItemKind.Field */, Codicon.symbolField);\n byKind.set(4 /* CompletionItemKind.Variable */, Codicon.symbolVariable);\n byKind.set(5 /* CompletionItemKind.Class */, Codicon.symbolClass);\n byKind.set(6 /* CompletionItemKind.Struct */, Codicon.symbolStruct);\n byKind.set(7 /* CompletionItemKind.Interface */, Codicon.symbolInterface);\n byKind.set(8 /* CompletionItemKind.Module */, Codicon.symbolModule);\n byKind.set(9 /* CompletionItemKind.Property */, Codicon.symbolProperty);\n byKind.set(10 /* CompletionItemKind.Event */, Codicon.symbolEvent);\n byKind.set(11 /* CompletionItemKind.Operator */, Codicon.symbolOperator);\n byKind.set(12 /* CompletionItemKind.Unit */, Codicon.symbolUnit);\n byKind.set(13 /* CompletionItemKind.Value */, Codicon.symbolValue);\n byKind.set(15 /* CompletionItemKind.Enum */, Codicon.symbolEnum);\n byKind.set(14 /* CompletionItemKind.Constant */, Codicon.symbolConstant);\n byKind.set(15 /* CompletionItemKind.Enum */, Codicon.symbolEnum);\n byKind.set(16 /* CompletionItemKind.EnumMember */, Codicon.symbolEnumMember);\n byKind.set(17 /* CompletionItemKind.Keyword */, Codicon.symbolKeyword);\n byKind.set(27 /* CompletionItemKind.Snippet */, Codicon.symbolSnippet);\n byKind.set(18 /* CompletionItemKind.Text */, Codicon.symbolText);\n byKind.set(19 /* CompletionItemKind.Color */, Codicon.symbolColor);\n byKind.set(20 /* CompletionItemKind.File */, Codicon.symbolFile);\n byKind.set(21 /* CompletionItemKind.Reference */, Codicon.symbolReference);\n byKind.set(22 /* CompletionItemKind.Customcolor */, Codicon.symbolCustomColor);\n byKind.set(23 /* CompletionItemKind.Folder */, Codicon.symbolFolder);\n byKind.set(24 /* CompletionItemKind.TypeParameter */, Codicon.symbolTypeParameter);\n byKind.set(25 /* CompletionItemKind.User */, Codicon.account);\n byKind.set(26 /* CompletionItemKind.Issue */, Codicon.issues);\n /**\n * @internal\n */\n function toIcon(kind) {\n let codicon = byKind.get(kind);\n if (!codicon) {\n console.info('No codicon found for CompletionItemKind ' + kind);\n codicon = Codicon.symbolProperty;\n }\n return codicon;\n }\n CompletionItemKinds.toIcon = toIcon;\n const data = new Map();\n data.set('method', 0 /* CompletionItemKind.Method */);\n data.set('function', 1 /* CompletionItemKind.Function */);\n data.set('constructor', 2 /* CompletionItemKind.Constructor */);\n data.set('field', 3 /* CompletionItemKind.Field */);\n data.set('variable', 4 /* CompletionItemKind.Variable */);\n data.set('class', 5 /* CompletionItemKind.Class */);\n data.set('struct', 6 /* CompletionItemKind.Struct */);\n data.set('interface', 7 /* CompletionItemKind.Interface */);\n data.set('module', 8 /* CompletionItemKind.Module */);\n data.set('property', 9 /* CompletionItemKind.Property */);\n data.set('event', 10 /* CompletionItemKind.Event */);\n data.set('operator', 11 /* CompletionItemKind.Operator */);\n data.set('unit', 12 /* CompletionItemKind.Unit */);\n data.set('value', 13 /* CompletionItemKind.Value */);\n data.set('constant', 14 /* CompletionItemKind.Constant */);\n data.set('enum', 15 /* CompletionItemKind.Enum */);\n data.set('enum-member', 16 /* CompletionItemKind.EnumMember */);\n data.set('enumMember', 16 /* CompletionItemKind.EnumMember */);\n data.set('keyword', 17 /* CompletionItemKind.Keyword */);\n data.set('snippet', 27 /* CompletionItemKind.Snippet */);\n data.set('text', 18 /* CompletionItemKind.Text */);\n data.set('color', 19 /* CompletionItemKind.Color */);\n data.set('file', 20 /* CompletionItemKind.File */);\n data.set('reference', 21 /* CompletionItemKind.Reference */);\n data.set('customcolor', 22 /* CompletionItemKind.Customcolor */);\n data.set('folder', 23 /* CompletionItemKind.Folder */);\n data.set('type-parameter', 24 /* CompletionItemKind.TypeParameter */);\n data.set('typeParameter', 24 /* CompletionItemKind.TypeParameter */);\n data.set('account', 25 /* CompletionItemKind.User */);\n data.set('issue', 26 /* CompletionItemKind.Issue */);\n /**\n * @internal\n */\n function fromString(value, strict) {\n let res = data.get(value);\n if (typeof res === 'undefined' && !strict) {\n res = 9 /* CompletionItemKind.Property */;\n }\n return res;\n }\n CompletionItemKinds.fromString = fromString;\n})(CompletionItemKinds || (CompletionItemKinds = {}));\n/**\n * How an {@link InlineCompletionsProvider inline completion provider} was triggered.\n */\nexport var InlineCompletionTriggerKind;\n(function (InlineCompletionTriggerKind) {\n /**\n * Completion was triggered automatically while editing.\n * It is sufficient to return a single completion item in this case.\n */\n InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Automatic\"] = 0] = \"Automatic\";\n /**\n * Completion was triggered explicitly by a user gesture.\n * Return multiple completion items to enable cycling through them.\n */\n InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Explicit\"] = 1] = \"Explicit\";\n})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));\nexport class SelectedSuggestionInfo {\n constructor(range, text, completionKind, isSnippetText) {\n this.range = range;\n this.text = text;\n this.completionKind = completionKind;\n this.isSnippetText = isSnippetText;\n }\n equals(other) {\n return Range.lift(this.range).equalsRange(other.range)\n && this.text === other.text\n && this.completionKind === other.completionKind\n && this.isSnippetText === other.isSnippetText;\n }\n}\nexport var SignatureHelpTriggerKind;\n(function (SignatureHelpTriggerKind) {\n SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"Invoke\"] = 1] = \"Invoke\";\n SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"TriggerCharacter\"] = 2] = \"TriggerCharacter\";\n SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"ContentChange\"] = 3] = \"ContentChange\";\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n /**\n * A textual occurrence.\n */\n DocumentHighlightKind[DocumentHighlightKind[\"Text\"] = 0] = \"Text\";\n /**\n * Read-access of a symbol, like reading a variable.\n */\n DocumentHighlightKind[DocumentHighlightKind[\"Read\"] = 1] = \"Read\";\n /**\n * Write-access of a symbol, like writing to a variable.\n */\n DocumentHighlightKind[DocumentHighlightKind[\"Write\"] = 2] = \"Write\";\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * @internal\n */\nexport function isLocationLink(thing) {\n return thing\n && URI.isUri(thing.uri)\n && Range.isIRange(thing.range)\n && (Range.isIRange(thing.originSelectionRange) || Range.isIRange(thing.targetSelectionRange));\n}\n/**\n * @internal\n */\nexport const symbolKindNames = {\n [17 /* SymbolKind.Array */]: localize('Array', \"array\"),\n [16 /* SymbolKind.Boolean */]: localize('Boolean', \"boolean\"),\n [4 /* SymbolKind.Class */]: localize('Class', \"class\"),\n [13 /* SymbolKind.Constant */]: localize('Constant', \"constant\"),\n [8 /* SymbolKind.Constructor */]: localize('Constructor', \"constructor\"),\n [9 /* SymbolKind.Enum */]: localize('Enum', \"enumeration\"),\n [21 /* SymbolKind.EnumMember */]: localize('EnumMember', \"enumeration member\"),\n [23 /* SymbolKind.Event */]: localize('Event', \"event\"),\n [7 /* SymbolKind.Field */]: localize('Field', \"field\"),\n [0 /* SymbolKind.File */]: localize('File', \"file\"),\n [11 /* SymbolKind.Function */]: localize('Function', \"function\"),\n [10 /* SymbolKind.Interface */]: localize('Interface', \"interface\"),\n [19 /* SymbolKind.Key */]: localize('Key', \"key\"),\n [5 /* SymbolKind.Method */]: localize('Method', \"method\"),\n [1 /* SymbolKind.Module */]: localize('Module', \"module\"),\n [2 /* SymbolKind.Namespace */]: localize('Namespace', \"namespace\"),\n [20 /* SymbolKind.Null */]: localize('Null', \"null\"),\n [15 /* SymbolKind.Number */]: localize('Number', \"number\"),\n [18 /* SymbolKind.Object */]: localize('Object', \"object\"),\n [24 /* SymbolKind.Operator */]: localize('Operator', \"operator\"),\n [3 /* SymbolKind.Package */]: localize('Package', \"package\"),\n [6 /* SymbolKind.Property */]: localize('Property', \"property\"),\n [14 /* SymbolKind.String */]: localize('String', \"string\"),\n [22 /* SymbolKind.Struct */]: localize('Struct', \"struct\"),\n [25 /* SymbolKind.TypeParameter */]: localize('TypeParameter', \"type parameter\"),\n [12 /* SymbolKind.Variable */]: localize('Variable', \"variable\"),\n};\n/**\n * @internal\n */\nexport function getAriaLabelForSymbol(symbolName, kind) {\n return localize('symbolAriaLabel', '{0} ({1})', symbolName, symbolKindNames[kind]);\n}\n/**\n * @internal\n */\nexport var SymbolKinds;\n(function (SymbolKinds) {\n const byKind = new Map();\n byKind.set(0 /* SymbolKind.File */, Codicon.symbolFile);\n byKind.set(1 /* SymbolKind.Module */, Codicon.symbolModule);\n byKind.set(2 /* SymbolKind.Namespace */, Codicon.symbolNamespace);\n byKind.set(3 /* SymbolKind.Package */, Codicon.symbolPackage);\n byKind.set(4 /* SymbolKind.Class */, Codicon.symbolClass);\n byKind.set(5 /* SymbolKind.Method */, Codicon.symbolMethod);\n byKind.set(6 /* SymbolKind.Property */, Codicon.symbolProperty);\n byKind.set(7 /* SymbolKind.Field */, Codicon.symbolField);\n byKind.set(8 /* SymbolKind.Constructor */, Codicon.symbolConstructor);\n byKind.set(9 /* SymbolKind.Enum */, Codicon.symbolEnum);\n byKind.set(10 /* SymbolKind.Interface */, Codicon.symbolInterface);\n byKind.set(11 /* SymbolKind.Function */, Codicon.symbolFunction);\n byKind.set(12 /* SymbolKind.Variable */, Codicon.symbolVariable);\n byKind.set(13 /* SymbolKind.Constant */, Codicon.symbolConstant);\n byKind.set(14 /* SymbolKind.String */, Codicon.symbolString);\n byKind.set(15 /* SymbolKind.Number */, Codicon.symbolNumber);\n byKind.set(16 /* SymbolKind.Boolean */, Codicon.symbolBoolean);\n byKind.set(17 /* SymbolKind.Array */, Codicon.symbolArray);\n byKind.set(18 /* SymbolKind.Object */, Codicon.symbolObject);\n byKind.set(19 /* SymbolKind.Key */, Codicon.symbolKey);\n byKind.set(20 /* SymbolKind.Null */, Codicon.symbolNull);\n byKind.set(21 /* SymbolKind.EnumMember */, Codicon.symbolEnumMember);\n byKind.set(22 /* SymbolKind.Struct */, Codicon.symbolStruct);\n byKind.set(23 /* SymbolKind.Event */, Codicon.symbolEvent);\n byKind.set(24 /* SymbolKind.Operator */, Codicon.symbolOperator);\n byKind.set(25 /* SymbolKind.TypeParameter */, Codicon.symbolTypeParameter);\n /**\n * @internal\n */\n function toIcon(kind) {\n let icon = byKind.get(kind);\n if (!icon) {\n console.info('No codicon found for SymbolKind ' + kind);\n icon = Codicon.symbolProperty;\n }\n return icon;\n }\n SymbolKinds.toIcon = toIcon;\n})(SymbolKinds || (SymbolKinds = {}));\n/** @internal */\nexport class TextEdit {\n}\nexport class FoldingRangeKind {\n /**\n * Returns a {@link FoldingRangeKind} for the given value.\n *\n * @param value of the kind.\n */\n static fromValue(value) {\n switch (value) {\n case 'comment': return FoldingRangeKind.Comment;\n case 'imports': return FoldingRangeKind.Imports;\n case 'region': return FoldingRangeKind.Region;\n }\n return new FoldingRangeKind(value);\n }\n /**\n * Creates a new {@link FoldingRangeKind}.\n *\n * @param value of the kind.\n */\n constructor(value) {\n this.value = value;\n }\n}\n/**\n * Kind for folding range representing a comment. The value of the kind is 'comment'.\n */\nFoldingRangeKind.Comment = new FoldingRangeKind('comment');\n/**\n * Kind for folding range representing a import. The value of the kind is 'imports'.\n */\nFoldingRangeKind.Imports = new FoldingRangeKind('imports');\n/**\n * Kind for folding range representing regions (for example marked by `#region`, `#endregion`).\n * The value of the kind is 'region'.\n */\nFoldingRangeKind.Region = new FoldingRangeKind('region');\n/**\n * @internal\n */\nexport var Command;\n(function (Command) {\n /**\n * @internal\n */\n function is(obj) {\n if (!obj || typeof obj !== 'object') {\n return false;\n }\n return typeof obj.id === 'string' &&\n typeof obj.title === 'string';\n }\n Command.is = is;\n})(Command || (Command = {}));\nexport var InlayHintKind;\n(function (InlayHintKind) {\n InlayHintKind[InlayHintKind[\"Type\"] = 1] = \"Type\";\n InlayHintKind[InlayHintKind[\"Parameter\"] = 2] = \"Parameter\";\n})(InlayHintKind || (InlayHintKind = {}));\n/**\n * @internal\n */\nexport class LazyTokenizationSupport {\n constructor(createSupport) {\n this.createSupport = createSupport;\n this._tokenizationSupport = null;\n }\n dispose() {\n if (this._tokenizationSupport) {\n this._tokenizationSupport.then((support) => {\n if (support) {\n support.dispose();\n }\n });\n }\n }\n get tokenizationSupport() {\n if (!this._tokenizationSupport) {\n this._tokenizationSupport = this.createSupport();\n }\n return this._tokenizationSupport;\n }\n}\n/**\n * @internal\n */\nexport const TokenizationRegistry = new TokenizationRegistryImpl();\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Color, HSLA } from '../../../base/common/color.js';\nfunction _parseCaptureGroups(captureGroups) {\n const values = [];\n for (const captureGroup of captureGroups) {\n const parsedNumber = Number(captureGroup);\n if (parsedNumber || parsedNumber === 0 && captureGroup.replace(/\\s/g, '') !== '') {\n values.push(parsedNumber);\n }\n }\n return values;\n}\nfunction _toIColor(r, g, b, a) {\n return {\n red: r / 255,\n blue: b / 255,\n green: g / 255,\n alpha: a\n };\n}\nfunction _findRange(model, match) {\n const index = match.index;\n const length = match[0].length;\n if (!index) {\n return;\n }\n const startPosition = model.positionAt(index);\n const range = {\n startLineNumber: startPosition.lineNumber,\n startColumn: startPosition.column,\n endLineNumber: startPosition.lineNumber,\n endColumn: startPosition.column + length\n };\n return range;\n}\nfunction _findHexColorInformation(range, hexValue) {\n if (!range) {\n return;\n }\n const parsedHexColor = Color.Format.CSS.parseHex(hexValue);\n if (!parsedHexColor) {\n return;\n }\n return {\n range: range,\n color: _toIColor(parsedHexColor.rgba.r, parsedHexColor.rgba.g, parsedHexColor.rgba.b, parsedHexColor.rgba.a)\n };\n}\nfunction _findRGBColorInformation(range, matches, isAlpha) {\n if (!range || matches.length !== 1) {\n return;\n }\n const match = matches[0];\n const captureGroups = match.values();\n const parsedRegex = _parseCaptureGroups(captureGroups);\n return {\n range: range,\n color: _toIColor(parsedRegex[0], parsedRegex[1], parsedRegex[2], isAlpha ? parsedRegex[3] : 1)\n };\n}\nfunction _findHSLColorInformation(range, matches, isAlpha) {\n if (!range || matches.length !== 1) {\n return;\n }\n const match = matches[0];\n const captureGroups = match.values();\n const parsedRegex = _parseCaptureGroups(captureGroups);\n const colorEquivalent = new Color(new HSLA(parsedRegex[0], parsedRegex[1] / 100, parsedRegex[2] / 100, isAlpha ? parsedRegex[3] : 1));\n return {\n range: range,\n color: _toIColor(colorEquivalent.rgba.r, colorEquivalent.rgba.g, colorEquivalent.rgba.b, colorEquivalent.rgba.a)\n };\n}\nfunction _findMatches(model, regex) {\n if (typeof model === 'string') {\n return [...model.matchAll(regex)];\n }\n else {\n return model.findMatches(regex);\n }\n}\nfunction computeColors(model) {\n const result = [];\n // Early validation for RGB and HSL\n const initialValidationRegex = /\\b(rgb|rgba|hsl|hsla)(\\([0-9\\s,.\\%]*\\))|(#)([A-Fa-f0-9]{3})\\b|(#)([A-Fa-f0-9]{4})\\b|(#)([A-Fa-f0-9]{6})\\b|(#)([A-Fa-f0-9]{8})\\b/gm;\n const initialValidationMatches = _findMatches(model, initialValidationRegex);\n // Potential colors have been found, validate the parameters\n if (initialValidationMatches.length > 0) {\n for (const initialMatch of initialValidationMatches) {\n const initialCaptureGroups = initialMatch.filter(captureGroup => captureGroup !== undefined);\n const colorScheme = initialCaptureGroups[1];\n const colorParameters = initialCaptureGroups[2];\n if (!colorParameters) {\n continue;\n }\n let colorInformation;\n if (colorScheme === 'rgb') {\n const regexParameters = /^\\(\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*\\)$/gm;\n colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false);\n }\n else if (colorScheme === 'rgba') {\n const regexParameters = /^\\(\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\\s*\\)$/gm;\n colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);\n }\n else if (colorScheme === 'hsl') {\n const regexParameters = /^\\(\\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*\\)$/gm;\n colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false);\n }\n else if (colorScheme === 'hsla') {\n const regexParameters = /^\\(\\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*,\\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\\s*\\)$/gm;\n colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);\n }\n else if (colorScheme === '#') {\n colorInformation = _findHexColorInformation(_findRange(model, initialMatch), colorScheme + colorParameters);\n }\n if (colorInformation) {\n result.push(colorInformation);\n }\n }\n }\n return result;\n}\n/**\n * Returns an array of all default document colors in the provided document\n */\nexport function computeDefaultDocumentColors(model) {\n if (!model || typeof model.getValue !== 'function' || typeof model.positionAt !== 'function') {\n // Unknown caller!\n return [];\n }\n return computeColors(model);\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CharacterClassifier } from '../core/characterClassifier.js';\nclass Uint8Matrix {\n constructor(rows, cols, defaultValue) {\n const data = new Uint8Array(rows * cols);\n for (let i = 0, len = rows * cols; i < len; i++) {\n data[i] = defaultValue;\n }\n this._data = data;\n this.rows = rows;\n this.cols = cols;\n }\n get(row, col) {\n return this._data[row * this.cols + col];\n }\n set(row, col, value) {\n this._data[row * this.cols + col] = value;\n }\n}\nexport class StateMachine {\n constructor(edges) {\n let maxCharCode = 0;\n let maxState = 0 /* State.Invalid */;\n for (let i = 0, len = edges.length; i < len; i++) {\n const [from, chCode, to] = edges[i];\n if (chCode > maxCharCode) {\n maxCharCode = chCode;\n }\n if (from > maxState) {\n maxState = from;\n }\n if (to > maxState) {\n maxState = to;\n }\n }\n maxCharCode++;\n maxState++;\n const states = new Uint8Matrix(maxState, maxCharCode, 0 /* State.Invalid */);\n for (let i = 0, len = edges.length; i < len; i++) {\n const [from, chCode, to] = edges[i];\n states.set(from, chCode, to);\n }\n this._states = states;\n this._maxCharCode = maxCharCode;\n }\n nextState(currentState, chCode) {\n if (chCode < 0 || chCode >= this._maxCharCode) {\n return 0 /* State.Invalid */;\n }\n return this._states.get(currentState, chCode);\n }\n}\n// State machine for http:// or https:// or file://\nlet _stateMachine = null;\nfunction getStateMachine() {\n if (_stateMachine === null) {\n _stateMachine = new StateMachine([\n [1 /* State.Start */, 104 /* CharCode.h */, 2 /* State.H */],\n [1 /* State.Start */, 72 /* CharCode.H */, 2 /* State.H */],\n [1 /* State.Start */, 102 /* CharCode.f */, 6 /* State.F */],\n [1 /* State.Start */, 70 /* CharCode.F */, 6 /* State.F */],\n [2 /* State.H */, 116 /* CharCode.t */, 3 /* State.HT */],\n [2 /* State.H */, 84 /* CharCode.T */, 3 /* State.HT */],\n [3 /* State.HT */, 116 /* CharCode.t */, 4 /* State.HTT */],\n [3 /* State.HT */, 84 /* CharCode.T */, 4 /* State.HTT */],\n [4 /* State.HTT */, 112 /* CharCode.p */, 5 /* State.HTTP */],\n [4 /* State.HTT */, 80 /* CharCode.P */, 5 /* State.HTTP */],\n [5 /* State.HTTP */, 115 /* CharCode.s */, 9 /* State.BeforeColon */],\n [5 /* State.HTTP */, 83 /* CharCode.S */, 9 /* State.BeforeColon */],\n [5 /* State.HTTP */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */],\n [6 /* State.F */, 105 /* CharCode.i */, 7 /* State.FI */],\n [6 /* State.F */, 73 /* CharCode.I */, 7 /* State.FI */],\n [7 /* State.FI */, 108 /* CharCode.l */, 8 /* State.FIL */],\n [7 /* State.FI */, 76 /* CharCode.L */, 8 /* State.FIL */],\n [8 /* State.FIL */, 101 /* CharCode.e */, 9 /* State.BeforeColon */],\n [8 /* State.FIL */, 69 /* CharCode.E */, 9 /* State.BeforeColon */],\n [9 /* State.BeforeColon */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */],\n [10 /* State.AfterColon */, 47 /* CharCode.Slash */, 11 /* State.AlmostThere */],\n [11 /* State.AlmostThere */, 47 /* CharCode.Slash */, 12 /* State.End */],\n ]);\n }\n return _stateMachine;\n}\nlet _classifier = null;\nfunction getClassifier() {\n if (_classifier === null) {\n _classifier = new CharacterClassifier(0 /* CharacterClass.None */);\n // allow-any-unicode-next-line\n const FORCE_TERMINATION_CHARACTERS = ' \\t<>\\'\\\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';\n for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\n _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* CharacterClass.ForceTermination */);\n }\n const CANNOT_END_WITH_CHARACTERS = '.,;:';\n for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\n _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CharacterClass.CannotEndIn */);\n }\n }\n return _classifier;\n}\nexport class LinkComputer {\n static _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {\n // Do not allow to end link in certain characters...\n let lastIncludedCharIndex = linkEndIndex - 1;\n do {\n const chCode = line.charCodeAt(lastIncludedCharIndex);\n const chClass = classifier.get(chCode);\n if (chClass !== 2 /* CharacterClass.CannotEndIn */) {\n break;\n }\n lastIncludedCharIndex--;\n } while (lastIncludedCharIndex > linkBeginIndex);\n // Handle links enclosed in parens, square brackets and curlys.\n if (linkBeginIndex > 0) {\n const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\n const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\n if ((charCodeBeforeLink === 40 /* CharCode.OpenParen */ && lastCharCodeInLink === 41 /* CharCode.CloseParen */)\n || (charCodeBeforeLink === 91 /* CharCode.OpenSquareBracket */ && lastCharCodeInLink === 93 /* CharCode.CloseSquareBracket */)\n || (charCodeBeforeLink === 123 /* CharCode.OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CharCode.CloseCurlyBrace */)) {\n // Do not end in ) if ( is before the link start\n // Do not end in ] if [ is before the link start\n // Do not end in } if { is before the link start\n lastIncludedCharIndex--;\n }\n }\n return {\n range: {\n startLineNumber: lineNumber,\n startColumn: linkBeginIndex + 1,\n endLineNumber: lineNumber,\n endColumn: lastIncludedCharIndex + 2\n },\n url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\n };\n }\n static computeLinks(model, stateMachine = getStateMachine()) {\n const classifier = getClassifier();\n const result = [];\n for (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\n const line = model.getLineContent(i);\n const len = line.length;\n let j = 0;\n let linkBeginIndex = 0;\n let linkBeginChCode = 0;\n let state = 1 /* State.Start */;\n let hasOpenParens = false;\n let hasOpenSquareBracket = false;\n let inSquareBrackets = false;\n let hasOpenCurlyBracket = false;\n while (j < len) {\n let resetStateMachine = false;\n const chCode = line.charCodeAt(j);\n if (state === 13 /* State.Accept */) {\n let chClass;\n switch (chCode) {\n case 40 /* CharCode.OpenParen */:\n hasOpenParens = true;\n chClass = 0 /* CharacterClass.None */;\n break;\n case 41 /* CharCode.CloseParen */:\n chClass = (hasOpenParens ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n break;\n case 91 /* CharCode.OpenSquareBracket */:\n inSquareBrackets = true;\n hasOpenSquareBracket = true;\n chClass = 0 /* CharacterClass.None */;\n break;\n case 93 /* CharCode.CloseSquareBracket */:\n inSquareBrackets = false;\n chClass = (hasOpenSquareBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n break;\n case 123 /* CharCode.OpenCurlyBrace */:\n hasOpenCurlyBracket = true;\n chClass = 0 /* CharacterClass.None */;\n break;\n case 125 /* CharCode.CloseCurlyBrace */:\n chClass = (hasOpenCurlyBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n break;\n // The following three rules make it that ' or \" or ` are allowed inside links\n // only if the link is wrapped by some other quote character\n case 39 /* CharCode.SingleQuote */:\n case 34 /* CharCode.DoubleQuote */:\n case 96 /* CharCode.BackTick */:\n if (linkBeginChCode === chCode) {\n chClass = 1 /* CharacterClass.ForceTermination */;\n }\n else if (linkBeginChCode === 39 /* CharCode.SingleQuote */ || linkBeginChCode === 34 /* CharCode.DoubleQuote */ || linkBeginChCode === 96 /* CharCode.BackTick */) {\n chClass = 0 /* CharacterClass.None */;\n }\n else {\n chClass = 1 /* CharacterClass.ForceTermination */;\n }\n break;\n case 42 /* CharCode.Asterisk */:\n // `*` terminates a link if the link began with `*`\n chClass = (linkBeginChCode === 42 /* CharCode.Asterisk */) ? 1 /* CharacterClass.ForceTermination */ : 0 /* CharacterClass.None */;\n break;\n case 124 /* CharCode.Pipe */:\n // `|` terminates a link if the link began with `|`\n chClass = (linkBeginChCode === 124 /* CharCode.Pipe */) ? 1 /* CharacterClass.ForceTermination */ : 0 /* CharacterClass.None */;\n break;\n case 32 /* CharCode.Space */:\n // ` ` allow space in between [ and ]\n chClass = (inSquareBrackets ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n break;\n default:\n chClass = classifier.get(chCode);\n }\n // Check if character terminates link\n if (chClass === 1 /* CharacterClass.ForceTermination */) {\n result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\n resetStateMachine = true;\n }\n }\n else if (state === 12 /* State.End */) {\n let chClass;\n if (chCode === 91 /* CharCode.OpenSquareBracket */) {\n // Allow for the authority part to contain ipv6 addresses which contain [ and ]\n hasOpenSquareBracket = true;\n chClass = 0 /* CharacterClass.None */;\n }\n else {\n chClass = classifier.get(chCode);\n }\n // Check if character terminates link\n if (chClass === 1 /* CharacterClass.ForceTermination */) {\n resetStateMachine = true;\n }\n else {\n state = 13 /* State.Accept */;\n }\n }\n else {\n state = stateMachine.nextState(state, chCode);\n if (state === 0 /* State.Invalid */) {\n resetStateMachine = true;\n }\n }\n if (resetStateMachine) {\n state = 1 /* State.Start */;\n hasOpenParens = false;\n hasOpenSquareBracket = false;\n hasOpenCurlyBracket = false;\n // Record where the link started\n linkBeginIndex = j + 1;\n linkBeginChCode = chCode;\n }\n j++;\n }\n if (state === 13 /* State.Accept */) {\n result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\n }\n }\n return result;\n }\n}\n/**\n * Returns an array of all links contains in the provided\n * document. *Note* that this operation is computational\n * expensive and should not run in the UI thread.\n */\nexport function computeLinks(model) {\n if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {\n // Unknown caller!\n return [];\n }\n return LinkComputer.computeLinks(model);\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class BasicInplaceReplace {\n constructor() {\n this._defaultValueSet = [\n ['true', 'false'],\n ['True', 'False'],\n ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\n ['public', 'protected', 'private'],\n ];\n }\n navigateValueSet(range1, text1, range2, text2, up) {\n if (range1 && text1) {\n const result = this.doNavigateValueSet(text1, up);\n if (result) {\n return {\n range: range1,\n value: result\n };\n }\n }\n if (range2 && text2) {\n const result = this.doNavigateValueSet(text2, up);\n if (result) {\n return {\n range: range2,\n value: result\n };\n }\n }\n return null;\n }\n doNavigateValueSet(text, up) {\n const numberResult = this.numberReplace(text, up);\n if (numberResult !== null) {\n return numberResult;\n }\n return this.textReplace(text, up);\n }\n numberReplace(value, up) {\n const precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\n let n1 = Number(value);\n const n2 = parseFloat(value);\n if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\n if (n1 === 0 && !up) {\n return null; // don't do negative\n //\t\t\t} else if(n1 === 9 && up) {\n //\t\t\t\treturn null; // don't insert 10 into a number\n }\n else {\n n1 = Math.floor(n1 * precision);\n n1 += up ? precision : -precision;\n return String(n1 / precision);\n }\n }\n return null;\n }\n textReplace(value, up) {\n return this.valueSetsReplace(this._defaultValueSet, value, up);\n }\n valueSetsReplace(valueSets, value, up) {\n let result = null;\n for (let i = 0, len = valueSets.length; result === null && i < len; i++) {\n result = this.valueSetReplace(valueSets[i], value, up);\n }\n return result;\n }\n valueSetReplace(valueSet, value, up) {\n let idx = valueSet.indexOf(value);\n if (idx >= 0) {\n idx += up ? +1 : -1;\n if (idx < 0) {\n idx = valueSet.length - 1;\n }\n else {\n idx %= valueSet.length;\n }\n return valueSet[idx];\n }\n return null;\n }\n}\nBasicInplaceReplace.INSTANCE = new BasicInplaceReplace();\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { equals } from '../../base/common/objects.js';\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nexport var OverviewRulerLane;\n(function (OverviewRulerLane) {\n OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\n OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\n OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\n OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\n/**\n * Vertical Lane in the glyph margin of the editor.\n */\nexport var GlyphMarginLane;\n(function (GlyphMarginLane) {\n GlyphMarginLane[GlyphMarginLane[\"Left\"] = 1] = \"Left\";\n GlyphMarginLane[GlyphMarginLane[\"Right\"] = 2] = \"Right\";\n})(GlyphMarginLane || (GlyphMarginLane = {}));\n/**\n * Position in the minimap to render the decoration.\n */\nexport var MinimapPosition;\n(function (MinimapPosition) {\n MinimapPosition[MinimapPosition[\"Inline\"] = 1] = \"Inline\";\n MinimapPosition[MinimapPosition[\"Gutter\"] = 2] = \"Gutter\";\n})(MinimapPosition || (MinimapPosition = {}));\nexport var InjectedTextCursorStops;\n(function (InjectedTextCursorStops) {\n InjectedTextCursorStops[InjectedTextCursorStops[\"Both\"] = 0] = \"Both\";\n InjectedTextCursorStops[InjectedTextCursorStops[\"Right\"] = 1] = \"Right\";\n InjectedTextCursorStops[InjectedTextCursorStops[\"Left\"] = 2] = \"Left\";\n InjectedTextCursorStops[InjectedTextCursorStops[\"None\"] = 3] = \"None\";\n})(InjectedTextCursorStops || (InjectedTextCursorStops = {}));\nexport class TextModelResolvedOptions {\n get originalIndentSize() {\n return this._indentSizeIsTabSize ? 'tabSize' : this.indentSize;\n }\n /**\n * @internal\n */\n constructor(src) {\n this._textModelResolvedOptionsBrand = undefined;\n this.tabSize = Math.max(1, src.tabSize | 0);\n if (src.indentSize === 'tabSize') {\n this.indentSize = this.tabSize;\n this._indentSizeIsTabSize = true;\n }\n else {\n this.indentSize = Math.max(1, src.indentSize | 0);\n this._indentSizeIsTabSize = false;\n }\n this.insertSpaces = Boolean(src.insertSpaces);\n this.defaultEOL = src.defaultEOL | 0;\n this.trimAutoWhitespace = Boolean(src.trimAutoWhitespace);\n this.bracketPairColorizationOptions = src.bracketPairColorizationOptions;\n }\n /**\n * @internal\n */\n equals(other) {\n return (this.tabSize === other.tabSize\n && this._indentSizeIsTabSize === other._indentSizeIsTabSize\n && this.indentSize === other.indentSize\n && this.insertSpaces === other.insertSpaces\n && this.defaultEOL === other.defaultEOL\n && this.trimAutoWhitespace === other.trimAutoWhitespace\n && equals(this.bracketPairColorizationOptions, other.bracketPairColorizationOptions));\n }\n /**\n * @internal\n */\n createChangeEvent(newOpts) {\n return {\n tabSize: this.tabSize !== newOpts.tabSize,\n indentSize: this.indentSize !== newOpts.indentSize,\n insertSpaces: this.insertSpaces !== newOpts.insertSpaces,\n trimAutoWhitespace: this.trimAutoWhitespace !== newOpts.trimAutoWhitespace,\n };\n }\n}\nexport class FindMatch {\n /**\n * @internal\n */\n constructor(range, matches) {\n this._findMatchBrand = undefined;\n this.range = range;\n this.matches = matches;\n }\n}\n/**\n * @internal\n */\nexport function isITextSnapshot(obj) {\n return (obj && typeof obj.read === 'function');\n}\n/**\n * @internal\n */\nexport class ValidAnnotatedEditOperation {\n constructor(identifier, range, text, forceMoveMarkers, isAutoWhitespaceEdit, _isTracked) {\n this.identifier = identifier;\n this.range = range;\n this.text = text;\n this.forceMoveMarkers = forceMoveMarkers;\n this.isAutoWhitespaceEdit = isAutoWhitespaceEdit;\n this._isTracked = _isTracked;\n }\n}\n/**\n * @internal\n */\nexport class SearchData {\n constructor(regex, wordSeparators, simpleSearch) {\n this.regex = regex;\n this.wordSeparators = wordSeparators;\n this.simpleSearch = simpleSearch;\n }\n}\n/**\n * @internal\n */\nexport class ApplyEditsResult {\n constructor(reverseEdits, changes, trimAutoWhitespaceLineNumbers) {\n this.reverseEdits = reverseEdits;\n this.changes = changes;\n this.trimAutoWhitespaceLineNumbers = trimAutoWhitespaceLineNumbers;\n }\n}\n/**\n * @internal\n */\nexport function shouldSynchronizeModel(model) {\n return (!model.isTooLargeForSyncing() && !model.isForSimpleWidget);\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { splitLines } from '../../../base/common/strings.js';\nimport { Position } from '../core/position.js';\nimport { PrefixSumComputer } from './prefixSumComputer.js';\nexport class MirrorTextModel {\n constructor(uri, lines, eol, versionId) {\n this._uri = uri;\n this._lines = lines;\n this._eol = eol;\n this._versionId = versionId;\n this._lineStarts = null;\n this._cachedTextValue = null;\n }\n dispose() {\n this._lines.length = 0;\n }\n get version() {\n return this._versionId;\n }\n getText() {\n if (this._cachedTextValue === null) {\n this._cachedTextValue = this._lines.join(this._eol);\n }\n return this._cachedTextValue;\n }\n onEvents(e) {\n if (e.eol && e.eol !== this._eol) {\n this._eol = e.eol;\n this._lineStarts = null;\n }\n // Update my lines\n const changes = e.changes;\n for (const change of changes) {\n this._acceptDeleteRange(change.range);\n this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);\n }\n this._versionId = e.versionId;\n this._cachedTextValue = null;\n }\n _ensureLineStarts() {\n if (!this._lineStarts) {\n const eolLength = this._eol.length;\n const linesLength = this._lines.length;\n const lineStartValues = new Uint32Array(linesLength);\n for (let i = 0; i < linesLength; i++) {\n lineStartValues[i] = this._lines[i].length + eolLength;\n }\n this._lineStarts = new PrefixSumComputer(lineStartValues);\n }\n }\n /**\n * All changes to a line's text go through this method\n */\n _setLineText(lineIndex, newValue) {\n this._lines[lineIndex] = newValue;\n if (this._lineStarts) {\n // update prefix sum\n this._lineStarts.setValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\n }\n }\n _acceptDeleteRange(range) {\n if (range.startLineNumber === range.endLineNumber) {\n if (range.startColumn === range.endColumn) {\n // Nothing to delete\n return;\n }\n // Delete text on the affected line\n this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));\n return;\n }\n // Take remaining text on last line and append it to remaining text on first line\n this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));\n // Delete middle lines\n this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n if (this._lineStarts) {\n // update prefix sum\n this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n }\n }\n _acceptInsertText(position, insertText) {\n if (insertText.length === 0) {\n // Nothing to insert\n return;\n }\n const insertLines = splitLines(insertText);\n if (insertLines.length === 1) {\n // Inserting text on one line\n this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n + insertLines[0]\n + this._lines[position.lineNumber - 1].substring(position.column - 1));\n return;\n }\n // Append overflowing text from first line to the end of text to insert\n insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\n // Delete overflowing text from first line and insert text on first line\n this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n + insertLines[0]);\n // Insert new lines & store lengths\n const newLengths = new Uint32Array(insertLines.length - 1);\n for (let i = 1; i < insertLines.length; i++) {\n this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\n newLengths[i - 1] = insertLines[i].length + this._eol.length;\n }\n if (this._lineStarts) {\n // update prefix sum\n this._lineStarts.insertValues(position.lineNumber, newLengths);\n }\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { arrayInsert } from '../../../base/common/arrays.js';\nimport { toUint32 } from '../../../base/common/uint.js';\nexport class PrefixSumComputer {\n constructor(values) {\n this.values = values;\n this.prefixSum = new Uint32Array(values.length);\n this.prefixSumValidIndex = new Int32Array(1);\n this.prefixSumValidIndex[0] = -1;\n }\n insertValues(insertIndex, insertValues) {\n insertIndex = toUint32(insertIndex);\n const oldValues = this.values;\n const oldPrefixSum = this.prefixSum;\n const insertValuesLen = insertValues.length;\n if (insertValuesLen === 0) {\n return false;\n }\n this.values = new Uint32Array(oldValues.length + insertValuesLen);\n this.values.set(oldValues.subarray(0, insertIndex), 0);\n this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\n this.values.set(insertValues, insertIndex);\n if (insertIndex - 1 < this.prefixSumValidIndex[0]) {\n this.prefixSumValidIndex[0] = insertIndex - 1;\n }\n this.prefixSum = new Uint32Array(this.values.length);\n if (this.prefixSumValidIndex[0] >= 0) {\n this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n }\n return true;\n }\n setValue(index, value) {\n index = toUint32(index);\n value = toUint32(value);\n if (this.values[index] === value) {\n return false;\n }\n this.values[index] = value;\n if (index - 1 < this.prefixSumValidIndex[0]) {\n this.prefixSumValidIndex[0] = index - 1;\n }\n return true;\n }\n removeValues(startIndex, count) {\n startIndex = toUint32(startIndex);\n count = toUint32(count);\n const oldValues = this.values;\n const oldPrefixSum = this.prefixSum;\n if (startIndex >= oldValues.length) {\n return false;\n }\n const maxCount = oldValues.length - startIndex;\n if (count >= maxCount) {\n count = maxCount;\n }\n if (count === 0) {\n return false;\n }\n this.values = new Uint32Array(oldValues.length - count);\n this.values.set(oldValues.subarray(0, startIndex), 0);\n this.values.set(oldValues.subarray(startIndex + count), startIndex);\n this.prefixSum = new Uint32Array(this.values.length);\n if (startIndex - 1 < this.prefixSumValidIndex[0]) {\n this.prefixSumValidIndex[0] = startIndex - 1;\n }\n if (this.prefixSumValidIndex[0] >= 0) {\n this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n }\n return true;\n }\n getTotalSum() {\n if (this.values.length === 0) {\n return 0;\n }\n return this._getPrefixSum(this.values.length - 1);\n }\n /**\n * Returns the sum of the first `index + 1` many items.\n * @returns `SUM(0 <= j <= index, values[j])`.\n */\n getPrefixSum(index) {\n if (index < 0) {\n return 0;\n }\n index = toUint32(index);\n return this._getPrefixSum(index);\n }\n _getPrefixSum(index) {\n if (index <= this.prefixSumValidIndex[0]) {\n return this.prefixSum[index];\n }\n let startIndex = this.prefixSumValidIndex[0] + 1;\n if (startIndex === 0) {\n this.prefixSum[0] = this.values[0];\n startIndex++;\n }\n if (index >= this.values.length) {\n index = this.values.length - 1;\n }\n for (let i = startIndex; i <= index; i++) {\n this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\n }\n this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\n return this.prefixSum[index];\n }\n getIndexOf(sum) {\n sum = Math.floor(sum);\n // Compute all sums (to get a fully valid prefixSum)\n this.getTotalSum();\n let low = 0;\n let high = this.values.length - 1;\n let mid = 0;\n let midStop = 0;\n let midStart = 0;\n while (low <= high) {\n mid = low + ((high - low) / 2) | 0;\n midStop = this.prefixSum[mid];\n midStart = midStop - this.values[mid];\n if (sum < midStart) {\n high = mid - 1;\n }\n else if (sum >= midStop) {\n low = mid + 1;\n }\n else {\n break;\n }\n }\n return new PrefixSumIndexOfResult(mid, sum - midStart);\n }\n}\n/**\n * {@link getIndexOf} has an amortized runtime complexity of O(1).\n *\n * ({@link PrefixSumComputer.getIndexOf} is just O(log n))\n*/\nexport class ConstantTimePrefixSumComputer {\n constructor(values) {\n this._values = values;\n this._isValid = false;\n this._validEndIndex = -1;\n this._prefixSum = [];\n this._indexBySum = [];\n }\n /**\n * @returns SUM(0 <= j < values.length, values[j])\n */\n getTotalSum() {\n this._ensureValid();\n return this._indexBySum.length;\n }\n /**\n * Returns the sum of the first `count` many items.\n * @returns `SUM(0 <= j < count, values[j])`.\n */\n getPrefixSum(count) {\n this._ensureValid();\n if (count === 0) {\n return 0;\n }\n return this._prefixSum[count - 1];\n }\n /**\n * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum`\n */\n getIndexOf(sum) {\n this._ensureValid();\n const idx = this._indexBySum[sum];\n const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0;\n return new PrefixSumIndexOfResult(idx, sum - viewLinesAbove);\n }\n removeValues(start, deleteCount) {\n this._values.splice(start, deleteCount);\n this._invalidate(start);\n }\n insertValues(insertIndex, insertArr) {\n this._values = arrayInsert(this._values, insertIndex, insertArr);\n this._invalidate(insertIndex);\n }\n _invalidate(index) {\n this._isValid = false;\n this._validEndIndex = Math.min(this._validEndIndex, index - 1);\n }\n _ensureValid() {\n if (this._isValid) {\n return;\n }\n for (let i = this._validEndIndex + 1, len = this._values.length; i < len; i++) {\n const value = this._values[i];\n const sumAbove = i > 0 ? this._prefixSum[i - 1] : 0;\n this._prefixSum[i] = sumAbove + value;\n for (let j = 0; j < value; j++) {\n this._indexBySum[sumAbove + j] = i;\n }\n }\n // trim things\n this._prefixSum.length = this._values.length;\n this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1];\n // mark as valid\n this._isValid = true;\n this._validEndIndex = this._values.length - 1;\n }\n setValue(index, value) {\n if (this._values[index] === value) {\n // no change\n return;\n }\n this._values[index] = value;\n this._invalidate(index);\n }\n}\nexport class PrefixSumIndexOfResult {\n constructor(index, remainder) {\n this.index = index;\n this.remainder = remainder;\n this._prefixSumIndexOfResultBrand = undefined;\n this.index = index;\n this.remainder = remainder;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../base/common/strings.js';\nimport { getMapForWordSeparators } from '../core/wordCharacterClassifier.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { FindMatch, SearchData } from '../model.js';\nconst LIMIT_FIND_COUNT = 999;\nexport class SearchParams {\n constructor(searchString, isRegex, matchCase, wordSeparators) {\n this.searchString = searchString;\n this.isRegex = isRegex;\n this.matchCase = matchCase;\n this.wordSeparators = wordSeparators;\n }\n parseSearchRequest() {\n if (this.searchString === '') {\n return null;\n }\n // Try to create a RegExp out of the params\n let multiline;\n if (this.isRegex) {\n multiline = isMultilineRegexSource(this.searchString);\n }\n else {\n multiline = (this.searchString.indexOf('\\n') >= 0);\n }\n let regex = null;\n try {\n regex = strings.createRegExp(this.searchString, this.isRegex, {\n matchCase: this.matchCase,\n wholeWord: false,\n multiline: multiline,\n global: true,\n unicode: true\n });\n }\n catch (err) {\n return null;\n }\n if (!regex) {\n return null;\n }\n let canUseSimpleSearch = (!this.isRegex && !multiline);\n if (canUseSimpleSearch && this.searchString.toLowerCase() !== this.searchString.toUpperCase()) {\n // casing might make a difference\n canUseSimpleSearch = this.matchCase;\n }\n return new SearchData(regex, this.wordSeparators ? getMapForWordSeparators(this.wordSeparators) : null, canUseSimpleSearch ? this.searchString : null);\n }\n}\nexport function isMultilineRegexSource(searchString) {\n if (!searchString || searchString.length === 0) {\n return false;\n }\n for (let i = 0, len = searchString.length; i < len; i++) {\n const chCode = searchString.charCodeAt(i);\n if (chCode === 10 /* CharCode.LineFeed */) {\n return true;\n }\n if (chCode === 92 /* CharCode.Backslash */) {\n // move to next char\n i++;\n if (i >= len) {\n // string ends with a \\\n break;\n }\n const nextChCode = searchString.charCodeAt(i);\n if (nextChCode === 110 /* CharCode.n */ || nextChCode === 114 /* CharCode.r */ || nextChCode === 87 /* CharCode.W */) {\n return true;\n }\n }\n }\n return false;\n}\nexport function createFindMatch(range, rawMatches, captureMatches) {\n if (!captureMatches) {\n return new FindMatch(range, null);\n }\n const matches = [];\n for (let i = 0, len = rawMatches.length; i < len; i++) {\n matches[i] = rawMatches[i];\n }\n return new FindMatch(range, matches);\n}\nclass LineFeedCounter {\n constructor(text) {\n const lineFeedsOffsets = [];\n let lineFeedsOffsetsLen = 0;\n for (let i = 0, textLen = text.length; i < textLen; i++) {\n if (text.charCodeAt(i) === 10 /* CharCode.LineFeed */) {\n lineFeedsOffsets[lineFeedsOffsetsLen++] = i;\n }\n }\n this._lineFeedsOffsets = lineFeedsOffsets;\n }\n findLineFeedCountBeforeOffset(offset) {\n const lineFeedsOffsets = this._lineFeedsOffsets;\n let min = 0;\n let max = lineFeedsOffsets.length - 1;\n if (max === -1) {\n // no line feeds\n return 0;\n }\n if (offset <= lineFeedsOffsets[0]) {\n // before first line feed\n return 0;\n }\n while (min < max) {\n const mid = min + ((max - min) / 2 >> 0);\n if (lineFeedsOffsets[mid] >= offset) {\n max = mid - 1;\n }\n else {\n if (lineFeedsOffsets[mid + 1] >= offset) {\n // bingo!\n min = mid;\n max = mid;\n }\n else {\n min = mid + 1;\n }\n }\n }\n return min + 1;\n }\n}\nexport class TextModelSearch {\n static findMatches(model, searchParams, searchRange, captureMatches, limitResultCount) {\n const searchData = searchParams.parseSearchRequest();\n if (!searchData) {\n return [];\n }\n if (searchData.regex.multiline) {\n return this._doFindMatchesMultiline(model, searchRange, new Searcher(searchData.wordSeparators, searchData.regex), captureMatches, limitResultCount);\n }\n return this._doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount);\n }\n /**\n * Multiline search always executes on the lines concatenated with \\n.\n * We must therefore compensate for the count of \\n in case the model is CRLF\n */\n static _getMultilineMatchRange(model, deltaOffset, text, lfCounter, matchIndex, match0) {\n let startOffset;\n let lineFeedCountBeforeMatch = 0;\n if (lfCounter) {\n lineFeedCountBeforeMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex);\n startOffset = deltaOffset + matchIndex + lineFeedCountBeforeMatch /* add as many \\r as there were \\n */;\n }\n else {\n startOffset = deltaOffset + matchIndex;\n }\n let endOffset;\n if (lfCounter) {\n const lineFeedCountBeforeEndOfMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex + match0.length);\n const lineFeedCountInMatch = lineFeedCountBeforeEndOfMatch - lineFeedCountBeforeMatch;\n endOffset = startOffset + match0.length + lineFeedCountInMatch /* add as many \\r as there were \\n */;\n }\n else {\n endOffset = startOffset + match0.length;\n }\n const startPosition = model.getPositionAt(startOffset);\n const endPosition = model.getPositionAt(endOffset);\n return new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);\n }\n static _doFindMatchesMultiline(model, searchRange, searcher, captureMatches, limitResultCount) {\n const deltaOffset = model.getOffsetAt(searchRange.getStartPosition());\n // We always execute multiline search over the lines joined with \\n\n // This makes it that \\n will match the EOL for both CRLF and LF models\n // We compensate for offset errors in `_getMultilineMatchRange`\n const text = model.getValueInRange(searchRange, 1 /* EndOfLinePreference.LF */);\n const lfCounter = (model.getEOL() === '\\r\\n' ? new LineFeedCounter(text) : null);\n const result = [];\n let counter = 0;\n let m;\n searcher.reset(0);\n while ((m = searcher.next(text))) {\n result[counter++] = createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);\n if (counter >= limitResultCount) {\n return result;\n }\n }\n return result;\n }\n static _doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount) {\n const result = [];\n let resultLen = 0;\n // Early case for a search range that starts & stops on the same line number\n if (searchRange.startLineNumber === searchRange.endLineNumber) {\n const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1, searchRange.endColumn - 1);\n resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);\n return result;\n }\n // Collect results from first line\n const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1);\n resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);\n // Collect results from middle lines\n for (let lineNumber = searchRange.startLineNumber + 1; lineNumber < searchRange.endLineNumber && resultLen < limitResultCount; lineNumber++) {\n resultLen = this._findMatchesInLine(searchData, model.getLineContent(lineNumber), lineNumber, 0, resultLen, result, captureMatches, limitResultCount);\n }\n // Collect results from last line\n if (resultLen < limitResultCount) {\n const text = model.getLineContent(searchRange.endLineNumber).substring(0, searchRange.endColumn - 1);\n resultLen = this._findMatchesInLine(searchData, text, searchRange.endLineNumber, 0, resultLen, result, captureMatches, limitResultCount);\n }\n return result;\n }\n static _findMatchesInLine(searchData, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) {\n const wordSeparators = searchData.wordSeparators;\n if (!captureMatches && searchData.simpleSearch) {\n const searchString = searchData.simpleSearch;\n const searchStringLen = searchString.length;\n const textLength = text.length;\n let lastMatchIndex = -searchStringLen;\n while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) {\n if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) {\n result[resultLen++] = new FindMatch(new Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null);\n if (resultLen >= limitResultCount) {\n return resultLen;\n }\n }\n }\n return resultLen;\n }\n const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n let m;\n // Reset regex to search from the beginning\n searcher.reset(0);\n do {\n m = searcher.next(text);\n if (m) {\n result[resultLen++] = createFindMatch(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches);\n if (resultLen >= limitResultCount) {\n return resultLen;\n }\n }\n } while (m);\n return resultLen;\n }\n static findNextMatch(model, searchParams, searchStart, captureMatches) {\n const searchData = searchParams.parseSearchRequest();\n if (!searchData) {\n return null;\n }\n const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n if (searchData.regex.multiline) {\n return this._doFindNextMatchMultiline(model, searchStart, searcher, captureMatches);\n }\n return this._doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches);\n }\n static _doFindNextMatchMultiline(model, searchStart, searcher, captureMatches) {\n const searchTextStart = new Position(searchStart.lineNumber, 1);\n const deltaOffset = model.getOffsetAt(searchTextStart);\n const lineCount = model.getLineCount();\n // We always execute multiline search over the lines joined with \\n\n // This makes it that \\n will match the EOL for both CRLF and LF models\n // We compensate for offset errors in `_getMultilineMatchRange`\n const text = model.getValueInRange(new Range(searchTextStart.lineNumber, searchTextStart.column, lineCount, model.getLineMaxColumn(lineCount)), 1 /* EndOfLinePreference.LF */);\n const lfCounter = (model.getEOL() === '\\r\\n' ? new LineFeedCounter(text) : null);\n searcher.reset(searchStart.column - 1);\n const m = searcher.next(text);\n if (m) {\n return createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);\n }\n if (searchStart.lineNumber !== 1 || searchStart.column !== 1) {\n // Try again from the top\n return this._doFindNextMatchMultiline(model, new Position(1, 1), searcher, captureMatches);\n }\n return null;\n }\n static _doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches) {\n const lineCount = model.getLineCount();\n const startLineNumber = searchStart.lineNumber;\n // Look in first line\n const text = model.getLineContent(startLineNumber);\n const r = this._findFirstMatchInLine(searcher, text, startLineNumber, searchStart.column, captureMatches);\n if (r) {\n return r;\n }\n for (let i = 1; i <= lineCount; i++) {\n const lineIndex = (startLineNumber + i - 1) % lineCount;\n const text = model.getLineContent(lineIndex + 1);\n const r = this._findFirstMatchInLine(searcher, text, lineIndex + 1, 1, captureMatches);\n if (r) {\n return r;\n }\n }\n return null;\n }\n static _findFirstMatchInLine(searcher, text, lineNumber, fromColumn, captureMatches) {\n // Set regex to search from column\n searcher.reset(fromColumn - 1);\n const m = searcher.next(text);\n if (m) {\n return createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);\n }\n return null;\n }\n static findPreviousMatch(model, searchParams, searchStart, captureMatches) {\n const searchData = searchParams.parseSearchRequest();\n if (!searchData) {\n return null;\n }\n const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n if (searchData.regex.multiline) {\n return this._doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches);\n }\n return this._doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches);\n }\n static _doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches) {\n const matches = this._doFindMatchesMultiline(model, new Range(1, 1, searchStart.lineNumber, searchStart.column), searcher, captureMatches, 10 * LIMIT_FIND_COUNT);\n if (matches.length > 0) {\n return matches[matches.length - 1];\n }\n const lineCount = model.getLineCount();\n if (searchStart.lineNumber !== lineCount || searchStart.column !== model.getLineMaxColumn(lineCount)) {\n // Try again with all content\n return this._doFindPreviousMatchMultiline(model, new Position(lineCount, model.getLineMaxColumn(lineCount)), searcher, captureMatches);\n }\n return null;\n }\n static _doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches) {\n const lineCount = model.getLineCount();\n const startLineNumber = searchStart.lineNumber;\n // Look in first line\n const text = model.getLineContent(startLineNumber).substring(0, searchStart.column - 1);\n const r = this._findLastMatchInLine(searcher, text, startLineNumber, captureMatches);\n if (r) {\n return r;\n }\n for (let i = 1; i <= lineCount; i++) {\n const lineIndex = (lineCount + startLineNumber - i - 1) % lineCount;\n const text = model.getLineContent(lineIndex + 1);\n const r = this._findLastMatchInLine(searcher, text, lineIndex + 1, captureMatches);\n if (r) {\n return r;\n }\n }\n return null;\n }\n static _findLastMatchInLine(searcher, text, lineNumber, captureMatches) {\n let bestResult = null;\n let m;\n searcher.reset(0);\n while ((m = searcher.next(text))) {\n bestResult = createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);\n }\n return bestResult;\n }\n}\nfunction leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n if (matchStartIndex === 0) {\n // Match starts at start of string\n return true;\n }\n const charBefore = text.charCodeAt(matchStartIndex - 1);\n if (wordSeparators.get(charBefore) !== 0 /* WordCharacterClass.Regular */) {\n // The character before the match is a word separator\n return true;\n }\n if (charBefore === 13 /* CharCode.CarriageReturn */ || charBefore === 10 /* CharCode.LineFeed */) {\n // The character before the match is line break or carriage return.\n return true;\n }\n if (matchLength > 0) {\n const firstCharInMatch = text.charCodeAt(matchStartIndex);\n if (wordSeparators.get(firstCharInMatch) !== 0 /* WordCharacterClass.Regular */) {\n // The first character inside the match is a word separator\n return true;\n }\n }\n return false;\n}\nfunction rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n if (matchStartIndex + matchLength === textLength) {\n // Match ends at end of string\n return true;\n }\n const charAfter = text.charCodeAt(matchStartIndex + matchLength);\n if (wordSeparators.get(charAfter) !== 0 /* WordCharacterClass.Regular */) {\n // The character after the match is a word separator\n return true;\n }\n if (charAfter === 13 /* CharCode.CarriageReturn */ || charAfter === 10 /* CharCode.LineFeed */) {\n // The character after the match is line break or carriage return.\n return true;\n }\n if (matchLength > 0) {\n const lastCharInMatch = text.charCodeAt(matchStartIndex + matchLength - 1);\n if (wordSeparators.get(lastCharInMatch) !== 0 /* WordCharacterClass.Regular */) {\n // The last character in the match is a word separator\n return true;\n }\n }\n return false;\n}\nexport function isValidMatch(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n return (leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength)\n && rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength));\n}\nexport class Searcher {\n constructor(wordSeparators, searchRegex) {\n this._wordSeparators = wordSeparators;\n this._searchRegex = searchRegex;\n this._prevMatchStartIndex = -1;\n this._prevMatchLength = 0;\n }\n reset(lastIndex) {\n this._searchRegex.lastIndex = lastIndex;\n this._prevMatchStartIndex = -1;\n this._prevMatchLength = 0;\n }\n next(text) {\n const textLength = text.length;\n let m;\n do {\n if (this._prevMatchStartIndex + this._prevMatchLength === textLength) {\n // Reached the end of the line\n return null;\n }\n m = this._searchRegex.exec(text);\n if (!m) {\n return null;\n }\n const matchStartIndex = m.index;\n const matchLength = m[0].length;\n if (matchStartIndex === this._prevMatchStartIndex && matchLength === this._prevMatchLength) {\n if (matchLength === 0) {\n // the search result is an empty string and won't advance `regex.lastIndex`, so `regex.exec` will stuck here\n // we attempt to recover from that by advancing by two if surrogate pair found and by one otherwise\n if (strings.getNextCodePoint(text, textLength, this._searchRegex.lastIndex) > 0xFFFF) {\n this._searchRegex.lastIndex += 2;\n }\n else {\n this._searchRegex.lastIndex += 1;\n }\n continue;\n }\n // Exit early if the regex matches the same range twice\n return null;\n }\n this._prevMatchStartIndex = matchStartIndex;\n this._prevMatchLength = matchLength;\n if (!this._wordSeparators || isValidMatch(this._wordSeparators, text, textLength, matchStartIndex, matchLength)) {\n return m;\n }\n } while (m);\n return null;\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CancellationTokenSource } from '../../../base/common/cancellation.js';\nimport { Emitter } from '../../../base/common/event.js';\nimport { KeyChord } from '../../../base/common/keyCodes.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { Selection } from '../core/selection.js';\nimport { Token } from '../languages.js';\nimport * as standaloneEnums from '../standalone/standaloneEnums.js';\nexport class KeyMod {\n static chord(firstPart, secondPart) {\n return KeyChord(firstPart, secondPart);\n }\n}\nKeyMod.CtrlCmd = 2048 /* ConstKeyMod.CtrlCmd */;\nKeyMod.Shift = 1024 /* ConstKeyMod.Shift */;\nKeyMod.Alt = 512 /* ConstKeyMod.Alt */;\nKeyMod.WinCtrl = 256 /* ConstKeyMod.WinCtrl */;\nexport function createMonacoBaseAPI() {\n return {\n editor: undefined, // undefined override expected here\n languages: undefined, // undefined override expected here\n CancellationTokenSource: CancellationTokenSource,\n Emitter: Emitter,\n KeyCode: standaloneEnums.KeyCode,\n KeyMod: KeyMod,\n Position: Position,\n Range: Range,\n Selection: Selection,\n SelectionDirection: standaloneEnums.SelectionDirection,\n MarkerSeverity: standaloneEnums.MarkerSeverity,\n MarkerTag: standaloneEnums.MarkerTag,\n Uri: URI,\n Token: Token\n };\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { stringDiff } from '../../../base/common/diff/diff.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { MirrorTextModel as BaseMirrorModel } from '../model/mirrorTextModel.js';\nimport { ensureValidWordDefinition, getWordAtText } from '../core/wordHelper.js';\nimport { computeLinks } from '../languages/linkComputer.js';\nimport { BasicInplaceReplace } from '../languages/supports/inplaceReplaceSupport.js';\nimport { createMonacoBaseAPI } from './editorBaseApi.js';\nimport { StopWatch } from '../../../base/common/stopwatch.js';\nimport { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';\nimport { linesDiffComputers } from '../diff/linesDiffComputers.js';\nimport { createProxyObject, getAllMethodNames } from '../../../base/common/objects.js';\nimport { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';\n/**\n * @internal\n */\nclass MirrorModel extends BaseMirrorModel {\n get uri() {\n return this._uri;\n }\n get eol() {\n return this._eol;\n }\n getValue() {\n return this.getText();\n }\n findMatches(regex) {\n const matches = [];\n for (let i = 0; i < this._lines.length; i++) {\n const line = this._lines[i];\n const offsetToAdd = this.offsetAt(new Position(i + 1, 1));\n const iteratorOverMatches = line.matchAll(regex);\n for (const match of iteratorOverMatches) {\n if (match.index || match.index === 0) {\n match.index = match.index + offsetToAdd;\n }\n matches.push(match);\n }\n }\n return matches;\n }\n getLinesContent() {\n return this._lines.slice(0);\n }\n getLineCount() {\n return this._lines.length;\n }\n getLineContent(lineNumber) {\n return this._lines[lineNumber - 1];\n }\n getWordAtPosition(position, wordDefinition) {\n const wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);\n if (wordAtText) {\n return new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);\n }\n return null;\n }\n words(wordDefinition) {\n const lines = this._lines;\n const wordenize = this._wordenize.bind(this);\n let lineNumber = 0;\n let lineText = '';\n let wordRangesIdx = 0;\n let wordRanges = [];\n return {\n *[Symbol.iterator]() {\n while (true) {\n if (wordRangesIdx < wordRanges.length) {\n const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);\n wordRangesIdx += 1;\n yield value;\n }\n else {\n if (lineNumber < lines.length) {\n lineText = lines[lineNumber];\n wordRanges = wordenize(lineText, wordDefinition);\n wordRangesIdx = 0;\n lineNumber += 1;\n }\n else {\n break;\n }\n }\n }\n }\n };\n }\n getLineWords(lineNumber, wordDefinition) {\n const content = this._lines[lineNumber - 1];\n const ranges = this._wordenize(content, wordDefinition);\n const words = [];\n for (const range of ranges) {\n words.push({\n word: content.substring(range.start, range.end),\n startColumn: range.start + 1,\n endColumn: range.end + 1\n });\n }\n return words;\n }\n _wordenize(content, wordDefinition) {\n const result = [];\n let match;\n wordDefinition.lastIndex = 0; // reset lastIndex just to be sure\n while (match = wordDefinition.exec(content)) {\n if (match[0].length === 0) {\n // it did match the empty string\n break;\n }\n result.push({ start: match.index, end: match.index + match[0].length });\n }\n return result;\n }\n getValueInRange(range) {\n range = this._validateRange(range);\n if (range.startLineNumber === range.endLineNumber) {\n return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);\n }\n const lineEnding = this._eol;\n const startLineIndex = range.startLineNumber - 1;\n const endLineIndex = range.endLineNumber - 1;\n const resultLines = [];\n resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));\n for (let i = startLineIndex + 1; i < endLineIndex; i++) {\n resultLines.push(this._lines[i]);\n }\n resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));\n return resultLines.join(lineEnding);\n }\n offsetAt(position) {\n position = this._validatePosition(position);\n this._ensureLineStarts();\n return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);\n }\n positionAt(offset) {\n offset = Math.floor(offset);\n offset = Math.max(0, offset);\n this._ensureLineStarts();\n const out = this._lineStarts.getIndexOf(offset);\n const lineLength = this._lines[out.index].length;\n // Ensure we return a valid position\n return {\n lineNumber: 1 + out.index,\n column: 1 + Math.min(out.remainder, lineLength)\n };\n }\n _validateRange(range) {\n const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });\n const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });\n if (start.lineNumber !== range.startLineNumber\n || start.column !== range.startColumn\n || end.lineNumber !== range.endLineNumber\n || end.column !== range.endColumn) {\n return {\n startLineNumber: start.lineNumber,\n startColumn: start.column,\n endLineNumber: end.lineNumber,\n endColumn: end.column\n };\n }\n return range;\n }\n _validatePosition(position) {\n if (!Position.isIPosition(position)) {\n throw new Error('bad position');\n }\n let { lineNumber, column } = position;\n let hasChanged = false;\n if (lineNumber < 1) {\n lineNumber = 1;\n column = 1;\n hasChanged = true;\n }\n else if (lineNumber > this._lines.length) {\n lineNumber = this._lines.length;\n column = this._lines[lineNumber - 1].length + 1;\n hasChanged = true;\n }\n else {\n const maxCharacter = this._lines[lineNumber - 1].length + 1;\n if (column < 1) {\n column = 1;\n hasChanged = true;\n }\n else if (column > maxCharacter) {\n column = maxCharacter;\n hasChanged = true;\n }\n }\n if (!hasChanged) {\n return position;\n }\n else {\n return { lineNumber, column };\n }\n }\n}\n/**\n * @internal\n */\nexport class EditorSimpleWorker {\n constructor(host, foreignModuleFactory) {\n this._host = host;\n this._models = Object.create(null);\n this._foreignModuleFactory = foreignModuleFactory;\n this._foreignModule = null;\n }\n dispose() {\n this._models = Object.create(null);\n }\n _getModel(uri) {\n return this._models[uri];\n }\n _getModels() {\n const all = [];\n Object.keys(this._models).forEach((key) => all.push(this._models[key]));\n return all;\n }\n acceptNewModel(data) {\n this._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);\n }\n acceptModelChanged(strURL, e) {\n if (!this._models[strURL]) {\n return;\n }\n const model = this._models[strURL];\n model.onEvents(e);\n }\n acceptRemovedModel(strURL) {\n if (!this._models[strURL]) {\n return;\n }\n delete this._models[strURL];\n }\n async computeUnicodeHighlights(url, options, range) {\n const model = this._getModel(url);\n if (!model) {\n return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 };\n }\n return UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range);\n }\n // ---- BEGIN diff --------------------------------------------------------------------------\n async computeDiff(originalUrl, modifiedUrl, options, algorithm) {\n const original = this._getModel(originalUrl);\n const modified = this._getModel(modifiedUrl);\n if (!original || !modified) {\n return null;\n }\n return EditorSimpleWorker.computeDiff(original, modified, options, algorithm);\n }\n static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) {\n const diffAlgorithm = algorithm === 'advanced' ? linesDiffComputers.getDefault() : linesDiffComputers.getLegacy();\n const originalLines = originalTextModel.getLinesContent();\n const modifiedLines = modifiedTextModel.getLinesContent();\n const result = diffAlgorithm.computeDiff(originalLines, modifiedLines, options);\n const identical = (result.changes.length > 0 ? false : this._modelsAreIdentical(originalTextModel, modifiedTextModel));\n function getLineChanges(changes) {\n return changes.map(m => {\n var _a;\n return ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, (_a = m.innerChanges) === null || _a === void 0 ? void 0 : _a.map(m => [\n m.originalRange.startLineNumber,\n m.originalRange.startColumn,\n m.originalRange.endLineNumber,\n m.originalRange.endColumn,\n m.modifiedRange.startLineNumber,\n m.modifiedRange.startColumn,\n m.modifiedRange.endLineNumber,\n m.modifiedRange.endColumn,\n ])]);\n });\n }\n return {\n identical,\n quitEarly: result.hitTimeout,\n changes: getLineChanges(result.changes),\n moves: result.moves.map(m => ([\n m.lineRangeMapping.original.startLineNumber,\n m.lineRangeMapping.original.endLineNumberExclusive,\n m.lineRangeMapping.modified.startLineNumber,\n m.lineRangeMapping.modified.endLineNumberExclusive,\n getLineChanges(m.changes)\n ])),\n };\n }\n static _modelsAreIdentical(original, modified) {\n const originalLineCount = original.getLineCount();\n const modifiedLineCount = modified.getLineCount();\n if (originalLineCount !== modifiedLineCount) {\n return false;\n }\n for (let line = 1; line <= originalLineCount; line++) {\n const originalLine = original.getLineContent(line);\n const modifiedLine = modified.getLineContent(line);\n if (originalLine !== modifiedLine) {\n return false;\n }\n }\n return true;\n }\n async computeMoreMinimalEdits(modelUrl, edits, pretty) {\n const model = this._getModel(modelUrl);\n if (!model) {\n return edits;\n }\n const result = [];\n let lastEol = undefined;\n edits = edits.slice(0).sort((a, b) => {\n if (a.range && b.range) {\n return Range.compareRangesUsingStarts(a.range, b.range);\n }\n // eol only changes should go to the end\n const aRng = a.range ? 0 : 1;\n const bRng = b.range ? 0 : 1;\n return aRng - bRng;\n });\n // merge adjacent edits\n let writeIndex = 0;\n for (let readIndex = 1; readIndex < edits.length; readIndex++) {\n if (Range.getEndPosition(edits[writeIndex].range).equals(Range.getStartPosition(edits[readIndex].range))) {\n edits[writeIndex].range = Range.fromPositions(Range.getStartPosition(edits[writeIndex].range), Range.getEndPosition(edits[readIndex].range));\n edits[writeIndex].text += edits[readIndex].text;\n }\n else {\n writeIndex++;\n edits[writeIndex] = edits[readIndex];\n }\n }\n edits.length = writeIndex + 1;\n for (let { range, text, eol } of edits) {\n if (typeof eol === 'number') {\n lastEol = eol;\n }\n if (Range.isEmpty(range) && !text) {\n // empty change\n continue;\n }\n const original = model.getValueInRange(range);\n text = text.replace(/\\r\\n|\\n|\\r/g, model.eol);\n if (original === text) {\n // noop\n continue;\n }\n // make sure diff won't take too long\n if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {\n result.push({ range, text });\n continue;\n }\n // compute diff between original and edit.text\n const changes = stringDiff(original, text, pretty);\n const editOffset = model.offsetAt(Range.lift(range).getStartPosition());\n for (const change of changes) {\n const start = model.positionAt(editOffset + change.originalStart);\n const end = model.positionAt(editOffset + change.originalStart + change.originalLength);\n const newEdit = {\n text: text.substr(change.modifiedStart, change.modifiedLength),\n range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }\n };\n if (model.getValueInRange(newEdit.range) !== newEdit.text) {\n result.push(newEdit);\n }\n }\n }\n if (typeof lastEol === 'number') {\n result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });\n }\n return result;\n }\n // ---- END minimal edits ---------------------------------------------------------------\n async computeLinks(modelUrl) {\n const model = this._getModel(modelUrl);\n if (!model) {\n return null;\n }\n return computeLinks(model);\n }\n // --- BEGIN default document colors -----------------------------------------------------------\n async computeDefaultDocumentColors(modelUrl) {\n const model = this._getModel(modelUrl);\n if (!model) {\n return null;\n }\n return computeDefaultDocumentColors(model);\n }\n async textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {\n const sw = new StopWatch();\n const wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n const seen = new Set();\n outer: for (const url of modelUrls) {\n const model = this._getModel(url);\n if (!model) {\n continue;\n }\n for (const word of model.words(wordDefRegExp)) {\n if (word === leadingWord || !isNaN(Number(word))) {\n continue;\n }\n seen.add(word);\n if (seen.size > EditorSimpleWorker._suggestionsLimit) {\n break outer;\n }\n }\n }\n return { words: Array.from(seen), duration: sw.elapsed() };\n }\n // ---- END suggest --------------------------------------------------------------------------\n //#region -- word ranges --\n async computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {\n const model = this._getModel(modelUrl);\n if (!model) {\n return Object.create(null);\n }\n const wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n const result = Object.create(null);\n for (let line = range.startLineNumber; line < range.endLineNumber; line++) {\n const words = model.getLineWords(line, wordDefRegExp);\n for (const word of words) {\n if (!isNaN(Number(word.word))) {\n continue;\n }\n let array = result[word.word];\n if (!array) {\n array = [];\n result[word.word] = array;\n }\n array.push({\n startLineNumber: line,\n startColumn: word.startColumn,\n endLineNumber: line,\n endColumn: word.endColumn\n });\n }\n }\n return result;\n }\n //#endregion\n async navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {\n const model = this._getModel(modelUrl);\n if (!model) {\n return null;\n }\n const wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n if (range.startColumn === range.endColumn) {\n range = {\n startLineNumber: range.startLineNumber,\n startColumn: range.startColumn,\n endLineNumber: range.endLineNumber,\n endColumn: range.endColumn + 1\n };\n }\n const selectionText = model.getValueInRange(range);\n const wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);\n if (!wordRange) {\n return null;\n }\n const word = model.getValueInRange(wordRange);\n const result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);\n return result;\n }\n // ---- BEGIN foreign module support --------------------------------------------------------------------------\n loadForeignModule(moduleId, createData, foreignHostMethods) {\n const proxyMethodRequest = (method, args) => {\n return this._host.fhr(method, args);\n };\n const foreignHost = createProxyObject(foreignHostMethods, proxyMethodRequest);\n const ctx = {\n host: foreignHost,\n getMirrorModels: () => {\n return this._getModels();\n }\n };\n if (this._foreignModuleFactory) {\n this._foreignModule = this._foreignModuleFactory(ctx, createData);\n // static foreing module\n return Promise.resolve(getAllMethodNames(this._foreignModule));\n }\n // ESM-comment-begin\n // \t\treturn new Promise((resolve, reject) => {\n // \t\t\trequire([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {\n // \t\t\t\tthis._foreignModule = foreignModule.create(ctx, createData);\n // \n // \t\t\t\tresolve(getAllMethodNames(this._foreignModule));\n // \n // \t\t\t}, reject);\n // \t\t});\n // ESM-comment-end\n // ESM-uncomment-begin\n return Promise.reject(new Error(`Unexpected usage`));\n // ESM-uncomment-end\n }\n // foreign method request\n fmr(method, args) {\n if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {\n return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n }\n try {\n return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));\n }\n catch (e) {\n return Promise.reject(e);\n }\n }\n}\n// ---- END diff --------------------------------------------------------------------------\n// ---- BEGIN minimal edits ---------------------------------------------------------------\nEditorSimpleWorker._diffLimit = 100000;\n// ---- BEGIN suggest --------------------------------------------------------------------------\nEditorSimpleWorker._suggestionsLimit = 10000;\n/**\n * Called on the worker side\n * @internal\n */\nexport function create(host) {\n return new EditorSimpleWorker(host, null);\n}\nif (typeof importScripts === 'function') {\n // Running in a web worker\n globalThis.monaco = createMonacoBaseAPI();\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Range } from '../core/range.js';\nimport { Searcher } from '../model/textModelSearch.js';\nimport * as strings from '../../../base/common/strings.js';\nimport { assertNever } from '../../../base/common/assert.js';\nimport { DEFAULT_WORD_REGEXP, getWordAtText } from '../core/wordHelper.js';\nexport class UnicodeTextModelHighlighter {\n static computeUnicodeHighlights(model, options, range) {\n const startLine = range ? range.startLineNumber : 1;\n const endLine = range ? range.endLineNumber : model.getLineCount();\n const codePointHighlighter = new CodePointHighlighter(options);\n const candidates = codePointHighlighter.getCandidateCodePoints();\n let regex;\n if (candidates === 'allNonBasicAscii') {\n regex = new RegExp('[^\\\\t\\\\n\\\\r\\\\x20-\\\\x7E]', 'g');\n }\n else {\n regex = new RegExp(`${buildRegExpCharClassExpr(Array.from(candidates))}`, 'g');\n }\n const searcher = new Searcher(null, regex);\n const ranges = [];\n let hasMore = false;\n let m;\n let ambiguousCharacterCount = 0;\n let invisibleCharacterCount = 0;\n let nonBasicAsciiCharacterCount = 0;\n forLoop: for (let lineNumber = startLine, lineCount = endLine; lineNumber <= lineCount; lineNumber++) {\n const lineContent = model.getLineContent(lineNumber);\n const lineLength = lineContent.length;\n // Reset regex to search from the beginning\n searcher.reset(0);\n do {\n m = searcher.next(lineContent);\n if (m) {\n let startIndex = m.index;\n let endIndex = m.index + m[0].length;\n // Extend range to entire code point\n if (startIndex > 0) {\n const charCodeBefore = lineContent.charCodeAt(startIndex - 1);\n if (strings.isHighSurrogate(charCodeBefore)) {\n startIndex--;\n }\n }\n if (endIndex + 1 < lineLength) {\n const charCodeBefore = lineContent.charCodeAt(endIndex - 1);\n if (strings.isHighSurrogate(charCodeBefore)) {\n endIndex++;\n }\n }\n const str = lineContent.substring(startIndex, endIndex);\n let word = getWordAtText(startIndex + 1, DEFAULT_WORD_REGEXP, lineContent, 0);\n if (word && word.endColumn <= startIndex + 1) {\n // The word does not include the problematic character, ignore the word\n word = null;\n }\n const highlightReason = codePointHighlighter.shouldHighlightNonBasicASCII(str, word ? word.word : null);\n if (highlightReason !== 0 /* SimpleHighlightReason.None */) {\n if (highlightReason === 3 /* SimpleHighlightReason.Ambiguous */) {\n ambiguousCharacterCount++;\n }\n else if (highlightReason === 2 /* SimpleHighlightReason.Invisible */) {\n invisibleCharacterCount++;\n }\n else if (highlightReason === 1 /* SimpleHighlightReason.NonBasicASCII */) {\n nonBasicAsciiCharacterCount++;\n }\n else {\n assertNever(highlightReason);\n }\n const MAX_RESULT_LENGTH = 1000;\n if (ranges.length >= MAX_RESULT_LENGTH) {\n hasMore = true;\n break forLoop;\n }\n ranges.push(new Range(lineNumber, startIndex + 1, lineNumber, endIndex + 1));\n }\n }\n } while (m);\n }\n return {\n ranges,\n hasMore,\n ambiguousCharacterCount,\n invisibleCharacterCount,\n nonBasicAsciiCharacterCount\n };\n }\n static computeUnicodeHighlightReason(char, options) {\n const codePointHighlighter = new CodePointHighlighter(options);\n const reason = codePointHighlighter.shouldHighlightNonBasicASCII(char, null);\n switch (reason) {\n case 0 /* SimpleHighlightReason.None */:\n return null;\n case 2 /* SimpleHighlightReason.Invisible */:\n return { kind: 1 /* UnicodeHighlighterReasonKind.Invisible */ };\n case 3 /* SimpleHighlightReason.Ambiguous */: {\n const codePoint = char.codePointAt(0);\n const primaryConfusable = codePointHighlighter.ambiguousCharacters.getPrimaryConfusable(codePoint);\n const notAmbiguousInLocales = strings.AmbiguousCharacters.getLocales().filter((l) => !strings.AmbiguousCharacters.getInstance(new Set([...options.allowedLocales, l])).isAmbiguous(codePoint));\n return { kind: 0 /* UnicodeHighlighterReasonKind.Ambiguous */, confusableWith: String.fromCodePoint(primaryConfusable), notAmbiguousInLocales };\n }\n case 1 /* SimpleHighlightReason.NonBasicASCII */:\n return { kind: 2 /* UnicodeHighlighterReasonKind.NonBasicAscii */ };\n }\n }\n}\nfunction buildRegExpCharClassExpr(codePoints, flags) {\n const src = `[${strings.escapeRegExpCharacters(codePoints.map((i) => String.fromCodePoint(i)).join(''))}]`;\n return src;\n}\nclass CodePointHighlighter {\n constructor(options) {\n this.options = options;\n this.allowedCodePoints = new Set(options.allowedCodePoints);\n this.ambiguousCharacters = strings.AmbiguousCharacters.getInstance(new Set(options.allowedLocales));\n }\n getCandidateCodePoints() {\n if (this.options.nonBasicASCII) {\n return 'allNonBasicAscii';\n }\n const set = new Set();\n if (this.options.invisibleCharacters) {\n for (const cp of strings.InvisibleCharacters.codePoints) {\n if (!isAllowedInvisibleCharacter(String.fromCodePoint(cp))) {\n set.add(cp);\n }\n }\n }\n if (this.options.ambiguousCharacters) {\n for (const cp of this.ambiguousCharacters.getConfusableCodePoints()) {\n set.add(cp);\n }\n }\n for (const cp of this.allowedCodePoints) {\n set.delete(cp);\n }\n return set;\n }\n shouldHighlightNonBasicASCII(character, wordContext) {\n const codePoint = character.codePointAt(0);\n if (this.allowedCodePoints.has(codePoint)) {\n return 0 /* SimpleHighlightReason.None */;\n }\n if (this.options.nonBasicASCII) {\n return 1 /* SimpleHighlightReason.NonBasicASCII */;\n }\n let hasBasicASCIICharacters = false;\n let hasNonConfusableNonBasicAsciiCharacter = false;\n if (wordContext) {\n for (const char of wordContext) {\n const codePoint = char.codePointAt(0);\n const isBasicASCII = strings.isBasicASCII(char);\n hasBasicASCIICharacters = hasBasicASCIICharacters || isBasicASCII;\n if (!isBasicASCII &&\n !this.ambiguousCharacters.isAmbiguous(codePoint) &&\n !strings.InvisibleCharacters.isInvisibleCharacter(codePoint)) {\n hasNonConfusableNonBasicAsciiCharacter = true;\n }\n }\n }\n if (\n /* Don't allow mixing weird looking characters with ASCII */ !hasBasicASCIICharacters &&\n /* Is there an obviously weird looking character? */ hasNonConfusableNonBasicAsciiCharacter) {\n return 0 /* SimpleHighlightReason.None */;\n }\n if (this.options.invisibleCharacters) {\n // TODO check for emojis\n if (!isAllowedInvisibleCharacter(character) && strings.InvisibleCharacters.isInvisibleCharacter(codePoint)) {\n return 2 /* SimpleHighlightReason.Invisible */;\n }\n }\n if (this.options.ambiguousCharacters) {\n if (this.ambiguousCharacters.isAmbiguous(codePoint)) {\n return 3 /* SimpleHighlightReason.Ambiguous */;\n }\n }\n return 0 /* SimpleHighlightReason.None */;\n }\n}\nfunction isAllowedInvisibleCharacter(character) {\n return character === ' ' || character === '\\n' || character === '\\t';\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.\nexport var AccessibilitySupport;\n(function (AccessibilitySupport) {\n /**\n * This should be the browser case where it is not known if a screen reader is attached or no.\n */\n AccessibilitySupport[AccessibilitySupport[\"Unknown\"] = 0] = \"Unknown\";\n AccessibilitySupport[AccessibilitySupport[\"Disabled\"] = 1] = \"Disabled\";\n AccessibilitySupport[AccessibilitySupport[\"Enabled\"] = 2] = \"Enabled\";\n})(AccessibilitySupport || (AccessibilitySupport = {}));\nexport var CodeActionTriggerType;\n(function (CodeActionTriggerType) {\n CodeActionTriggerType[CodeActionTriggerType[\"Invoke\"] = 1] = \"Invoke\";\n CodeActionTriggerType[CodeActionTriggerType[\"Auto\"] = 2] = \"Auto\";\n})(CodeActionTriggerType || (CodeActionTriggerType = {}));\nexport var CompletionItemInsertTextRule;\n(function (CompletionItemInsertTextRule) {\n CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"None\"] = 0] = \"None\";\n /**\n * Adjust whitespace/indentation of multiline insert texts to\n * match the current line indentation.\n */\n CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"KeepWhitespace\"] = 1] = \"KeepWhitespace\";\n /**\n * `insertText` is a snippet.\n */\n CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"InsertAsSnippet\"] = 4] = \"InsertAsSnippet\";\n})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {}));\nexport var CompletionItemKind;\n(function (CompletionItemKind) {\n CompletionItemKind[CompletionItemKind[\"Method\"] = 0] = \"Method\";\n CompletionItemKind[CompletionItemKind[\"Function\"] = 1] = \"Function\";\n CompletionItemKind[CompletionItemKind[\"Constructor\"] = 2] = \"Constructor\";\n CompletionItemKind[CompletionItemKind[\"Field\"] = 3] = \"Field\";\n CompletionItemKind[CompletionItemKind[\"Variable\"] = 4] = \"Variable\";\n CompletionItemKind[CompletionItemKind[\"Class\"] = 5] = \"Class\";\n CompletionItemKind[CompletionItemKind[\"Struct\"] = 6] = \"Struct\";\n CompletionItemKind[CompletionItemKind[\"Interface\"] = 7] = \"Interface\";\n CompletionItemKind[CompletionItemKind[\"Module\"] = 8] = \"Module\";\n CompletionItemKind[CompletionItemKind[\"Property\"] = 9] = \"Property\";\n CompletionItemKind[CompletionItemKind[\"Event\"] = 10] = \"Event\";\n CompletionItemKind[CompletionItemKind[\"Operator\"] = 11] = \"Operator\";\n CompletionItemKind[CompletionItemKind[\"Unit\"] = 12] = \"Unit\";\n CompletionItemKind[CompletionItemKind[\"Value\"] = 13] = \"Value\";\n CompletionItemKind[CompletionItemKind[\"Constant\"] = 14] = \"Constant\";\n CompletionItemKind[CompletionItemKind[\"Enum\"] = 15] = \"Enum\";\n CompletionItemKind[CompletionItemKind[\"EnumMember\"] = 16] = \"EnumMember\";\n CompletionItemKind[CompletionItemKind[\"Keyword\"] = 17] = \"Keyword\";\n CompletionItemKind[CompletionItemKind[\"Text\"] = 18] = \"Text\";\n CompletionItemKind[CompletionItemKind[\"Color\"] = 19] = \"Color\";\n CompletionItemKind[CompletionItemKind[\"File\"] = 20] = \"File\";\n CompletionItemKind[CompletionItemKind[\"Reference\"] = 21] = \"Reference\";\n CompletionItemKind[CompletionItemKind[\"Customcolor\"] = 22] = \"Customcolor\";\n CompletionItemKind[CompletionItemKind[\"Folder\"] = 23] = \"Folder\";\n CompletionItemKind[CompletionItemKind[\"TypeParameter\"] = 24] = \"TypeParameter\";\n CompletionItemKind[CompletionItemKind[\"User\"] = 25] = \"User\";\n CompletionItemKind[CompletionItemKind[\"Issue\"] = 26] = \"Issue\";\n CompletionItemKind[CompletionItemKind[\"Snippet\"] = 27] = \"Snippet\";\n})(CompletionItemKind || (CompletionItemKind = {}));\nexport var CompletionItemTag;\n(function (CompletionItemTag) {\n CompletionItemTag[CompletionItemTag[\"Deprecated\"] = 1] = \"Deprecated\";\n})(CompletionItemTag || (CompletionItemTag = {}));\n/**\n * How a suggest provider was triggered.\n */\nexport var CompletionTriggerKind;\n(function (CompletionTriggerKind) {\n CompletionTriggerKind[CompletionTriggerKind[\"Invoke\"] = 0] = \"Invoke\";\n CompletionTriggerKind[CompletionTriggerKind[\"TriggerCharacter\"] = 1] = \"TriggerCharacter\";\n CompletionTriggerKind[CompletionTriggerKind[\"TriggerForIncompleteCompletions\"] = 2] = \"TriggerForIncompleteCompletions\";\n})(CompletionTriggerKind || (CompletionTriggerKind = {}));\n/**\n * A positioning preference for rendering content widgets.\n */\nexport var ContentWidgetPositionPreference;\n(function (ContentWidgetPositionPreference) {\n /**\n * Place the content widget exactly at a position\n */\n ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"EXACT\"] = 0] = \"EXACT\";\n /**\n * Place the content widget above a position\n */\n ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"ABOVE\"] = 1] = \"ABOVE\";\n /**\n * Place the content widget below a position\n */\n ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"BELOW\"] = 2] = \"BELOW\";\n})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {}));\n/**\n * Describes the reason the cursor has changed its position.\n */\nexport var CursorChangeReason;\n(function (CursorChangeReason) {\n /**\n * Unknown or not set.\n */\n CursorChangeReason[CursorChangeReason[\"NotSet\"] = 0] = \"NotSet\";\n /**\n * A `model.setValue()` was called.\n */\n CursorChangeReason[CursorChangeReason[\"ContentFlush\"] = 1] = \"ContentFlush\";\n /**\n * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.\n */\n CursorChangeReason[CursorChangeReason[\"RecoverFromMarkers\"] = 2] = \"RecoverFromMarkers\";\n /**\n * There was an explicit user gesture.\n */\n CursorChangeReason[CursorChangeReason[\"Explicit\"] = 3] = \"Explicit\";\n /**\n * There was a Paste.\n */\n CursorChangeReason[CursorChangeReason[\"Paste\"] = 4] = \"Paste\";\n /**\n * There was an Undo.\n */\n CursorChangeReason[CursorChangeReason[\"Undo\"] = 5] = \"Undo\";\n /**\n * There was a Redo.\n */\n CursorChangeReason[CursorChangeReason[\"Redo\"] = 6] = \"Redo\";\n})(CursorChangeReason || (CursorChangeReason = {}));\n/**\n * The default end of line to use when instantiating models.\n */\nexport var DefaultEndOfLine;\n(function (DefaultEndOfLine) {\n /**\n * Use line feed (\\n) as the end of line character.\n */\n DefaultEndOfLine[DefaultEndOfLine[\"LF\"] = 1] = \"LF\";\n /**\n * Use carriage return and line feed (\\r\\n) as the end of line character.\n */\n DefaultEndOfLine[DefaultEndOfLine[\"CRLF\"] = 2] = \"CRLF\";\n})(DefaultEndOfLine || (DefaultEndOfLine = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n /**\n * A textual occurrence.\n */\n DocumentHighlightKind[DocumentHighlightKind[\"Text\"] = 0] = \"Text\";\n /**\n * Read-access of a symbol, like reading a variable.\n */\n DocumentHighlightKind[DocumentHighlightKind[\"Read\"] = 1] = \"Read\";\n /**\n * Write-access of a symbol, like writing to a variable.\n */\n DocumentHighlightKind[DocumentHighlightKind[\"Write\"] = 2] = \"Write\";\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * Configuration options for auto indentation in the editor\n */\nexport var EditorAutoIndentStrategy;\n(function (EditorAutoIndentStrategy) {\n EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"None\"] = 0] = \"None\";\n EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Keep\"] = 1] = \"Keep\";\n EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Brackets\"] = 2] = \"Brackets\";\n EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Advanced\"] = 3] = \"Advanced\";\n EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Full\"] = 4] = \"Full\";\n})(EditorAutoIndentStrategy || (EditorAutoIndentStrategy = {}));\nexport var EditorOption;\n(function (EditorOption) {\n EditorOption[EditorOption[\"acceptSuggestionOnCommitCharacter\"] = 0] = \"acceptSuggestionOnCommitCharacter\";\n EditorOption[EditorOption[\"acceptSuggestionOnEnter\"] = 1] = \"acceptSuggestionOnEnter\";\n EditorOption[EditorOption[\"accessibilitySupport\"] = 2] = \"accessibilitySupport\";\n EditorOption[EditorOption[\"accessibilityPageSize\"] = 3] = \"accessibilityPageSize\";\n EditorOption[EditorOption[\"ariaLabel\"] = 4] = \"ariaLabel\";\n EditorOption[EditorOption[\"ariaRequired\"] = 5] = \"ariaRequired\";\n EditorOption[EditorOption[\"autoClosingBrackets\"] = 6] = \"autoClosingBrackets\";\n EditorOption[EditorOption[\"autoClosingComments\"] = 7] = \"autoClosingComments\";\n EditorOption[EditorOption[\"screenReaderAnnounceInlineSuggestion\"] = 8] = \"screenReaderAnnounceInlineSuggestion\";\n EditorOption[EditorOption[\"autoClosingDelete\"] = 9] = \"autoClosingDelete\";\n EditorOption[EditorOption[\"autoClosingOvertype\"] = 10] = \"autoClosingOvertype\";\n EditorOption[EditorOption[\"autoClosingQuotes\"] = 11] = \"autoClosingQuotes\";\n EditorOption[EditorOption[\"autoIndent\"] = 12] = \"autoIndent\";\n EditorOption[EditorOption[\"automaticLayout\"] = 13] = \"automaticLayout\";\n EditorOption[EditorOption[\"autoSurround\"] = 14] = \"autoSurround\";\n EditorOption[EditorOption[\"bracketPairColorization\"] = 15] = \"bracketPairColorization\";\n EditorOption[EditorOption[\"guides\"] = 16] = \"guides\";\n EditorOption[EditorOption[\"codeLens\"] = 17] = \"codeLens\";\n EditorOption[EditorOption[\"codeLensFontFamily\"] = 18] = \"codeLensFontFamily\";\n EditorOption[EditorOption[\"codeLensFontSize\"] = 19] = \"codeLensFontSize\";\n EditorOption[EditorOption[\"colorDecorators\"] = 20] = \"colorDecorators\";\n EditorOption[EditorOption[\"colorDecoratorsLimit\"] = 21] = \"colorDecoratorsLimit\";\n EditorOption[EditorOption[\"columnSelection\"] = 22] = \"columnSelection\";\n EditorOption[EditorOption[\"comments\"] = 23] = \"comments\";\n EditorOption[EditorOption[\"contextmenu\"] = 24] = \"contextmenu\";\n EditorOption[EditorOption[\"copyWithSyntaxHighlighting\"] = 25] = \"copyWithSyntaxHighlighting\";\n EditorOption[EditorOption[\"cursorBlinking\"] = 26] = \"cursorBlinking\";\n EditorOption[EditorOption[\"cursorSmoothCaretAnimation\"] = 27] = \"cursorSmoothCaretAnimation\";\n EditorOption[EditorOption[\"cursorStyle\"] = 28] = \"cursorStyle\";\n EditorOption[EditorOption[\"cursorSurroundingLines\"] = 29] = \"cursorSurroundingLines\";\n EditorOption[EditorOption[\"cursorSurroundingLinesStyle\"] = 30] = \"cursorSurroundingLinesStyle\";\n EditorOption[EditorOption[\"cursorWidth\"] = 31] = \"cursorWidth\";\n EditorOption[EditorOption[\"disableLayerHinting\"] = 32] = \"disableLayerHinting\";\n EditorOption[EditorOption[\"disableMonospaceOptimizations\"] = 33] = \"disableMonospaceOptimizations\";\n EditorOption[EditorOption[\"domReadOnly\"] = 34] = \"domReadOnly\";\n EditorOption[EditorOption[\"dragAndDrop\"] = 35] = \"dragAndDrop\";\n EditorOption[EditorOption[\"dropIntoEditor\"] = 36] = \"dropIntoEditor\";\n EditorOption[EditorOption[\"emptySelectionClipboard\"] = 37] = \"emptySelectionClipboard\";\n EditorOption[EditorOption[\"experimentalWhitespaceRendering\"] = 38] = \"experimentalWhitespaceRendering\";\n EditorOption[EditorOption[\"extraEditorClassName\"] = 39] = \"extraEditorClassName\";\n EditorOption[EditorOption[\"fastScrollSensitivity\"] = 40] = \"fastScrollSensitivity\";\n EditorOption[EditorOption[\"find\"] = 41] = \"find\";\n EditorOption[EditorOption[\"fixedOverflowWidgets\"] = 42] = \"fixedOverflowWidgets\";\n EditorOption[EditorOption[\"folding\"] = 43] = \"folding\";\n EditorOption[EditorOption[\"foldingStrategy\"] = 44] = \"foldingStrategy\";\n EditorOption[EditorOption[\"foldingHighlight\"] = 45] = \"foldingHighlight\";\n EditorOption[EditorOption[\"foldingImportsByDefault\"] = 46] = \"foldingImportsByDefault\";\n EditorOption[EditorOption[\"foldingMaximumRegions\"] = 47] = \"foldingMaximumRegions\";\n EditorOption[EditorOption[\"unfoldOnClickAfterEndOfLine\"] = 48] = \"unfoldOnClickAfterEndOfLine\";\n EditorOption[EditorOption[\"fontFamily\"] = 49] = \"fontFamily\";\n EditorOption[EditorOption[\"fontInfo\"] = 50] = \"fontInfo\";\n EditorOption[EditorOption[\"fontLigatures\"] = 51] = \"fontLigatures\";\n EditorOption[EditorOption[\"fontSize\"] = 52] = \"fontSize\";\n EditorOption[EditorOption[\"fontWeight\"] = 53] = \"fontWeight\";\n EditorOption[EditorOption[\"fontVariations\"] = 54] = \"fontVariations\";\n EditorOption[EditorOption[\"formatOnPaste\"] = 55] = \"formatOnPaste\";\n EditorOption[EditorOption[\"formatOnType\"] = 56] = \"formatOnType\";\n EditorOption[EditorOption[\"glyphMargin\"] = 57] = \"glyphMargin\";\n EditorOption[EditorOption[\"gotoLocation\"] = 58] = \"gotoLocation\";\n EditorOption[EditorOption[\"hideCursorInOverviewRuler\"] = 59] = \"hideCursorInOverviewRuler\";\n EditorOption[EditorOption[\"hover\"] = 60] = \"hover\";\n EditorOption[EditorOption[\"inDiffEditor\"] = 61] = \"inDiffEditor\";\n EditorOption[EditorOption[\"inlineSuggest\"] = 62] = \"inlineSuggest\";\n EditorOption[EditorOption[\"letterSpacing\"] = 63] = \"letterSpacing\";\n EditorOption[EditorOption[\"lightbulb\"] = 64] = \"lightbulb\";\n EditorOption[EditorOption[\"lineDecorationsWidth\"] = 65] = \"lineDecorationsWidth\";\n EditorOption[EditorOption[\"lineHeight\"] = 66] = \"lineHeight\";\n EditorOption[EditorOption[\"lineNumbers\"] = 67] = \"lineNumbers\";\n EditorOption[EditorOption[\"lineNumbersMinChars\"] = 68] = \"lineNumbersMinChars\";\n EditorOption[EditorOption[\"linkedEditing\"] = 69] = \"linkedEditing\";\n EditorOption[EditorOption[\"links\"] = 70] = \"links\";\n EditorOption[EditorOption[\"matchBrackets\"] = 71] = \"matchBrackets\";\n EditorOption[EditorOption[\"minimap\"] = 72] = \"minimap\";\n EditorOption[EditorOption[\"mouseStyle\"] = 73] = \"mouseStyle\";\n EditorOption[EditorOption[\"mouseWheelScrollSensitivity\"] = 74] = \"mouseWheelScrollSensitivity\";\n EditorOption[EditorOption[\"mouseWheelZoom\"] = 75] = \"mouseWheelZoom\";\n EditorOption[EditorOption[\"multiCursorMergeOverlapping\"] = 76] = \"multiCursorMergeOverlapping\";\n EditorOption[EditorOption[\"multiCursorModifier\"] = 77] = \"multiCursorModifier\";\n EditorOption[EditorOption[\"multiCursorPaste\"] = 78] = \"multiCursorPaste\";\n EditorOption[EditorOption[\"multiCursorLimit\"] = 79] = \"multiCursorLimit\";\n EditorOption[EditorOption[\"occurrencesHighlight\"] = 80] = \"occurrencesHighlight\";\n EditorOption[EditorOption[\"overviewRulerBorder\"] = 81] = \"overviewRulerBorder\";\n EditorOption[EditorOption[\"overviewRulerLanes\"] = 82] = \"overviewRulerLanes\";\n EditorOption[EditorOption[\"padding\"] = 83] = \"padding\";\n EditorOption[EditorOption[\"pasteAs\"] = 84] = \"pasteAs\";\n EditorOption[EditorOption[\"parameterHints\"] = 85] = \"parameterHints\";\n EditorOption[EditorOption[\"peekWidgetDefaultFocus\"] = 86] = \"peekWidgetDefaultFocus\";\n EditorOption[EditorOption[\"definitionLinkOpensInPeek\"] = 87] = \"definitionLinkOpensInPeek\";\n EditorOption[EditorOption[\"quickSuggestions\"] = 88] = \"quickSuggestions\";\n EditorOption[EditorOption[\"quickSuggestionsDelay\"] = 89] = \"quickSuggestionsDelay\";\n EditorOption[EditorOption[\"readOnly\"] = 90] = \"readOnly\";\n EditorOption[EditorOption[\"readOnlyMessage\"] = 91] = \"readOnlyMessage\";\n EditorOption[EditorOption[\"renameOnType\"] = 92] = \"renameOnType\";\n EditorOption[EditorOption[\"renderControlCharacters\"] = 93] = \"renderControlCharacters\";\n EditorOption[EditorOption[\"renderFinalNewline\"] = 94] = \"renderFinalNewline\";\n EditorOption[EditorOption[\"renderLineHighlight\"] = 95] = \"renderLineHighlight\";\n EditorOption[EditorOption[\"renderLineHighlightOnlyWhenFocus\"] = 96] = \"renderLineHighlightOnlyWhenFocus\";\n EditorOption[EditorOption[\"renderValidationDecorations\"] = 97] = \"renderValidationDecorations\";\n EditorOption[EditorOption[\"renderWhitespace\"] = 98] = \"renderWhitespace\";\n EditorOption[EditorOption[\"revealHorizontalRightPadding\"] = 99] = \"revealHorizontalRightPadding\";\n EditorOption[EditorOption[\"roundedSelection\"] = 100] = \"roundedSelection\";\n EditorOption[EditorOption[\"rulers\"] = 101] = \"rulers\";\n EditorOption[EditorOption[\"scrollbar\"] = 102] = \"scrollbar\";\n EditorOption[EditorOption[\"scrollBeyondLastColumn\"] = 103] = \"scrollBeyondLastColumn\";\n EditorOption[EditorOption[\"scrollBeyondLastLine\"] = 104] = \"scrollBeyondLastLine\";\n EditorOption[EditorOption[\"scrollPredominantAxis\"] = 105] = \"scrollPredominantAxis\";\n EditorOption[EditorOption[\"selectionClipboard\"] = 106] = \"selectionClipboard\";\n EditorOption[EditorOption[\"selectionHighlight\"] = 107] = \"selectionHighlight\";\n EditorOption[EditorOption[\"selectOnLineNumbers\"] = 108] = \"selectOnLineNumbers\";\n EditorOption[EditorOption[\"showFoldingControls\"] = 109] = \"showFoldingControls\";\n EditorOption[EditorOption[\"showUnused\"] = 110] = \"showUnused\";\n EditorOption[EditorOption[\"snippetSuggestions\"] = 111] = \"snippetSuggestions\";\n EditorOption[EditorOption[\"smartSelect\"] = 112] = \"smartSelect\";\n EditorOption[EditorOption[\"smoothScrolling\"] = 113] = \"smoothScrolling\";\n EditorOption[EditorOption[\"stickyScroll\"] = 114] = \"stickyScroll\";\n EditorOption[EditorOption[\"stickyTabStops\"] = 115] = \"stickyTabStops\";\n EditorOption[EditorOption[\"stopRenderingLineAfter\"] = 116] = \"stopRenderingLineAfter\";\n EditorOption[EditorOption[\"suggest\"] = 117] = \"suggest\";\n EditorOption[EditorOption[\"suggestFontSize\"] = 118] = \"suggestFontSize\";\n EditorOption[EditorOption[\"suggestLineHeight\"] = 119] = \"suggestLineHeight\";\n EditorOption[EditorOption[\"suggestOnTriggerCharacters\"] = 120] = \"suggestOnTriggerCharacters\";\n EditorOption[EditorOption[\"suggestSelection\"] = 121] = \"suggestSelection\";\n EditorOption[EditorOption[\"tabCompletion\"] = 122] = \"tabCompletion\";\n EditorOption[EditorOption[\"tabIndex\"] = 123] = \"tabIndex\";\n EditorOption[EditorOption[\"unicodeHighlighting\"] = 124] = \"unicodeHighlighting\";\n EditorOption[EditorOption[\"unusualLineTerminators\"] = 125] = \"unusualLineTerminators\";\n EditorOption[EditorOption[\"useShadowDOM\"] = 126] = \"useShadowDOM\";\n EditorOption[EditorOption[\"useTabStops\"] = 127] = \"useTabStops\";\n EditorOption[EditorOption[\"wordBreak\"] = 128] = \"wordBreak\";\n EditorOption[EditorOption[\"wordSeparators\"] = 129] = \"wordSeparators\";\n EditorOption[EditorOption[\"wordWrap\"] = 130] = \"wordWrap\";\n EditorOption[EditorOption[\"wordWrapBreakAfterCharacters\"] = 131] = \"wordWrapBreakAfterCharacters\";\n EditorOption[EditorOption[\"wordWrapBreakBeforeCharacters\"] = 132] = \"wordWrapBreakBeforeCharacters\";\n EditorOption[EditorOption[\"wordWrapColumn\"] = 133] = \"wordWrapColumn\";\n EditorOption[EditorOption[\"wordWrapOverride1\"] = 134] = \"wordWrapOverride1\";\n EditorOption[EditorOption[\"wordWrapOverride2\"] = 135] = \"wordWrapOverride2\";\n EditorOption[EditorOption[\"wrappingIndent\"] = 136] = \"wrappingIndent\";\n EditorOption[EditorOption[\"wrappingStrategy\"] = 137] = \"wrappingStrategy\";\n EditorOption[EditorOption[\"showDeprecated\"] = 138] = \"showDeprecated\";\n EditorOption[EditorOption[\"inlayHints\"] = 139] = \"inlayHints\";\n EditorOption[EditorOption[\"editorClassName\"] = 140] = \"editorClassName\";\n EditorOption[EditorOption[\"pixelRatio\"] = 141] = \"pixelRatio\";\n EditorOption[EditorOption[\"tabFocusMode\"] = 142] = \"tabFocusMode\";\n EditorOption[EditorOption[\"layoutInfo\"] = 143] = \"layoutInfo\";\n EditorOption[EditorOption[\"wrappingInfo\"] = 144] = \"wrappingInfo\";\n EditorOption[EditorOption[\"defaultColorDecorators\"] = 145] = \"defaultColorDecorators\";\n EditorOption[EditorOption[\"colorDecoratorsActivatedOn\"] = 146] = \"colorDecoratorsActivatedOn\";\n EditorOption[EditorOption[\"inlineCompletionsAccessibilityVerbose\"] = 147] = \"inlineCompletionsAccessibilityVerbose\";\n})(EditorOption || (EditorOption = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLinePreference;\n(function (EndOfLinePreference) {\n /**\n * Use the end of line character identified in the text buffer.\n */\n EndOfLinePreference[EndOfLinePreference[\"TextDefined\"] = 0] = \"TextDefined\";\n /**\n * Use line feed (\\n) as the end of line character.\n */\n EndOfLinePreference[EndOfLinePreference[\"LF\"] = 1] = \"LF\";\n /**\n * Use carriage return and line feed (\\r\\n) as the end of line character.\n */\n EndOfLinePreference[EndOfLinePreference[\"CRLF\"] = 2] = \"CRLF\";\n})(EndOfLinePreference || (EndOfLinePreference = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLineSequence;\n(function (EndOfLineSequence) {\n /**\n * Use line feed (\\n) as the end of line character.\n */\n EndOfLineSequence[EndOfLineSequence[\"LF\"] = 0] = \"LF\";\n /**\n * Use carriage return and line feed (\\r\\n) as the end of line character.\n */\n EndOfLineSequence[EndOfLineSequence[\"CRLF\"] = 1] = \"CRLF\";\n})(EndOfLineSequence || (EndOfLineSequence = {}));\n/**\n * Vertical Lane in the glyph margin of the editor.\n */\nexport var GlyphMarginLane;\n(function (GlyphMarginLane) {\n GlyphMarginLane[GlyphMarginLane[\"Left\"] = 1] = \"Left\";\n GlyphMarginLane[GlyphMarginLane[\"Right\"] = 2] = \"Right\";\n})(GlyphMarginLane || (GlyphMarginLane = {}));\n/**\n * Describes what to do with the indentation when pressing Enter.\n */\nexport var IndentAction;\n(function (IndentAction) {\n /**\n * Insert new line and copy the previous line's indentation.\n */\n IndentAction[IndentAction[\"None\"] = 0] = \"None\";\n /**\n * Insert new line and indent once (relative to the previous line's indentation).\n */\n IndentAction[IndentAction[\"Indent\"] = 1] = \"Indent\";\n /**\n * Insert two new lines:\n * - the first one indented which will hold the cursor\n * - the second one at the same indentation level\n */\n IndentAction[IndentAction[\"IndentOutdent\"] = 2] = \"IndentOutdent\";\n /**\n * Insert new line and outdent once (relative to the previous line's indentation).\n */\n IndentAction[IndentAction[\"Outdent\"] = 3] = \"Outdent\";\n})(IndentAction || (IndentAction = {}));\nexport var InjectedTextCursorStops;\n(function (InjectedTextCursorStops) {\n InjectedTextCursorStops[InjectedTextCursorStops[\"Both\"] = 0] = \"Both\";\n InjectedTextCursorStops[InjectedTextCursorStops[\"Right\"] = 1] = \"Right\";\n InjectedTextCursorStops[InjectedTextCursorStops[\"Left\"] = 2] = \"Left\";\n InjectedTextCursorStops[InjectedTextCursorStops[\"None\"] = 3] = \"None\";\n})(InjectedTextCursorStops || (InjectedTextCursorStops = {}));\nexport var InlayHintKind;\n(function (InlayHintKind) {\n InlayHintKind[InlayHintKind[\"Type\"] = 1] = \"Type\";\n InlayHintKind[InlayHintKind[\"Parameter\"] = 2] = \"Parameter\";\n})(InlayHintKind || (InlayHintKind = {}));\n/**\n * How an {@link InlineCompletionsProvider inline completion provider} was triggered.\n */\nexport var InlineCompletionTriggerKind;\n(function (InlineCompletionTriggerKind) {\n /**\n * Completion was triggered automatically while editing.\n * It is sufficient to return a single completion item in this case.\n */\n InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Automatic\"] = 0] = \"Automatic\";\n /**\n * Completion was triggered explicitly by a user gesture.\n * Return multiple completion items to enable cycling through them.\n */\n InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Explicit\"] = 1] = \"Explicit\";\n})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));\n/**\n * Virtual Key Codes, the value does not hold any inherent meaning.\n * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n * But these are \"more general\", as they should work across browsers & OS`s.\n */\nexport var KeyCode;\n(function (KeyCode) {\n KeyCode[KeyCode[\"DependsOnKbLayout\"] = -1] = \"DependsOnKbLayout\";\n /**\n * Placed first to cover the 0 value of the enum.\n */\n KeyCode[KeyCode[\"Unknown\"] = 0] = \"Unknown\";\n KeyCode[KeyCode[\"Backspace\"] = 1] = \"Backspace\";\n KeyCode[KeyCode[\"Tab\"] = 2] = \"Tab\";\n KeyCode[KeyCode[\"Enter\"] = 3] = \"Enter\";\n KeyCode[KeyCode[\"Shift\"] = 4] = \"Shift\";\n KeyCode[KeyCode[\"Ctrl\"] = 5] = \"Ctrl\";\n KeyCode[KeyCode[\"Alt\"] = 6] = \"Alt\";\n KeyCode[KeyCode[\"PauseBreak\"] = 7] = \"PauseBreak\";\n KeyCode[KeyCode[\"CapsLock\"] = 8] = \"CapsLock\";\n KeyCode[KeyCode[\"Escape\"] = 9] = \"Escape\";\n KeyCode[KeyCode[\"Space\"] = 10] = \"Space\";\n KeyCode[KeyCode[\"PageUp\"] = 11] = \"PageUp\";\n KeyCode[KeyCode[\"PageDown\"] = 12] = \"PageDown\";\n KeyCode[KeyCode[\"End\"] = 13] = \"End\";\n KeyCode[KeyCode[\"Home\"] = 14] = \"Home\";\n KeyCode[KeyCode[\"LeftArrow\"] = 15] = \"LeftArrow\";\n KeyCode[KeyCode[\"UpArrow\"] = 16] = \"UpArrow\";\n KeyCode[KeyCode[\"RightArrow\"] = 17] = \"RightArrow\";\n KeyCode[KeyCode[\"DownArrow\"] = 18] = \"DownArrow\";\n KeyCode[KeyCode[\"Insert\"] = 19] = \"Insert\";\n KeyCode[KeyCode[\"Delete\"] = 20] = \"Delete\";\n KeyCode[KeyCode[\"Digit0\"] = 21] = \"Digit0\";\n KeyCode[KeyCode[\"Digit1\"] = 22] = \"Digit1\";\n KeyCode[KeyCode[\"Digit2\"] = 23] = \"Digit2\";\n KeyCode[KeyCode[\"Digit3\"] = 24] = \"Digit3\";\n KeyCode[KeyCode[\"Digit4\"] = 25] = \"Digit4\";\n KeyCode[KeyCode[\"Digit5\"] = 26] = \"Digit5\";\n KeyCode[KeyCode[\"Digit6\"] = 27] = \"Digit6\";\n KeyCode[KeyCode[\"Digit7\"] = 28] = \"Digit7\";\n KeyCode[KeyCode[\"Digit8\"] = 29] = \"Digit8\";\n KeyCode[KeyCode[\"Digit9\"] = 30] = \"Digit9\";\n KeyCode[KeyCode[\"KeyA\"] = 31] = \"KeyA\";\n KeyCode[KeyCode[\"KeyB\"] = 32] = \"KeyB\";\n KeyCode[KeyCode[\"KeyC\"] = 33] = \"KeyC\";\n KeyCode[KeyCode[\"KeyD\"] = 34] = \"KeyD\";\n KeyCode[KeyCode[\"KeyE\"] = 35] = \"KeyE\";\n KeyCode[KeyCode[\"KeyF\"] = 36] = \"KeyF\";\n KeyCode[KeyCode[\"KeyG\"] = 37] = \"KeyG\";\n KeyCode[KeyCode[\"KeyH\"] = 38] = \"KeyH\";\n KeyCode[KeyCode[\"KeyI\"] = 39] = \"KeyI\";\n KeyCode[KeyCode[\"KeyJ\"] = 40] = \"KeyJ\";\n KeyCode[KeyCode[\"KeyK\"] = 41] = \"KeyK\";\n KeyCode[KeyCode[\"KeyL\"] = 42] = \"KeyL\";\n KeyCode[KeyCode[\"KeyM\"] = 43] = \"KeyM\";\n KeyCode[KeyCode[\"KeyN\"] = 44] = \"KeyN\";\n KeyCode[KeyCode[\"KeyO\"] = 45] = \"KeyO\";\n KeyCode[KeyCode[\"KeyP\"] = 46] = \"KeyP\";\n KeyCode[KeyCode[\"KeyQ\"] = 47] = \"KeyQ\";\n KeyCode[KeyCode[\"KeyR\"] = 48] = \"KeyR\";\n KeyCode[KeyCode[\"KeyS\"] = 49] = \"KeyS\";\n KeyCode[KeyCode[\"KeyT\"] = 50] = \"KeyT\";\n KeyCode[KeyCode[\"KeyU\"] = 51] = \"KeyU\";\n KeyCode[KeyCode[\"KeyV\"] = 52] = \"KeyV\";\n KeyCode[KeyCode[\"KeyW\"] = 53] = \"KeyW\";\n KeyCode[KeyCode[\"KeyX\"] = 54] = \"KeyX\";\n KeyCode[KeyCode[\"KeyY\"] = 55] = \"KeyY\";\n KeyCode[KeyCode[\"KeyZ\"] = 56] = \"KeyZ\";\n KeyCode[KeyCode[\"Meta\"] = 57] = \"Meta\";\n KeyCode[KeyCode[\"ContextMenu\"] = 58] = \"ContextMenu\";\n KeyCode[KeyCode[\"F1\"] = 59] = \"F1\";\n KeyCode[KeyCode[\"F2\"] = 60] = \"F2\";\n KeyCode[KeyCode[\"F3\"] = 61] = \"F3\";\n KeyCode[KeyCode[\"F4\"] = 62] = \"F4\";\n KeyCode[KeyCode[\"F5\"] = 63] = \"F5\";\n KeyCode[KeyCode[\"F6\"] = 64] = \"F6\";\n KeyCode[KeyCode[\"F7\"] = 65] = \"F7\";\n KeyCode[KeyCode[\"F8\"] = 66] = \"F8\";\n KeyCode[KeyCode[\"F9\"] = 67] = \"F9\";\n KeyCode[KeyCode[\"F10\"] = 68] = \"F10\";\n KeyCode[KeyCode[\"F11\"] = 69] = \"F11\";\n KeyCode[KeyCode[\"F12\"] = 70] = \"F12\";\n KeyCode[KeyCode[\"F13\"] = 71] = \"F13\";\n KeyCode[KeyCode[\"F14\"] = 72] = \"F14\";\n KeyCode[KeyCode[\"F15\"] = 73] = \"F15\";\n KeyCode[KeyCode[\"F16\"] = 74] = \"F16\";\n KeyCode[KeyCode[\"F17\"] = 75] = \"F17\";\n KeyCode[KeyCode[\"F18\"] = 76] = \"F18\";\n KeyCode[KeyCode[\"F19\"] = 77] = \"F19\";\n KeyCode[KeyCode[\"F20\"] = 78] = \"F20\";\n KeyCode[KeyCode[\"F21\"] = 79] = \"F21\";\n KeyCode[KeyCode[\"F22\"] = 80] = \"F22\";\n KeyCode[KeyCode[\"F23\"] = 81] = \"F23\";\n KeyCode[KeyCode[\"F24\"] = 82] = \"F24\";\n KeyCode[KeyCode[\"NumLock\"] = 83] = \"NumLock\";\n KeyCode[KeyCode[\"ScrollLock\"] = 84] = \"ScrollLock\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n * For the US standard keyboard, the ';:' key\n */\n KeyCode[KeyCode[\"Semicolon\"] = 85] = \"Semicolon\";\n /**\n * For any country/region, the '+' key\n * For the US standard keyboard, the '=+' key\n */\n KeyCode[KeyCode[\"Equal\"] = 86] = \"Equal\";\n /**\n * For any country/region, the ',' key\n * For the US standard keyboard, the ',<' key\n */\n KeyCode[KeyCode[\"Comma\"] = 87] = \"Comma\";\n /**\n * For any country/region, the '-' key\n * For the US standard keyboard, the '-_' key\n */\n KeyCode[KeyCode[\"Minus\"] = 88] = \"Minus\";\n /**\n * For any country/region, the '.' key\n * For the US standard keyboard, the '.>' key\n */\n KeyCode[KeyCode[\"Period\"] = 89] = \"Period\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n * For the US standard keyboard, the '/?' key\n */\n KeyCode[KeyCode[\"Slash\"] = 90] = \"Slash\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n * For the US standard keyboard, the '`~' key\n */\n KeyCode[KeyCode[\"Backquote\"] = 91] = \"Backquote\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n * For the US standard keyboard, the '[{' key\n */\n KeyCode[KeyCode[\"BracketLeft\"] = 92] = \"BracketLeft\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n * For the US standard keyboard, the '\\|' key\n */\n KeyCode[KeyCode[\"Backslash\"] = 93] = \"Backslash\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n * For the US standard keyboard, the ']}' key\n */\n KeyCode[KeyCode[\"BracketRight\"] = 94] = \"BracketRight\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n * For the US standard keyboard, the ''\"' key\n */\n KeyCode[KeyCode[\"Quote\"] = 95] = \"Quote\";\n /**\n * Used for miscellaneous characters; it can vary by keyboard.\n */\n KeyCode[KeyCode[\"OEM_8\"] = 96] = \"OEM_8\";\n /**\n * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\n */\n KeyCode[KeyCode[\"IntlBackslash\"] = 97] = \"IntlBackslash\";\n KeyCode[KeyCode[\"Numpad0\"] = 98] = \"Numpad0\";\n KeyCode[KeyCode[\"Numpad1\"] = 99] = \"Numpad1\";\n KeyCode[KeyCode[\"Numpad2\"] = 100] = \"Numpad2\";\n KeyCode[KeyCode[\"Numpad3\"] = 101] = \"Numpad3\";\n KeyCode[KeyCode[\"Numpad4\"] = 102] = \"Numpad4\";\n KeyCode[KeyCode[\"Numpad5\"] = 103] = \"Numpad5\";\n KeyCode[KeyCode[\"Numpad6\"] = 104] = \"Numpad6\";\n KeyCode[KeyCode[\"Numpad7\"] = 105] = \"Numpad7\";\n KeyCode[KeyCode[\"Numpad8\"] = 106] = \"Numpad8\";\n KeyCode[KeyCode[\"Numpad9\"] = 107] = \"Numpad9\";\n KeyCode[KeyCode[\"NumpadMultiply\"] = 108] = \"NumpadMultiply\";\n KeyCode[KeyCode[\"NumpadAdd\"] = 109] = \"NumpadAdd\";\n KeyCode[KeyCode[\"NUMPAD_SEPARATOR\"] = 110] = \"NUMPAD_SEPARATOR\";\n KeyCode[KeyCode[\"NumpadSubtract\"] = 111] = \"NumpadSubtract\";\n KeyCode[KeyCode[\"NumpadDecimal\"] = 112] = \"NumpadDecimal\";\n KeyCode[KeyCode[\"NumpadDivide\"] = 113] = \"NumpadDivide\";\n /**\n * Cover all key codes when IME is processing input.\n */\n KeyCode[KeyCode[\"KEY_IN_COMPOSITION\"] = 114] = \"KEY_IN_COMPOSITION\";\n KeyCode[KeyCode[\"ABNT_C1\"] = 115] = \"ABNT_C1\";\n KeyCode[KeyCode[\"ABNT_C2\"] = 116] = \"ABNT_C2\";\n KeyCode[KeyCode[\"AudioVolumeMute\"] = 117] = \"AudioVolumeMute\";\n KeyCode[KeyCode[\"AudioVolumeUp\"] = 118] = \"AudioVolumeUp\";\n KeyCode[KeyCode[\"AudioVolumeDown\"] = 119] = \"AudioVolumeDown\";\n KeyCode[KeyCode[\"BrowserSearch\"] = 120] = \"BrowserSearch\";\n KeyCode[KeyCode[\"BrowserHome\"] = 121] = \"BrowserHome\";\n KeyCode[KeyCode[\"BrowserBack\"] = 122] = \"BrowserBack\";\n KeyCode[KeyCode[\"BrowserForward\"] = 123] = \"BrowserForward\";\n KeyCode[KeyCode[\"MediaTrackNext\"] = 124] = \"MediaTrackNext\";\n KeyCode[KeyCode[\"MediaTrackPrevious\"] = 125] = \"MediaTrackPrevious\";\n KeyCode[KeyCode[\"MediaStop\"] = 126] = \"MediaStop\";\n KeyCode[KeyCode[\"MediaPlayPause\"] = 127] = \"MediaPlayPause\";\n KeyCode[KeyCode[\"LaunchMediaPlayer\"] = 128] = \"LaunchMediaPlayer\";\n KeyCode[KeyCode[\"LaunchMail\"] = 129] = \"LaunchMail\";\n KeyCode[KeyCode[\"LaunchApp2\"] = 130] = \"LaunchApp2\";\n /**\n * VK_CLEAR, 0x0C, CLEAR key\n */\n KeyCode[KeyCode[\"Clear\"] = 131] = \"Clear\";\n /**\n * Placed last to cover the length of the enum.\n * Please do not depend on this value!\n */\n KeyCode[KeyCode[\"MAX_VALUE\"] = 132] = \"MAX_VALUE\";\n})(KeyCode || (KeyCode = {}));\nexport var MarkerSeverity;\n(function (MarkerSeverity) {\n MarkerSeverity[MarkerSeverity[\"Hint\"] = 1] = \"Hint\";\n MarkerSeverity[MarkerSeverity[\"Info\"] = 2] = \"Info\";\n MarkerSeverity[MarkerSeverity[\"Warning\"] = 4] = \"Warning\";\n MarkerSeverity[MarkerSeverity[\"Error\"] = 8] = \"Error\";\n})(MarkerSeverity || (MarkerSeverity = {}));\nexport var MarkerTag;\n(function (MarkerTag) {\n MarkerTag[MarkerTag[\"Unnecessary\"] = 1] = \"Unnecessary\";\n MarkerTag[MarkerTag[\"Deprecated\"] = 2] = \"Deprecated\";\n})(MarkerTag || (MarkerTag = {}));\n/**\n * Position in the minimap to render the decoration.\n */\nexport var MinimapPosition;\n(function (MinimapPosition) {\n MinimapPosition[MinimapPosition[\"Inline\"] = 1] = \"Inline\";\n MinimapPosition[MinimapPosition[\"Gutter\"] = 2] = \"Gutter\";\n})(MinimapPosition || (MinimapPosition = {}));\n/**\n * Type of hit element with the mouse in the editor.\n */\nexport var MouseTargetType;\n(function (MouseTargetType) {\n /**\n * Mouse is on top of an unknown element.\n */\n MouseTargetType[MouseTargetType[\"UNKNOWN\"] = 0] = \"UNKNOWN\";\n /**\n * Mouse is on top of the textarea used for input.\n */\n MouseTargetType[MouseTargetType[\"TEXTAREA\"] = 1] = \"TEXTAREA\";\n /**\n * Mouse is on top of the glyph margin\n */\n MouseTargetType[MouseTargetType[\"GUTTER_GLYPH_MARGIN\"] = 2] = \"GUTTER_GLYPH_MARGIN\";\n /**\n * Mouse is on top of the line numbers\n */\n MouseTargetType[MouseTargetType[\"GUTTER_LINE_NUMBERS\"] = 3] = \"GUTTER_LINE_NUMBERS\";\n /**\n * Mouse is on top of the line decorations\n */\n MouseTargetType[MouseTargetType[\"GUTTER_LINE_DECORATIONS\"] = 4] = \"GUTTER_LINE_DECORATIONS\";\n /**\n * Mouse is on top of the whitespace left in the gutter by a view zone.\n */\n MouseTargetType[MouseTargetType[\"GUTTER_VIEW_ZONE\"] = 5] = \"GUTTER_VIEW_ZONE\";\n /**\n * Mouse is on top of text in the content.\n */\n MouseTargetType[MouseTargetType[\"CONTENT_TEXT\"] = 6] = \"CONTENT_TEXT\";\n /**\n * Mouse is on top of empty space in the content (e.g. after line text or below last line)\n */\n MouseTargetType[MouseTargetType[\"CONTENT_EMPTY\"] = 7] = \"CONTENT_EMPTY\";\n /**\n * Mouse is on top of a view zone in the content.\n */\n MouseTargetType[MouseTargetType[\"CONTENT_VIEW_ZONE\"] = 8] = \"CONTENT_VIEW_ZONE\";\n /**\n * Mouse is on top of a content widget.\n */\n MouseTargetType[MouseTargetType[\"CONTENT_WIDGET\"] = 9] = \"CONTENT_WIDGET\";\n /**\n * Mouse is on top of the decorations overview ruler.\n */\n MouseTargetType[MouseTargetType[\"OVERVIEW_RULER\"] = 10] = \"OVERVIEW_RULER\";\n /**\n * Mouse is on top of a scrollbar.\n */\n MouseTargetType[MouseTargetType[\"SCROLLBAR\"] = 11] = \"SCROLLBAR\";\n /**\n * Mouse is on top of an overlay widget.\n */\n MouseTargetType[MouseTargetType[\"OVERLAY_WIDGET\"] = 12] = \"OVERLAY_WIDGET\";\n /**\n * Mouse is outside of the editor.\n */\n MouseTargetType[MouseTargetType[\"OUTSIDE_EDITOR\"] = 13] = \"OUTSIDE_EDITOR\";\n})(MouseTargetType || (MouseTargetType = {}));\n/**\n * A positioning preference for rendering overlay widgets.\n */\nexport var OverlayWidgetPositionPreference;\n(function (OverlayWidgetPositionPreference) {\n /**\n * Position the overlay widget in the top right corner\n */\n OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_RIGHT_CORNER\"] = 0] = \"TOP_RIGHT_CORNER\";\n /**\n * Position the overlay widget in the bottom right corner\n */\n OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"BOTTOM_RIGHT_CORNER\"] = 1] = \"BOTTOM_RIGHT_CORNER\";\n /**\n * Position the overlay widget in the top center\n */\n OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_CENTER\"] = 2] = \"TOP_CENTER\";\n})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {}));\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nexport var OverviewRulerLane;\n(function (OverviewRulerLane) {\n OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\n OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\n OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\n OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\nexport var PositionAffinity;\n(function (PositionAffinity) {\n /**\n * Prefers the left most position.\n */\n PositionAffinity[PositionAffinity[\"Left\"] = 0] = \"Left\";\n /**\n * Prefers the right most position.\n */\n PositionAffinity[PositionAffinity[\"Right\"] = 1] = \"Right\";\n /**\n * No preference.\n */\n PositionAffinity[PositionAffinity[\"None\"] = 2] = \"None\";\n /**\n * If the given position is on injected text, prefers the position left of it.\n */\n PositionAffinity[PositionAffinity[\"LeftOfInjectedText\"] = 3] = \"LeftOfInjectedText\";\n /**\n * If the given position is on injected text, prefers the position right of it.\n */\n PositionAffinity[PositionAffinity[\"RightOfInjectedText\"] = 4] = \"RightOfInjectedText\";\n})(PositionAffinity || (PositionAffinity = {}));\nexport var RenderLineNumbersType;\n(function (RenderLineNumbersType) {\n RenderLineNumbersType[RenderLineNumbersType[\"Off\"] = 0] = \"Off\";\n RenderLineNumbersType[RenderLineNumbersType[\"On\"] = 1] = \"On\";\n RenderLineNumbersType[RenderLineNumbersType[\"Relative\"] = 2] = \"Relative\";\n RenderLineNumbersType[RenderLineNumbersType[\"Interval\"] = 3] = \"Interval\";\n RenderLineNumbersType[RenderLineNumbersType[\"Custom\"] = 4] = \"Custom\";\n})(RenderLineNumbersType || (RenderLineNumbersType = {}));\nexport var RenderMinimap;\n(function (RenderMinimap) {\n RenderMinimap[RenderMinimap[\"None\"] = 0] = \"None\";\n RenderMinimap[RenderMinimap[\"Text\"] = 1] = \"Text\";\n RenderMinimap[RenderMinimap[\"Blocks\"] = 2] = \"Blocks\";\n})(RenderMinimap || (RenderMinimap = {}));\nexport var ScrollType;\n(function (ScrollType) {\n ScrollType[ScrollType[\"Smooth\"] = 0] = \"Smooth\";\n ScrollType[ScrollType[\"Immediate\"] = 1] = \"Immediate\";\n})(ScrollType || (ScrollType = {}));\nexport var ScrollbarVisibility;\n(function (ScrollbarVisibility) {\n ScrollbarVisibility[ScrollbarVisibility[\"Auto\"] = 1] = \"Auto\";\n ScrollbarVisibility[ScrollbarVisibility[\"Hidden\"] = 2] = \"Hidden\";\n ScrollbarVisibility[ScrollbarVisibility[\"Visible\"] = 3] = \"Visible\";\n})(ScrollbarVisibility || (ScrollbarVisibility = {}));\n/**\n * The direction of a selection.\n */\nexport var SelectionDirection;\n(function (SelectionDirection) {\n /**\n * The selection starts above where it ends.\n */\n SelectionDirection[SelectionDirection[\"LTR\"] = 0] = \"LTR\";\n /**\n * The selection starts below where it ends.\n */\n SelectionDirection[SelectionDirection[\"RTL\"] = 1] = \"RTL\";\n})(SelectionDirection || (SelectionDirection = {}));\nexport var ShowAiIconMode;\n(function (ShowAiIconMode) {\n ShowAiIconMode[\"Off\"] = \"off\";\n ShowAiIconMode[\"OnCode\"] = \"onCode\";\n ShowAiIconMode[\"On\"] = \"on\";\n})(ShowAiIconMode || (ShowAiIconMode = {}));\nexport var SignatureHelpTriggerKind;\n(function (SignatureHelpTriggerKind) {\n SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"Invoke\"] = 1] = \"Invoke\";\n SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"TriggerCharacter\"] = 2] = \"TriggerCharacter\";\n SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"ContentChange\"] = 3] = \"ContentChange\";\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\n/**\n * A symbol kind.\n */\nexport var SymbolKind;\n(function (SymbolKind) {\n SymbolKind[SymbolKind[\"File\"] = 0] = \"File\";\n SymbolKind[SymbolKind[\"Module\"] = 1] = \"Module\";\n SymbolKind[SymbolKind[\"Namespace\"] = 2] = \"Namespace\";\n SymbolKind[SymbolKind[\"Package\"] = 3] = \"Package\";\n SymbolKind[SymbolKind[\"Class\"] = 4] = \"Class\";\n SymbolKind[SymbolKind[\"Method\"] = 5] = \"Method\";\n SymbolKind[SymbolKind[\"Property\"] = 6] = \"Property\";\n SymbolKind[SymbolKind[\"Field\"] = 7] = \"Field\";\n SymbolKind[SymbolKind[\"Constructor\"] = 8] = \"Constructor\";\n SymbolKind[SymbolKind[\"Enum\"] = 9] = \"Enum\";\n SymbolKind[SymbolKind[\"Interface\"] = 10] = \"Interface\";\n SymbolKind[SymbolKind[\"Function\"] = 11] = \"Function\";\n SymbolKind[SymbolKind[\"Variable\"] = 12] = \"Variable\";\n SymbolKind[SymbolKind[\"Constant\"] = 13] = \"Constant\";\n SymbolKind[SymbolKind[\"String\"] = 14] = \"String\";\n SymbolKind[SymbolKind[\"Number\"] = 15] = \"Number\";\n SymbolKind[SymbolKind[\"Boolean\"] = 16] = \"Boolean\";\n SymbolKind[SymbolKind[\"Array\"] = 17] = \"Array\";\n SymbolKind[SymbolKind[\"Object\"] = 18] = \"Object\";\n SymbolKind[SymbolKind[\"Key\"] = 19] = \"Key\";\n SymbolKind[SymbolKind[\"Null\"] = 20] = \"Null\";\n SymbolKind[SymbolKind[\"EnumMember\"] = 21] = \"EnumMember\";\n SymbolKind[SymbolKind[\"Struct\"] = 22] = \"Struct\";\n SymbolKind[SymbolKind[\"Event\"] = 23] = \"Event\";\n SymbolKind[SymbolKind[\"Operator\"] = 24] = \"Operator\";\n SymbolKind[SymbolKind[\"TypeParameter\"] = 25] = \"TypeParameter\";\n})(SymbolKind || (SymbolKind = {}));\nexport var SymbolTag;\n(function (SymbolTag) {\n SymbolTag[SymbolTag[\"Deprecated\"] = 1] = \"Deprecated\";\n})(SymbolTag || (SymbolTag = {}));\n/**\n * The kind of animation in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorBlinkingStyle;\n(function (TextEditorCursorBlinkingStyle) {\n /**\n * Hidden\n */\n TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Hidden\"] = 0] = \"Hidden\";\n /**\n * Blinking\n */\n TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Blink\"] = 1] = \"Blink\";\n /**\n * Blinking with smooth fading\n */\n TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Smooth\"] = 2] = \"Smooth\";\n /**\n * Blinking with prolonged filled state and smooth fading\n */\n TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Phase\"] = 3] = \"Phase\";\n /**\n * Expand collapse animation on the y axis\n */\n TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Expand\"] = 4] = \"Expand\";\n /**\n * No-Blinking\n */\n TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Solid\"] = 5] = \"Solid\";\n})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {}));\n/**\n * The style in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorStyle;\n(function (TextEditorCursorStyle) {\n /**\n * As a vertical line (sitting between two characters).\n */\n TextEditorCursorStyle[TextEditorCursorStyle[\"Line\"] = 1] = \"Line\";\n /**\n * As a block (sitting on top of a character).\n */\n TextEditorCursorStyle[TextEditorCursorStyle[\"Block\"] = 2] = \"Block\";\n /**\n * As a horizontal line (sitting under a character).\n */\n TextEditorCursorStyle[TextEditorCursorStyle[\"Underline\"] = 3] = \"Underline\";\n /**\n * As a thin vertical line (sitting between two characters).\n */\n TextEditorCursorStyle[TextEditorCursorStyle[\"LineThin\"] = 4] = \"LineThin\";\n /**\n * As an outlined block (sitting on top of a character).\n */\n TextEditorCursorStyle[TextEditorCursorStyle[\"BlockOutline\"] = 5] = \"BlockOutline\";\n /**\n * As a thin horizontal line (sitting under a character).\n */\n TextEditorCursorStyle[TextEditorCursorStyle[\"UnderlineThin\"] = 6] = \"UnderlineThin\";\n})(TextEditorCursorStyle || (TextEditorCursorStyle = {}));\n/**\n * Describes the behavior of decorations when typing/editing near their edges.\n * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`\n */\nexport var TrackedRangeStickiness;\n(function (TrackedRangeStickiness) {\n TrackedRangeStickiness[TrackedRangeStickiness[\"AlwaysGrowsWhenTypingAtEdges\"] = 0] = \"AlwaysGrowsWhenTypingAtEdges\";\n TrackedRangeStickiness[TrackedRangeStickiness[\"NeverGrowsWhenTypingAtEdges\"] = 1] = \"NeverGrowsWhenTypingAtEdges\";\n TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingBefore\"] = 2] = \"GrowsOnlyWhenTypingBefore\";\n TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingAfter\"] = 3] = \"GrowsOnlyWhenTypingAfter\";\n})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));\n/**\n * Describes how to indent wrapped lines.\n */\nexport var WrappingIndent;\n(function (WrappingIndent) {\n /**\n * No indentation => wrapped lines begin at column 1.\n */\n WrappingIndent[WrappingIndent[\"None\"] = 0] = \"None\";\n /**\n * Same => wrapped lines get the same indentation as the parent.\n */\n WrappingIndent[WrappingIndent[\"Same\"] = 1] = \"Same\";\n /**\n * Indent => wrapped lines get +1 indentation toward the parent.\n */\n WrappingIndent[WrappingIndent[\"Indent\"] = 2] = \"Indent\";\n /**\n * DeepIndent => wrapped lines get +2 indentation toward the parent.\n */\n WrappingIndent[WrappingIndent[\"DeepIndent\"] = 3] = \"DeepIndent\";\n})(WrappingIndent || (WrappingIndent = {}));\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter } from '../../base/common/event.js';\nimport { Disposable, toDisposable } from '../../base/common/lifecycle.js';\nexport class TokenizationRegistry {\n constructor() {\n this._tokenizationSupports = new Map();\n this._factories = new Map();\n this._onDidChange = new Emitter();\n this.onDidChange = this._onDidChange.event;\n this._colorMap = null;\n }\n handleChange(languageIds) {\n this._onDidChange.fire({\n changedLanguages: languageIds,\n changedColorMap: false\n });\n }\n register(languageId, support) {\n this._tokenizationSupports.set(languageId, support);\n this.handleChange([languageId]);\n return toDisposable(() => {\n if (this._tokenizationSupports.get(languageId) !== support) {\n return;\n }\n this._tokenizationSupports.delete(languageId);\n this.handleChange([languageId]);\n });\n }\n get(languageId) {\n return this._tokenizationSupports.get(languageId) || null;\n }\n registerFactory(languageId, factory) {\n var _a;\n (_a = this._factories.get(languageId)) === null || _a === void 0 ? void 0 : _a.dispose();\n const myData = new TokenizationSupportFactoryData(this, languageId, factory);\n this._factories.set(languageId, myData);\n return toDisposable(() => {\n const v = this._factories.get(languageId);\n if (!v || v !== myData) {\n return;\n }\n this._factories.delete(languageId);\n v.dispose();\n });\n }\n async getOrCreate(languageId) {\n // check first if the support is already set\n const tokenizationSupport = this.get(languageId);\n if (tokenizationSupport) {\n return tokenizationSupport;\n }\n const factory = this._factories.get(languageId);\n if (!factory || factory.isResolved) {\n // no factory or factory.resolve already finished\n return null;\n }\n await factory.resolve();\n return this.get(languageId);\n }\n isResolved(languageId) {\n const tokenizationSupport = this.get(languageId);\n if (tokenizationSupport) {\n return true;\n }\n const factory = this._factories.get(languageId);\n if (!factory || factory.isResolved) {\n return true;\n }\n return false;\n }\n setColorMap(colorMap) {\n this._colorMap = colorMap;\n this._onDidChange.fire({\n changedLanguages: Array.from(this._tokenizationSupports.keys()),\n changedColorMap: true\n });\n }\n getColorMap() {\n return this._colorMap;\n }\n getDefaultBackground() {\n if (this._colorMap && this._colorMap.length > 2 /* ColorId.DefaultBackground */) {\n return this._colorMap[2 /* ColorId.DefaultBackground */];\n }\n return null;\n }\n}\nclass TokenizationSupportFactoryData extends Disposable {\n get isResolved() {\n return this._isResolved;\n }\n constructor(_registry, _languageId, _factory) {\n super();\n this._registry = _registry;\n this._languageId = _languageId;\n this._factory = _factory;\n this._isDisposed = false;\n this._resolvePromise = null;\n this._isResolved = false;\n }\n dispose() {\n this._isDisposed = true;\n super.dispose();\n }\n async resolve() {\n if (!this._resolvePromise) {\n this._resolvePromise = this._create();\n }\n return this._resolvePromise;\n }\n async _create() {\n const value = await this._factory.tokenizationSupport;\n this._isResolved = true;\n if (value && !this._isDisposed) {\n this._register(this._registry.register(this._languageId, value));\n }\n }\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nlet isPseudo = (typeof document !== 'undefined' && document.location && document.location.hash.indexOf('pseudo=true') >= 0);\nconst DEFAULT_TAG = 'i-default';\nfunction _format(message, args) {\n let result;\n if (args.length === 0) {\n result = message;\n }\n else {\n result = message.replace(/\\{(\\d+)\\}/g, (match, rest) => {\n const index = rest[0];\n const arg = args[index];\n let result = match;\n if (typeof arg === 'string') {\n result = arg;\n }\n else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) {\n result = String(arg);\n }\n return result;\n });\n }\n if (isPseudo) {\n // FF3B and FF3D is the Unicode zenkaku representation for [ and ]\n result = '\\uFF3B' + result.replace(/[aouei]/g, '$&$&') + '\\uFF3D';\n }\n return result;\n}\nfunction findLanguageForModule(config, name) {\n let result = config[name];\n if (result) {\n return result;\n }\n result = config['*'];\n if (result) {\n return result;\n }\n return null;\n}\nfunction endWithSlash(path) {\n if (path.charAt(path.length - 1) === '/') {\n return path;\n }\n return path + '/';\n}\nasync function getMessagesFromTranslationsService(translationServiceUrl, language, name) {\n const url = endWithSlash(translationServiceUrl) + endWithSlash(language) + 'vscode/' + endWithSlash(name);\n const res = await fetch(url);\n if (res.ok) {\n const messages = await res.json();\n return messages;\n }\n throw new Error(`${res.status} - ${res.statusText}`);\n}\nfunction createScopedLocalize(scope) {\n return function (idx, defaultValue) {\n const restArgs = Array.prototype.slice.call(arguments, 2);\n return _format(scope[idx], restArgs);\n };\n}\nfunction createScopedLocalize2(scope) {\n return (idx, defaultValue, ...args) => ({\n value: _format(scope[idx], args),\n original: _format(defaultValue, args)\n });\n}\n/**\n * @skipMangle\n */\nexport function localize(data, message, ...args) {\n return _format(message, args);\n}\n/**\n * @skipMangle\n */\nexport function localize2(data, message, ...args) {\n const original = _format(message, args);\n return {\n value: original,\n original\n };\n}\n/**\n * @skipMangle\n */\nexport function getConfiguredDefaultLocale(_) {\n // This returns undefined because this implementation isn't used and is overwritten by the loader\n // when loaded.\n return undefined;\n}\n/**\n * @skipMangle\n */\nexport function setPseudoTranslation(value) {\n isPseudo = value;\n}\n/**\n * Invoked in a built product at run-time\n * @skipMangle\n */\nexport function create(key, data) {\n var _a;\n return {\n localize: createScopedLocalize(data[key]),\n localize2: createScopedLocalize2(data[key]),\n getConfiguredDefaultLocale: (_a = data.getConfiguredDefaultLocale) !== null && _a !== void 0 ? _a : ((_) => undefined)\n };\n}\n/**\n * Invoked by the loader at run-time\n * @skipMangle\n */\nexport function load(name, req, load, config) {\n var _a;\n const pluginConfig = (_a = config['vs/nls']) !== null && _a !== void 0 ? _a : {};\n if (!name || name.length === 0) {\n // TODO: We need to give back the mangled names here\n return load({\n localize: localize,\n localize2: localize2,\n getConfiguredDefaultLocale: () => { var _a; return (_a = pluginConfig.availableLanguages) === null || _a === void 0 ? void 0 : _a['*']; }\n });\n }\n const language = pluginConfig.availableLanguages ? findLanguageForModule(pluginConfig.availableLanguages, name) : null;\n const useDefaultLanguage = language === null || language === DEFAULT_TAG;\n let suffix = '.nls';\n if (!useDefaultLanguage) {\n suffix = suffix + '.' + language;\n }\n const messagesLoaded = (messages) => {\n if (Array.isArray(messages)) {\n messages.localize = createScopedLocalize(messages);\n messages.localize2 = createScopedLocalize2(messages);\n }\n else {\n messages.localize = createScopedLocalize(messages[name]);\n messages.localize2 = createScopedLocalize2(messages[name]);\n }\n messages.getConfiguredDefaultLocale = () => { var _a; return (_a = pluginConfig.availableLanguages) === null || _a === void 0 ? void 0 : _a['*']; };\n load(messages);\n };\n if (typeof pluginConfig.loadBundle === 'function') {\n pluginConfig.loadBundle(name, language, (err, messages) => {\n // We have an error. Load the English default strings to not fail\n if (err) {\n req([name + '.nls'], messagesLoaded);\n }\n else {\n messagesLoaded(messages);\n }\n });\n }\n else if (pluginConfig.translationServiceUrl && !useDefaultLanguage) {\n (async () => {\n var _a;\n try {\n const messages = await getMessagesFromTranslationsService(pluginConfig.translationServiceUrl, language, name);\n return messagesLoaded(messages);\n }\n catch (err) {\n // Language is already as generic as it gets, so require default messages\n if (!language.includes('-')) {\n console.error(err);\n return req([name + '.nls'], messagesLoaded);\n }\n try {\n // Since there is a dash, the language configured is a specific sub-language of the same generic language.\n // Since we were unable to load the specific language, try to load the generic language. Ex. we failed to find a\n // Swiss German (de-CH), so try to load the generic German (de) messages instead.\n const genericLanguage = language.split('-')[0];\n const messages = await getMessagesFromTranslationsService(pluginConfig.translationServiceUrl, genericLanguage, name);\n // We got some messages, so we configure the configuration to use the generic language for this session.\n (_a = pluginConfig.availableLanguages) !== null && _a !== void 0 ? _a : (pluginConfig.availableLanguages = {});\n pluginConfig.availableLanguages['*'] = genericLanguage;\n return messagesLoaded(messages);\n }\n catch (err) {\n console.error(err);\n return req([name + '.nls'], messagesLoaded);\n }\n }\n })();\n }\n else {\n req([name + suffix], messagesLoaded, (err) => {\n if (suffix === '.nls') {\n console.error('Failed trying to load default language strings', err);\n return;\n }\n console.error(`Failed to load message bundle for language ${language}. Falling back to the default language:`, err);\n req([name + '.nls'], messagesLoaded);\n });\n }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { SimpleWorkerServer } from '../base/common/worker/simpleWorker.js';\nimport { EditorSimpleWorker } from './common/services/editorSimpleWorker.js';\nlet initialized = false;\nexport function initialize(foreignModule) {\n if (initialized) {\n return;\n }\n initialized = true;\n const simpleWorker = new SimpleWorkerServer((msg) => {\n globalThis.postMessage(msg);\n }, (host) => new EditorSimpleWorker(host, foreignModule));\n globalThis.onmessage = (e) => {\n simpleWorker.onmessage(e.data);\n };\n}\nglobalThis.onmessage = (e) => {\n // Ignore first message in this case and initialize if not yet initialized\n if (!initialized) {\n initialize(null);\n }\n};\n"],"names":[],"sourceRoot":""} \ No newline at end of file diff --git a/dist/examples.json b/dist/examples.json new file mode 100644 index 00000000..7b250148 --- /dev/null +++ b/dist/examples.json @@ -0,0 +1 @@ +{"path":"./src/static/examples","name":"examples","children":[{"path":"examples/ambisonics","name":"ambisonics","children":[{"path":"examples/ambisonics/fourSourcesToOcto.dsp","name":"fourSourcesToOcto.dsp","size":981,"extension":".dsp","type":"file"},{"path":"examples/ambisonics/oneSourceToStereo.dsp","name":"oneSourceToStereo.dsp","size":404,"extension":".dsp","type":"file"}],"size":1385,"type":"directory"},{"path":"examples/analysis","name":"analysis","children":[{"path":"examples/analysis/dbmeter.dsp","name":"dbmeter.dsp","size":628,"extension":".dsp","type":"file"},{"path":"examples/analysis/FFT.dsp","name":"FFT.dsp","size":874,"extension":".dsp","type":"file"},{"path":"examples/analysis/spectralLevel.dsp","name":"spectralLevel.dsp","size":233,"extension":".dsp","type":"file"},{"path":"examples/analysis/spectralTiltLab.dsp","name":"spectralTiltLab.dsp","size":668,"extension":".dsp","type":"file"},{"path":"examples/analysis/vumeter.dsp","name":"vumeter.dsp","size":545,"extension":".dsp","type":"file"}],"size":2948,"type":"directory"},{"path":"examples/bela","name":"bela","children":[{"path":"examples/bela/AdditiveSynth.dsp","name":"AdditiveSynth.dsp","size":1462,"extension":".dsp","type":"file"},{"path":"examples/bela/AdditiveSynth_Analog.dsp","name":"AdditiveSynth_Analog.dsp","size":1525,"extension":".dsp","type":"file"},{"path":"examples/bela/crossDelay2.dsp","name":"crossDelay2.dsp","size":2314,"extension":".dsp","type":"file"},{"path":"examples/bela/Faust-complement.lib","name":"Faust-complement.lib","size":2032,"extension":".lib","type":"file"},{"path":"examples/bela/FMSynth2.dsp","name":"FMSynth2.dsp","size":1956,"extension":".dsp","type":"file"},{"path":"examples/bela/FMSynth2_Analog.dsp","name":"FMSynth2_Analog.dsp","size":1873,"extension":".dsp","type":"file"},{"path":"examples/bela/FMSynth2_FX.dsp","name":"FMSynth2_FX.dsp","size":4569,"extension":".dsp","type":"file"},{"path":"examples/bela/FMSynth2_FX_Analog.dsp","name":"FMSynth2_FX_Analog.dsp","size":4683,"extension":".dsp","type":"file"},{"path":"examples/bela/FXChaine2.dsp","name":"FXChaine2.dsp","size":5513,"extension":".dsp","type":"file"},{"path":"examples/bela/GrainGenerator.dsp","name":"GrainGenerator.dsp","size":3631,"extension":".dsp","type":"file"},{"path":"examples/bela/granulator.dsp","name":"granulator.dsp","size":2429,"extension":".dsp","type":"file"},{"path":"examples/bela/repeater.dsp","name":"repeater.dsp","size":2315,"extension":".dsp","type":"file"},{"path":"examples/bela/simpleFX.dsp","name":"simpleFX.dsp","size":2434,"extension":".dsp","type":"file"},{"path":"examples/bela/simpleFX_Analog.dsp","name":"simpleFX_Analog.dsp","size":2582,"extension":".dsp","type":"file"},{"path":"examples/bela/simpleSynth.dsp","name":"simpleSynth.dsp","size":2562,"extension":".dsp","type":"file"},{"path":"examples/bela/simpleSynth_Analog.dsp","name":"simpleSynth_Analog.dsp","size":2596,"extension":".dsp","type":"file"},{"path":"examples/bela/simpleSynth_FX.dsp","name":"simpleSynth_FX.dsp","size":5153,"extension":".dsp","type":"file"},{"path":"examples/bela/simpleSynth_FX_Analog.dsp","name":"simpleSynth_FX_Analog.dsp","size":5350,"extension":".dsp","type":"file"},{"path":"examples/bela/WaveSynth.dsp","name":"WaveSynth.dsp","size":2230,"extension":".dsp","type":"file"},{"path":"examples/bela/WaveSynth_Analog.dsp","name":"WaveSynth_Analog.dsp","size":2345,"extension":".dsp","type":"file"},{"path":"examples/bela/WaveSynth_FX.dsp","name":"WaveSynth_FX.dsp","size":4895,"extension":".dsp","type":"file"},{"path":"examples/bela/WaveSynth_FX_Analog.dsp","name":"WaveSynth_FX_Analog.dsp","size":5084,"extension":".dsp","type":"file"}],"size":69533,"type":"directory"},{"path":"examples/delayEcho","name":"delayEcho","children":[{"path":"examples/delayEcho/echo.dsp","name":"echo.dsp","size":462,"extension":".dsp","type":"file"},{"path":"examples/delayEcho/quadEcho.dsp","name":"quadEcho.dsp","size":561,"extension":".dsp","type":"file"},{"path":"examples/delayEcho/smoothDelay.dsp","name":"smoothDelay.dsp","size":825,"extension":".dsp","type":"file"},{"path":"examples/delayEcho/stereoEcho.dsp","name":"stereoEcho.dsp","size":491,"extension":".dsp","type":"file"},{"path":"examples/delayEcho/tapiir.dsp","name":"tapiir.dsp","size":1263,"extension":".dsp","type":"file"}],"size":3602,"type":"directory"},{"path":"examples/dynamic","name":"dynamic","children":[{"path":"examples/dynamic/compressor.dsp","name":"compressor.dsp","size":194,"extension":".dsp","type":"file"},{"path":"examples/dynamic/distortion.dsp","name":"distortion.dsp","size":192,"extension":".dsp","type":"file"},{"path":"examples/dynamic/gateCompressor.dsp","name":"gateCompressor.dsp","size":333,"extension":".dsp","type":"file"},{"path":"examples/dynamic/noiseGate.dsp","name":"noiseGate.dsp","size":182,"extension":".dsp","type":"file"},{"path":"examples/dynamic/volume.dsp","name":"volume.dsp","size":376,"extension":".dsp","type":"file"}],"size":1277,"type":"directory"},{"path":"examples/fft","name":"fft","children":[{"path":"examples/fft/fft_bandpass.dsp","name":"fft_bandpass.dsp","size":734,"extension":".dsp","type":"file"},{"path":"examples/fft/fft_centroid.dsp","name":"fft_centroid.dsp","size":865,"extension":".dsp","type":"file"},{"path":"examples/fft/fft_delay.dsp","name":"fft_delay.dsp","size":918,"extension":".dsp","type":"file"},{"path":"examples/fft/fft_gain.dsp","name":"fft_gain.dsp","size":67,"extension":".dsp","type":"file"},{"path":"examples/fft/fft_remove_phase.dsp","name":"fft_remove_phase.dsp","size":734,"extension":".dsp","type":"file"},{"path":"examples/fft/fft_synth.dsp","name":"fft_synth.dsp","size":97,"extension":".dsp","type":"file"}],"size":3415,"type":"directory"},{"path":"examples/filtering","name":"filtering","children":[{"path":"examples/filtering/APF.dsp","name":"APF.dsp","size":337,"extension":".dsp","type":"file"},{"path":"examples/filtering/bandFilter.dsp","name":"bandFilter.dsp","size":1314,"extension":".dsp","type":"file"},{"path":"examples/filtering/BPF.dsp","name":"BPF.dsp","size":337,"extension":".dsp","type":"file"},{"path":"examples/filtering/cryBaby.dsp","name":"cryBaby.dsp","size":156,"extension":".dsp","type":"file"},{"path":"examples/filtering/diodeLadder.dsp","name":"diodeLadder.dsp","size":381,"extension":".dsp","type":"file"},{"path":"examples/filtering/DNN.dsp","name":"DNN.dsp","size":806,"extension":".dsp","type":"file"},{"path":"examples/filtering/filterBank.dsp","name":"filterBank.dsp","size":177,"extension":".dsp","type":"file"},{"path":"examples/filtering/graphicEqLab.dsp","name":"graphicEqLab.dsp","size":354,"extension":".dsp","type":"file"},{"path":"examples/filtering/highShelf.dsp","name":"highShelf.dsp","size":349,"extension":".dsp","type":"file"},{"path":"examples/filtering/HPF.dsp","name":"HPF.dsp","size":337,"extension":".dsp","type":"file"},{"path":"examples/filtering/korg35HPF.dsp","name":"korg35HPF.dsp","size":379,"extension":".dsp","type":"file"},{"path":"examples/filtering/korg35LPF.dsp","name":"korg35LPF.dsp","size":379,"extension":".dsp","type":"file"},{"path":"examples/filtering/lfBoost.dsp","name":"lfBoost.dsp","size":1348,"extension":".dsp","type":"file"},{"path":"examples/filtering/lowBoost.dsp","name":"lowBoost.dsp","size":1478,"extension":".dsp","type":"file"},{"path":"examples/filtering/lowCut.dsp","name":"lowCut.dsp","size":1453,"extension":".dsp","type":"file"},{"path":"examples/filtering/lowShelf.dsp","name":"lowShelf.dsp","size":347,"extension":".dsp","type":"file"},{"path":"examples/filtering/LPF.dsp","name":"LPF.dsp","size":337,"extension":".dsp","type":"file"},{"path":"examples/filtering/moogHalfLadder.dsp","name":"moogHalfLadder.dsp","size":390,"extension":".dsp","type":"file"},{"path":"examples/filtering/moogLadder.dsp","name":"moogLadder.dsp","size":378,"extension":".dsp","type":"file"},{"path":"examples/filtering/moogVCF.dsp","name":"moogVCF.dsp","size":153,"extension":".dsp","type":"file"},{"path":"examples/filtering/multibandFilter.dsp","name":"multibandFilter.dsp","size":561,"extension":".dsp","type":"file"},{"path":"examples/filtering/notch.dsp","name":"notch.dsp","size":341,"extension":".dsp","type":"file"},{"path":"examples/filtering/oberheim.dsp","name":"oberheim.dsp","size":457,"extension":".dsp","type":"file"},{"path":"examples/filtering/oberheimBPF.dsp","name":"oberheimBPF.dsp","size":397,"extension":".dsp","type":"file"},{"path":"examples/filtering/oberheimBSF.dsp","name":"oberheimBSF.dsp","size":397,"extension":".dsp","type":"file"},{"path":"examples/filtering/oberheimHPF.dsp","name":"oberheimHPF.dsp","size":397,"extension":".dsp","type":"file"},{"path":"examples/filtering/oberheimLPF.dsp","name":"oberheimLPF.dsp","size":396,"extension":".dsp","type":"file"},{"path":"examples/filtering/parametricEqLab.dsp","name":"parametricEqLab.dsp","size":437,"extension":".dsp","type":"file"},{"path":"examples/filtering/parametricEqualizer.dsp","name":"parametricEqualizer.dsp","size":185,"extension":".dsp","type":"file"},{"path":"examples/filtering/peakingEQ.dsp","name":"peakingEQ.dsp","size":349,"extension":".dsp","type":"file"},{"path":"examples/filtering/peakNotch.dsp","name":"peakNotch.dsp","size":350,"extension":".dsp","type":"file"},{"path":"examples/filtering/sallenKey2ndOrder.dsp","name":"sallenKey2ndOrder.dsp","size":481,"extension":".dsp","type":"file"},{"path":"examples/filtering/sallenKey2ndOrderBPF.dsp","name":"sallenKey2ndOrderBPF.dsp","size":430,"extension":".dsp","type":"file"},{"path":"examples/filtering/sallenKey2ndOrderHPF.dsp","name":"sallenKey2ndOrderHPF.dsp","size":429,"extension":".dsp","type":"file"},{"path":"examples/filtering/sallenKey2ndOrderLPF.dsp","name":"sallenKey2ndOrderLPF.dsp","size":429,"extension":".dsp","type":"file"},{"path":"examples/filtering/sallenKeyOnePole.dsp","name":"sallenKeyOnePole.dsp","size":444,"extension":".dsp","type":"file"},{"path":"examples/filtering/sallenKeyOnePoleHPF.dsp","name":"sallenKeyOnePoleHPF.dsp","size":390,"extension":".dsp","type":"file"},{"path":"examples/filtering/sallenKeyOnePoleLPF.dsp","name":"sallenKeyOnePoleLPF.dsp","size":389,"extension":".dsp","type":"file"},{"path":"examples/filtering/spectralTilt.dsp","name":"spectralTilt.dsp","size":191,"extension":".dsp","type":"file"},{"path":"examples/filtering/vcfWahLab.dsp","name":"vcfWahLab.dsp","size":504,"extension":".dsp","type":"file"},{"path":"examples/filtering/vocoder.dsp","name":"vocoder.dsp","size":226,"extension":".dsp","type":"file"},{"path":"examples/filtering/wahPedal.dsp","name":"wahPedal.dsp","size":163,"extension":".dsp","type":"file"}],"size":19533,"type":"directory"},{"path":"examples/gameaudio","name":"gameaudio","children":[{"path":"examples/gameaudio/bubble.dsp","name":"bubble.dsp","size":1037,"extension":".dsp","type":"file"},{"path":"examples/gameaudio/door.dsp","name":"door.dsp","size":1892,"extension":".dsp","type":"file"},{"path":"examples/gameaudio/fire.dsp","name":"fire.dsp","size":1312,"extension":".dsp","type":"file"},{"path":"examples/gameaudio/insects.dsp","name":"insects.dsp","size":4953,"extension":".dsp","type":"file"},{"path":"examples/gameaudio/rain.dsp","name":"rain.dsp","size":622,"extension":".dsp","type":"file"},{"path":"examples/gameaudio/wind.dsp","name":"wind.dsp","size":551,"extension":".dsp","type":"file"}],"size":10367,"type":"directory"},{"path":"examples/generator","name":"generator","children":[{"path":"examples/generator/filterOsc.dsp","name":"filterOsc.dsp","size":213,"extension":".dsp","type":"file"},{"path":"examples/generator/noise.dsp","name":"noise.dsp","size":1813,"extension":".dsp","type":"file"},{"path":"examples/generator/noiseMetadata.dsp","name":"noiseMetadata.dsp","size":2356,"extension":".dsp","type":"file"},{"path":"examples/generator/osc.dsp","name":"osc.dsp","size":471,"extension":".dsp","type":"file"},{"path":"examples/generator/osci.dsp","name":"osci.dsp","size":505,"extension":".dsp","type":"file"},{"path":"examples/generator/sawtoothLab.dsp","name":"sawtoothLab.dsp","size":239,"extension":".dsp","type":"file"},{"path":"examples/generator/virtualAnalog.dsp","name":"virtualAnalog.dsp","size":228,"extension":".dsp","type":"file"},{"path":"examples/generator/virtualAnalogLab.dsp","name":"virtualAnalogLab.dsp","size":268,"extension":".dsp","type":"file"}],"size":6093,"type":"directory"},{"path":"examples/LIBRARIES","name":"LIBRARIES","children":[{"path":"examples/LIBRARIES/aanl.lib","name":"aanl.lib","size":27753,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/all.lib","name":"all.lib","size":1016,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/analyzers.lib","name":"analyzers.lib","size":37512,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/basics.lib","name":"basics.lib","size":60106,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/compressors.lib","name":"compressors.lib","size":64754,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/delays.lib","name":"delays.lib","size":15122,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/demos.lib","name":"demos.lib","size":65185,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/dx7.lib","name":"dx7.lib","size":69103,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/envelopes.lib","name":"envelopes.lib","size":12032,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/fds.lib","name":"fds.lib","size":20559,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/filters.lib","name":"filters.lib","size":115548,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/hoa.lib","name":"hoa.lib","size":42799,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/instruments.lib","name":"instruments.lib","size":9395,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/interpolators.lib","name":"interpolators.lib","size":23955,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/maths.lib","name":"maths.lib","size":21483,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/maxmsp.lib","name":"maxmsp.lib","size":8174,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/mi.lib","name":"mi.lib","size":17280,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/misceffects.lib","name":"misceffects.lib","size":21753,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/noises.lib","name":"noises.lib","size":16086,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/oscillators.lib","name":"oscillators.lib","size":53381,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/phaflangers.lib","name":"phaflangers.lib","size":10024,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/physmodels.lib","name":"physmodels.lib","size":171348,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/platform.lib","name":"platform.lib","size":3131,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/quantizers.lib","name":"quantizers.lib","size":9855,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/reducemaps.lib","name":"reducemaps.lib","size":4836,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/reverbs.lib","name":"reverbs.lib","size":37506,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/routes.lib","name":"routes.lib","size":8565,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/sf.lib","name":"sf.lib","size":1066,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/signals.lib","name":"signals.lib","size":16416,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/soundfiles.lib","name":"soundfiles.lib","size":9361,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/spats.lib","name":"spats.lib","size":5193,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/stdfaust.lib","name":"stdfaust.lib","size":1270,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/synths.lib","name":"synths.lib","size":11395,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/tonestacks.lib","name":"tonestacks.lib","size":12354,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/tubes.lib","name":"tubes.lib","size":349789,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/vaeffects.lib","name":"vaeffects.lib","size":35897,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/version.lib","name":"version.lib","size":910,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/wdmodels.lib","name":"wdmodels.lib","size":89953,"extension":".lib","type":"file"},{"path":"examples/LIBRARIES/webaudio.lib","name":"webaudio.lib","size":12119,"extension":".lib","type":"file"}],"size":1493984,"type":"directory"},{"path":"examples/misc","name":"misc","children":[{"path":"examples/misc/autopan.dsp","name":"autopan.dsp","size":2292,"extension":".dsp","type":"file"},{"path":"examples/misc/capture.dsp","name":"capture.dsp","size":802,"extension":".dsp","type":"file"},{"path":"examples/misc/drumkit.dsp","name":"drumkit.dsp","size":1307,"extension":".dsp","type":"file"},{"path":"examples/misc/guitarix.dsp","name":"guitarix.dsp","size":8986,"extension":".dsp","type":"file"},{"path":"examples/misc/matrix.dsp","name":"matrix.dsp","size":551,"extension":".dsp","type":"file"},{"path":"examples/misc/midiTester.dsp","name":"midiTester.dsp","size":7986,"extension":".dsp","type":"file"},{"path":"examples/misc/mixer.dsp","name":"mixer.dsp","size":667,"extension":".dsp","type":"file"},{"path":"examples/misc/statespace.dsp","name":"statespace.dsp","size":1356,"extension":".dsp","type":"file"},{"path":"examples/misc/switcher.dsp","name":"switcher.dsp","size":564,"extension":".dsp","type":"file"},{"path":"examples/misc/tester.dsp","name":"tester.dsp","size":1082,"extension":".dsp","type":"file"},{"path":"examples/misc/tester2.dsp","name":"tester2.dsp","size":1189,"extension":".dsp","type":"file"},{"path":"examples/misc/UITester.dsp","name":"UITester.dsp","size":2158,"extension":".dsp","type":"file"}],"size":28940,"type":"directory"},{"path":"examples/phasing","name":"phasing","children":[{"path":"examples/phasing/flanger.dsp","name":"flanger.dsp","size":188,"extension":".dsp","type":"file"},{"path":"examples/phasing/phaser.dsp","name":"phaser.dsp","size":184,"extension":".dsp","type":"file"},{"path":"examples/phasing/phaserFlangerLab.dsp","name":"phaserFlangerLab.dsp","size":395,"extension":".dsp","type":"file"}],"size":767,"type":"directory"},{"path":"examples/physicalModeling","name":"physicalModeling","children":[{"path":"examples/physicalModeling/brass.dsp","name":"brass.dsp","size":263,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/brassMIDI.dsp","name":"brassMIDI.dsp","size":290,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/churchBell.dsp","name":"churchBell.dsp","size":244,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/clarinet.dsp","name":"clarinet.dsp","size":261,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/clarinetMIDI.dsp","name":"clarinetMIDI.dsp","size":288,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/djembeMIDI.dsp","name":"djembeMIDI.dsp","size":257,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/elecGuitarMIDI.dsp","name":"elecGuitarMIDI.dsp","size":330,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/englishBell.dsp","name":"englishBell.dsp","size":252,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk","name":"faust-stk","children":[{"path":"examples/physicalModeling/faust-stk/blowBottle.dsp","name":"blowBottle.dsp","size":5036,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/bowed.dsp","name":"bowed.dsp","size":5791,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/brass.dsp","name":"brass.dsp","size":5421,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/clarinet.dsp","name":"clarinet.dsp","size":5439,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/flute.dsp","name":"flute.dsp","size":5763,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/fluteStk.dsp","name":"fluteStk.dsp","size":6147,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/glassHarmonica.dsp","name":"glassHarmonica.dsp","size":5550,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/NLFeks.dsp","name":"NLFeks.dsp","size":3140,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/NLFfm.dsp","name":"NLFfm.dsp","size":3849,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/saxophony.dsp","name":"saxophony.dsp","size":6161,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/sitar.dsp","name":"sitar.dsp","size":1747,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/tibetanBowl.dsp","name":"tibetanBowl.dsp","size":6118,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/tunedBar.dsp","name":"tunedBar.dsp","size":5350,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/uniBar.dsp","name":"uniBar.dsp","size":3872,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/faust-stk/voiceForm.dsp","name":"voiceForm.dsp","size":5988,"extension":".dsp","type":"file"}],"size":75372,"type":"directory"},{"path":"examples/physicalModeling/flute.dsp","name":"flute.dsp","size":252,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/fluteMIDI.dsp","name":"fluteMIDI.dsp","size":279,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/frenchBell.dsp","name":"frenchBell.dsp","size":249,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/germanBell.dsp","name":"germanBell.dsp","size":249,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/guitarMIDI.dsp","name":"guitarMIDI.dsp","size":258,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/karplus.dsp","name":"karplus.dsp","size":288,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/marimbaMIDI.dsp","name":"marimbaMIDI.dsp","size":336,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/modularInterpInstrMIDI.dsp","name":"modularInterpInstrMIDI.dsp","size":310,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/nylonGuitarMIDI.dsp","name":"nylonGuitarMIDI.dsp","size":268,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/russianBell.dsp","name":"russianBell.dsp","size":252,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/standardBell.dsp","name":"standardBell.dsp","size":255,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/violin.dsp","name":"violin.dsp","size":268,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/violinMIDI.dsp","name":"violinMIDI.dsp","size":257,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/vocalBP.dsp","name":"vocalBP.dsp","size":258,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/vocalBPMIDI.dsp","name":"vocalBPMIDI.dsp","size":286,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/vocalFOF.dsp","name":"vocalFOF.dsp","size":233,"extension":".dsp","type":"file"},{"path":"examples/physicalModeling/vocalFOFMIDI.dsp","name":"vocalFOFMIDI.dsp","size":261,"extension":".dsp","type":"file"}],"size":82116,"type":"directory"},{"path":"examples/pitchShifting","name":"pitchShifting","children":[{"path":"examples/pitchShifting/pitchShifter.dsp","name":"pitchShifter.dsp","size":559,"extension":".dsp","type":"file"}],"size":559,"type":"directory"},{"path":"examples/psychoacoustic","name":"psychoacoustic","children":[{"path":"examples/psychoacoustic/harmonicExciter.dsp","name":"harmonicExciter.dsp","size":379,"extension":".dsp","type":"file"}],"size":379,"type":"directory"},{"path":"examples/reverb","name":"reverb","children":[{"path":"examples/reverb/dattorro.dsp","name":"dattorro.dsp","size":189,"extension":".dsp","type":"file"},{"path":"examples/reverb/fdnRev.dsp","name":"fdnRev.dsp","size":200,"extension":".dsp","type":"file"},{"path":"examples/reverb/freeverb.dsp","name":"freeverb.dsp","size":173,"extension":".dsp","type":"file"},{"path":"examples/reverb/greyhole.dsp","name":"greyhole.dsp","size":177,"extension":".dsp","type":"file"},{"path":"examples/reverb/jprev.dsp","name":"jprev.dsp","size":168,"extension":".dsp","type":"file"},{"path":"examples/reverb/reverbDesigner.dsp","name":"reverbDesigner.dsp","size":307,"extension":".dsp","type":"file"},{"path":"examples/reverb/reverbTester.dsp","name":"reverbTester.dsp","size":205,"extension":".dsp","type":"file"},{"path":"examples/reverb/zitaRev.dsp","name":"zitaRev.dsp","size":239,"extension":".dsp","type":"file"},{"path":"examples/reverb/zitaRevFDN.dsp","name":"zitaRevFDN.dsp","size":217,"extension":".dsp","type":"file"}],"size":1875,"type":"directory"},{"path":"examples/smartKeyboard","name":"smartKeyboard","children":[{"path":"examples/smartKeyboard/acGuitar.dsp","name":"acGuitar.dsp","size":3902,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/associatedEffects","name":"associatedEffects","children":[{"path":"examples/smartKeyboard/associatedEffects/elecGuitarEffect.dsp","name":"elecGuitarEffect.dsp","size":186,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/associatedEffects/myEffect.dsp","name":"myEffect.dsp","size":89,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/associatedEffects/reverb.dsp","name":"reverb.dsp","size":89,"extension":".dsp","type":"file"}],"size":364,"type":"directory"},{"path":"examples/smartKeyboard/bells.dsp","name":"bells.dsp","size":3002,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/bowed.dsp","name":"bowed.dsp","size":3130,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/brass.dsp","name":"brass.dsp","size":3151,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/clarinet.dsp","name":"clarinet.dsp","size":5188,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/crazyGuiro.dsp","name":"crazyGuiro.dsp","size":3916,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/drums.dsp","name":"drums.dsp","size":2550,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/dubDub.dsp","name":"dubDub.dsp","size":3264,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/elecGuitar.dsp","name":"elecGuitar.dsp","size":2516,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/fm.dsp","name":"fm.dsp","size":2974,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/frog.dsp","name":"frog.dsp","size":2868,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/harp.dsp","name":"harp.dsp","size":3329,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/midiOnly.dsp","name":"midiOnly.dsp","size":2458,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/multiSynth.dsp","name":"multiSynth.dsp","size":2550,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/toy.dsp","name":"toy.dsp","size":2823,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/trumpet.dsp","name":"trumpet.dsp","size":1922,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/turenas.dsp","name":"turenas.dsp","size":4268,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/violin.dsp","name":"violin.dsp","size":3439,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/violin2.dsp","name":"violin2.dsp","size":3017,"extension":".dsp","type":"file"},{"path":"examples/smartKeyboard/vocal.dsp","name":"vocal.dsp","size":1384,"extension":".dsp","type":"file"}],"size":62015,"type":"directory"},{"path":"examples/spat","name":"spat","children":[{"path":"examples/spat/panpot.dsp","name":"panpot.dsp","size":392,"extension":".dsp","type":"file"},{"path":"examples/spat/spat.dsp","name":"spat.dsp","size":695,"extension":".dsp","type":"file"}],"size":1087,"type":"directory"}],"size":1789875,"type":"directory"} \ No newline at end of file diff --git a/dist/examples/LIBRARIES/aanl.lib b/dist/examples/LIBRARIES/aanl.lib new file mode 100644 index 00000000..9b3f3a45 --- /dev/null +++ b/dist/examples/LIBRARIES/aanl.lib @@ -0,0 +1,898 @@ +//################################ aanl.lib ########################################## +// A library for antialiased nonlinearities. Its official prefix is `aa`. +// +// This library provides aliasing-suppressed nonlinearities through first-order +// and second-order approximations of continuous-time signals, functions, +// and convolution based on antiderivatives. This technique is particularly +// effective if combined with low-factor oversampling, for example, operating +// at 96 kHz or 192 kHz sample-rate. +// +// The library contains trigonometric functions as well as other nonlinear +// functions such as bounded and unbounded saturators. +// +// Due to their limited domains or ranges, some of these functions may not +// suitable for audio nonlinear processing or waveshaping, although +// they have been included for completeness. Some other functions, +// for example, tan() and tanh(), are only available with first-order +// antialiasing due to the complexity of the antiderivative of the +// x * f(x) term, particularly because of the necessity of the dilogarithm +// function, which requires special implementation. +// +// Future improvements to this library may include an adaptive +// mechanism to set the ill-conditioned cases threshold to improve +// performance in varying cases. +// +// Note that the antialiasing functions introduce a delay in the path, +// respectively half and one-sample delay for first and second-order functions. +// +// Also note that due to division by differences, it is vital to use +// double-precision or more to reduce errors. +// +// The environment identifier for this library is `aa`. After importing +// the standard libraries in Faust, the functions below can be called as `aa.function_name`. +// +// #### References +// * +// * +//######################################################################################## + +ba = library("basics.lib"); +ma = library("maths.lib"); + +declare name "Faust Antialiased Nonlinearities"; +declare version "0.3"; + +//==============================Auxiliary Functions======================================= +//======================================================================================== + +//-------`(aa.)clip`----------- +// Clipping function. +//----------------------------- +clip(l, h, x) = max(l, min(h, x)); + + +//-------`(aa.)Rsqrt`---------- +// Real-valued sqrt(). +//----------------------------- +Rsqrt(x) = sqrt(max(0.0, x)); + + +//-------`(aa.)Rlog`----------- +// Real-valued log(). +//----------------------------- +Rlog(x) = log(max(ma.EPSILON, x)); + + +//-------`(aa.)Rtan`----------- +// Real-valued tan(). +//----------------------------- +Rtan(x) = tan(clip(-ma.MAX, ma.MAX, x)); + + +//-------`(aa.)Racos`---------- +// Real-valued acos(). +//----------------------------- +Racos(x) = acos(clip(-1.0, 1.0, x)); + + +//-------`(aa.)Rasin`---------- +// Real-valued asin(). +//----------------------------- +Rasin(x) = asin(clip(-1.0, 1.0, x)); + + +//-------`(aa.)Racosh`---------- +// Real-valued acosh() +//------------------------------ +Racosh(x) = ma.acosh(clip(1.0, ma.MAX, x)); + + +//-------`(aa.)Rcosh`---------- +// Real-valued cosh(). +//----------------------------- +Rcosh(x) = min(ma.MAX, ma.cosh(x)); + + +//-------`(aa.)Rsinh`----------- +// Real-valued sinh(). +//------------------------------ +Rsinh(x) = clip(-ma.MAX, ma.MAX, ma.sinh(x)); + + +//-------`(aa.)Ratanh`---------- +// Real-valued atanh(). +//------------------------------ +Ratanh(x) = ma.atanh(clip(-1.0 + ma.EPSILON, 1.0 - ma.EPSILON, x)); + + +//-------`(aa.)ADAA1`--------------------- +// Generalised first-order ADAA function. +// +// #### Usage +// +// ``` +// _ : ADAA1(EPS, f, F1) : _ +// ``` +// +// Where: +// +// * `EPS`: a threshold to handle ill-conditioned cases +// * `f`: a function that we want to process with ADAA +// * `F1`: f's first antiderivative + +declare ADAA1 author "Dario Sanfilippo"; +declare ADAA1 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare ADAA1 license "LGPL v3.0 license"; +ADAA1(EPS, f, F1, x) = D1q + with { + D1q = ba.if(abs(x - x') <= EPS, ill_D1q, safe_D1q) + with { + ill_D1q = f(x_m); + safe_D1q = (F1(x) - F1(x')) / (x - x'); + x_m = .5 * (x + x'); + }; + }; + + +//-------`(aa.)ADAA2`--------------------- +// Generalised second-order ADAA function. +// +// #### Usage +// +// ``` +// _ : ADAA2(EPS, f, F1, F2) : _ +// ``` +// +// Where: +// +// * `EPS`: a threshold to handle ill-conditioned cases +// * `f`: a function that we want to process with ADAA +// * `F1`: f's first antiderivative +// * `F2`: f's second antiderivative + +declare ADAA2 author "Dario Sanfilippo"; +declare ADAA2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare ADAA2 license "LGPL v3.0 license"; +ADAA2(EPS, f, F1, F2, x) = T1 + T2 + with { + T1 = ba.if((x - x') ^ 2.0 <= EPS, ill_T1, safe_T1) + with { + ill_T1 = .5 * f((x + 2.0 * x') / 3.0); + safe_T1 = (x * (F1(x) - F1(x')) - (F2(x) - F2(x'))) / + ((x - x') ^ 2.0); + }; + T2 = ba.if((x' - x'') ^ 2.0 <= EPS, ill_T2, safe_T2) + with { + ill_T2 = .5 * f((x'' + 2.0 * x') / 3.0); + safe_T2 = (x'' * (F1(x'') - F1(x')) - (F2(x'') - F2(x'))) / + ((x'' - x') ^ 2.0); + }; + }; + + +//==============================Main functions============================================ +//======================================================================================== + +//================= Saturators =============== +// +// These antialiased saturators perform best with high-amplitude input +// signals. If the input is only slightly saturated, hence producing +// negligible aliasing, the trivial saturator may result in a better +// overall output, as noise can be introduced by first and second ADAA +// at low amplitudes. +// +// Once determining the lowest saturation level for which the antialiased +// functions perform adequately, it might be sensible to cross-fade +// between the trivial and the antialiased saturators according to the +// amplitude profile of the input signal. +//============================================== + +//-------`(aa.)hardclip`--------------------- +// +// First-order ADAA hard-clip. +// +// The domain of this function is ℝ; its theoretical range is [-1.0; 1.0]. +// +// #### Usage +// ``` +// _ : aa.hardclip : _ +// ``` +//--------------------------------------------- +declare hardclip author "Dario Sanfilippo"; +declare hardclip copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare hardclip license "LGPL v3.0 license"; +hardclip(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = clip(-1.0, 1.0, x_f); + F1(x_F1) = ba.if( (x_F1 <= 1.0) & (x_F1 >= -1.0), + .5 * x_F1 ^ 2.0, + x_F1 * ma.signum(x_F1) - .5); + }; + + +//-------`(aa.)hardclip2`--------------------- +// +// Second-order ADAA hard-clip. +// +// The domain of this function is ℝ; its theoretical range is [-1.0; 1.0]. +// +// #### Usage +// ``` +// _ : aa.hardclip2 : _ +// ``` +//--------------------------------------------- +declare hardclip2 author "Dario Sanfilippo"; +declare hardclip2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare hardclip2 license "LGPL v3.0 license"; +hardclip2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = clip(-1.0, 1.0, x_f); + F1(x_F1) = ba.if( (x_F1 <= 1.0) & (x_F1 >= -1.0), + .5 * x_F1 ^ 2.0, + x_F1 * ma.signum(x_F1) - .5); + F2(x_F2) = ba.if( (x_F2 <= 1.0) & (x_F2 >= -1.0), + (1.0 / 3.0) * x_F2 ^ 3.0, + ((.5 * x_F2 ^ 2.0) - 1.0 / 6.0) * + ma.signum(x_F2)); + }; + + +//-------`(aa.)cubic1`--------------------- +// +// First-order ADAA cubic saturator. +// +// The domain of this function is ℝ; its theoretical range is +// [-2.0/3.0; 2.0/3.0]. +// +// #### Usage +// ``` +// _ : aa.cubic1 : _ +// ``` +//------------------------------------------- +declare cubic1 author "Dario Sanfilippo"; +declare cubic1 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare cubic1 license "LGPL v3.0 license"; +cubic1(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = ba.if( (x_f < 1.0) & (x_f > -1.0), + x_f - x_f ^ 3.0 / 3.0, + (2.0 / 3.0) * ma.signum(x_f)); + F1(x_F1) = ba.if( x_F1 <= -1.0, + x_F1 * -2.0 / 3.0, + ba.if( x_F1 >= 1.0, + x_F1 * 2.0 / 3.0, + x_F1 ^ 2.0 / 2.0 - x_F1 ^ 4.0 / 12.0)); + }; + + +//-------`(aa.)parabolic`--------------------- +// +// First-order ADAA parabolic saturator. +// +// The domain of this function is ℝ; its theoretical range is [-1.0; 1.0]. +// +// #### Usage +// ``` +// _ : aa.parabolic : _ +// ``` +//-------------------------------------------- +declare parabolic author "Dario Sanfilippo"; +declare parabolic copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare parabolic license "LGPL v3.0 license"; +parabolic(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = ba.if( abs(x_f) <= 2.0, + x_f * (1.0 - abs(x_f) / 4.0), + ma.signum(x_f)); + F1(x_F1) = ba.if( abs(x_F1) <= 2.0, + (-1.0 / 12.0) * x_F1 ^ 2.0 * + (x_F1 * ma.signum(x_F1) - 6.0), + abs(x_F1)); + }; + + +//-------`(aa.)parabolic2`--------------------- +// +// Second-order ADAA parabolic saturator. +// +// The domain of this function is ℝ; its theoretical range is [-1.0; 1.0]. +// +// #### Usage +// ``` +// _ : aa.parabolic : _ +// ``` +//--------------------------------------------- +declare parabolic2 author "Dario Sanfilippo"; +declare parabolic2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare parabolic2 license "LGPL v3.0 license"; +parabolic2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = ba.if( abs(x_f) <= 2.0, + x_f * (1.0 - abs(x_f) / 4.0), + ma.signum(x_f)); + F1(x_F1) = ba.if( abs(x_F1) <= 2.0, + (-1.0 / 12.0) * x_F1 ^ 2.0 * + (x_F1 * ma.signum(x_F1) - 6.0), + abs(x_F1)); + F2(x_F2) = ba.if( abs(x_F2) <= 2.0, + (1.0 / 48.0) * x_F2 ^ 3.0 * + (16.0 - 3.0 * x_F2 * ma.signum(x_F2)), + .5 * x_F2 ^ 2.0 * ma.signum(x_F2)); + }; + + +//-------`(aa.)hyperbolic`--------------------- +// +// First-order ADAA hyperbolic saturator. +// +// The domain of this function is ℝ; its theoretical range is ]-1.0; 1.0[. +// +// #### Usage +// ``` +// _ : aa.hyperbolic : _ +// ``` +//--------------------------------------------- +declare hyperbolic author "Dario Sanfilippo"; +declare hyperbolic copyright "Copyright (C) 2021 Dario Sanfilippo +  "; +declare hyperbolic license "LGPL v3.0 license"; +hyperbolic(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = x_f / (1.0 + abs(x_f)); + F1(x_F1) = abs(x_F1) - log(1.0 + abs(x_F1)); + }; + + +//-------`(aa.)hyperbolic2`--------------------- +// +// Second-order ADAA hyperbolic saturator. +// +// The domain of this function is ℝ; its theoretical range is ]-1.0; 1.0[. +// +// #### Usage +// ``` +// _ : aa.hyperbolic2 : _ +// ``` +//---------------------------------------------- +declare hyperbolic2 author "Dario Sanfilippo"; +declare hyperbolic2 copyright "Copyright (C) 2021 Dario Sanfilippo +  "; +declare hyperbolic2 license "LGPL v3.0 license"; +hyperbolic2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = x_f / (1.0 + abs(x_f)); + F1(x_F1) = abs(x_F1) - log(1.0 + abs(x_F1)); + F2(x_F2) = ma.signum(x_F2) * (.5 * (3.0 - 2.0 * abs(x_F2) + x_F2 ^ 2.0 + + 2.0 * log(1.0 + abs(x_F2))) - 3.0 / 2.0) + 3.0 / 2.0; + }; + + +//-------`(aa.)sinarctan`--------------------- +// +// First-order ADAA sin(atan()) saturator. +// +// The domain of this function is ℝ; its theoretical range is ]-1.0; 1.0[. +// +// #### Usage +// ``` +// _ : aa.sinatan : _ +// ``` +//---------------------------------------------- +declare sinarctan author "Dario Sanfilippo"; +declare sinarctan copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare sinarctan license "LGPL v3.0 license"; +sinarctan(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = x_f / sqrt(1.0 + x_f ^ 2.0); + F1(x_F1) = sqrt(x_F1 ^ 2.0 + 1.0) + const + with { + const = -1.0; // for F1(0) = 0 to minimise precision loss + }; + }; + + +//-------`(aa.)sinarctan2`--------------------- +// +// Second-order ADAA sin(atan()) saturator. +// +// The domain of this function is ℝ; its theoretical range is ]-1.0; 1.0[. +// +// #### Usage +// ``` +// _ : aa.sinarctan2 : _ +// ``` +//---------------------------------------------- +declare sinarctan2 author "Dario Sanfilippo"; +declare sinarctan2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare sinarctan2 license "LGPL v3.0 license"; +sinarctan2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = x_f / sqrt(1.0 + x_f ^ 2.0); + F1(x_F1) = sqrt(x_F1 ^ 2.0 + 1.0) + const + with { + const = -1.0; // for F1(0) = 0 to minimise precision loss + }; + F2(x_F2) = .5 * x_F2 * sqrt(x_F2 ^ 2.0 + 1.0) - .5 * ma.asinh(x_F2); + }; + + +//-------`(aa.)tanh1`--------------------- +// +// First-order ADAA tanh() saturator. +// +// The domain of this function is ℝ; its theoretical range is ]-1.0; 1.0[. +// +// #### Usage +// ``` +// _ : aa.tanh1 : _ +// ``` +//---------------------------------------------- +declare tanh1 author "Dario Sanfilippo"; +declare tanh1 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare tanh1 license "LGPL v3.0 license"; +tanh1(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = ma.tanh(x_f); + F1(x_F1) = log(Rcosh(x_F1)); + }; + + +//-------`(aa.)arctan`--------------------- +// +// First-order ADAA atan(). +// +// The domain of this function is ℝ; its theoretical range is ]-π/2.0; π/2.0[. +// +// #### Usage +// ``` +// _ : aa.arctan : _ +// ``` +//------------------------------------------- +declare arctan author "Dario Sanfilippo"; +declare arctan copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare arctan license "LGPL v3.0 license"; +arctan(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = atan(x_f); + F1(x_F1) = x_F1 * f(x_F1) - .5 * log(x_F1 ^ 2.0 + 1.0); + }; + + +//-------`(aa.)arctan2`--------------------- +// +// Second-order ADAA atan(). +// +// The domain of this function is ℝ; its theoretical range is ]-π/2.0; π/2.0[. +// +// #### Usage +// ``` +// _ : aa.arctan2 : _ +// ``` +//------------------------------------------- +declare arctan2 author "Dario Sanfilippo"; +declare arctan2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare arctan2 license "LGPL v3.0 license"; +arctan2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = atan(x_f); + F1(x_F1) = x_F1 * f(x_F1) - .5 * log(x_F1 ^ 2.0 + 1.0); + F2(x_F2) = .5 * x_F2 ^ 2.0 * f(x_F2) - x_F2 / 2.0 + .5 * f(x_F2); + }; + + +//-------`(aa.)asinh1`--------------------- +// +// First-order ADAA asinh() saturator (unbounded). +// +// The domain of this function is ℝ; its theoretical range is ℝ. +// +// #### Usage +// ``` +// _ : aa.asinh1 : _ +// ``` +//------------------------------------------- +declare asinh1 author "Dario Sanfilippo"; +declare asinh1 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare asinh1 license "LGPL v3.0 license"; +asinh1(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = ma.asinh(x_f); + F1(x_F1) = x_F1 * f(x_F1) - sqrt(1.0 + x_F1 ^ 2.0) + const + with { + const = 1.0; // for F1(0) = 0 to minimise precision loss + }; + }; + + +//-------`(aa.)asinh2`--------------------- +// +// Second-order ADAA asinh() saturator (unbounded). +// +// The domain of this function is ℝ; its theoretical range is ℝ. +// +// #### Usage +// ``` +// _ : aa.asinh2 : _ +// ``` +//------------------------------------------- +declare asinh2 author "Dario Sanfilippo"; +declare asinh2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare asinh2 license "LGPL v3.0 license"; +asinh2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = ma.asinh(x_f); + F1(x_F1) = x_F1 * f(x_F1) - sqrt(1.0 + x_F1 ^ 2.0) + const + with { + const = 1.0; // for F1(0) = 0 to minimise precision loss + }; + F2(x_F2) = .25 * (2.0 * x_F2 ^ 2.0 * f(x_F2) + f(x_F2) - + sqrt(x_F2 ^ 2.0 + 1.0) * x_F2); + }; + + +//================= Trigonometry =============== +// These functions are reliable if input signals are within their domains. +//============================================ + + +//-------`(aa.)cosine1`--------------------- +// +// First-order ADAA cos(). +// +// The domain of this function is ℝ; its theoretical range is [-1.0; 1.0]. +// +// #### Usage +// ``` +// _ : aa.cosine1 : _ +// ``` +//------------------------------------------- +declare cosine1 author "Dario Sanfilippo"; +declare cosine1 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare cosine1 license "LGPL v3.0 license"; +cosine1(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = cos(x_f); + F1(x_F1) = sin(x_F1); + }; + + +//-------`(aa.)cosine2`--------------------- +// +// Second-order ADAA cos(). +// +// The domain of this function is ℝ; its theoretical range is [-1.0; 1.0]. +// +// #### Usage +// ``` +// _ : aa.cosine2 : _ +// ``` +//------------------------------------------- +declare cosine2 author "Dario Sanfilippo"; +declare cosine2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare cosine2 license "LGPL v3.0 license"; +cosine2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = cos(x_f); + F1(x_F1) = sin(x_F1); + F2(x_F2) = x_F2 * sin(x_F2) + cos(x_F2); + }; + + +//-------`(aa.)arccos`--------------------- +// +// First-order ADAA acos(). +// +// The domain of this function is [-1.0; 1.0]; its theoretical range is +// [π; 0.0]. +// +// #### Usage +// ``` +// _ : aa.arccos : _ +// ``` +//------------------------------------------ +declare arccos author "Dario Sanfilippo"; +declare arccos copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare arccos license "LGPL v3.0 license"; +arccos(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Racos(x_f); + F1(x_F1) = x_F1 * f(x_F1) - Rsqrt(1.0 - x_F1 ^ 2.0) + const + with { + const = 1.0; // for F1(0) = 0 to minimise precision loss + }; + }; + + +//-------`(aa.)arccos2`--------------------- +// +// Second-order ADAA acos(). +// +// The domain of this function is [-1.0; 1.0]; its theoretical range is +// [π; 0.0]. +// +// Note that this function is not accurate for low-amplitude or low-frequency +// input signals. In that case, the first-order ADAA arccos() can be used. +// +// #### Usage +// ``` +// _ : aa.arccos2 : _ +// ``` +//-------------------------------------------- +declare arccos2 author "Dario Sanfilippo"; +declare arccos2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare arccos2 license "LGPL v3.0 license"; +arccos2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Racos(x_f); + F1(x_F1) = x_F1 * f(x_F1) - Rsqrt(1.0 - x_F1 ^ 2.0) + const + with { + const = 1.0; // for F1(0) = 0 to minimise precision loss + }; + F2(x_F2) = .25 * (2.0 * x_F2 ^ 2.0 * f(x_F2) + Rasin(x_F2) - + Rsqrt(1.0 - x_F2 ^ 2.0)); + }; + + +//-------`(aa.)acosh1`--------------------- +// +// First-order ADAA acosh(). +// +// The domain of this function is ℝ >= 1.0; its theoretical range is ℝ >= 0.0. +// +// #### Usage +// ``` +// _ : aa.acosh1 : _ +// ``` +//------------------------------------------ +declare acosh1 author "Dario Sanfilippo"; +declare acosh1 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare acosh1 license "LGPL v3.0 license"; +acosh1(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Racosh(x_f); + F1(x_F1) = x_F1 * f(x_F1) - Rsqrt(x_F1 - 1.0) * Rsqrt(x_F1 + 1.0); + }; + + +//-------`(aa.)acosh2`--------------------- +// +// Second-order ADAA acosh(). +// +// The domain of this function is ℝ >= 1.0; its theoretical range is ℝ >= 0.0. +// +// Note that this function is not accurate for low-frequency input signals. +// In that case, the first-order ADAA acosh() can be used. +// +// #### Usage +// ``` +// _ : aa.acosh2 : _ +// ``` +//------------------------------------------- +declare acosh2 author "Dario Sanfilippo"; +declare acosh2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare acosh2 license "LGPL v3.0 license"; +acosh2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Racosh(x_f); + F1(x_F1) = x_F1 * f(x_F1) - Rsqrt(x_F1 - 1.0) * Rsqrt(x_F1 + 1.0); + F2(x_F2) = .5 * x_F2 ^ 2.0 * f(x_F2) - .25 * + Rsqrt(x_F2 - 1.0) * Rsqrt(x_F2 + 1.0) * x_F2 - + .25 * Rlog(x_F2 + Rsqrt(x_F2 - 1.0) * Rsqrt(x_F2 + 1.0)); + }; + + +//-------`(aa.)sine`--------------------- +// +// First-order ADAA sin(). +// +// The domain of this function is ℝ; its theoretical range is ℝ. +// +// #### Usage +// ``` +// _ : aa.sine : _ +// ``` +//---------------------------------------- +declare sine author "Dario Sanfilippo"; +declare sine copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare sine license "LGPL v3.0 license"; +sine(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = sin(x_f); + F1(x_F1) = -1.0 * cos(x_F1); + }; + + +//-------`(aa.)sine2`--------------------- +// +// Second-order ADAA sin(). +// +// The domain of this function is ℝ; its theoretical range is ℝ. +// +// #### Usage +// ``` +// _ : aa.sine2 : _ +// ``` +//---------------------------------------- +declare sine2 author "Dario Sanfilippo"; +declare sine2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare sine2 license "LGPL v3.0 license"; +sine2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = sin(x_f); + F1(x_F1) = 1.0 - cos(x_F1); + F2(x_F2) = sin(x_F2) - x_F2 * cos(x_F2); + }; + + +//-------`(aa.)arcsin`--------------------- +// +// First-order ADAA asin(). +// +// The domain of this function is [-1.0, 1.0]; its theoretical range is +// [-π/2.0; π/2.0]. +// +// #### Usage +// ``` +// _ : aa.arcsin : _ +// ``` +//------------------------------------------ +declare arcsin author "Dario Sanfilippo"; +declare arcsin copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare arcsin license "LGPL v3.0 license"; +arcsin(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Rasin(x_f); + F1(x_F1) = x_F1 * f(x_F1) + Rsqrt(1.0 - x_F1 ^ 2.0) + const + with { + const = -1.0; // for F1(0) = 0 to minimise precision loss + }; + }; + + +//-------`(aa.)arcsin2`--------------------- +// +// Second-order ADAA asin(). +// +// The domain of this function is [-1.0, 1.0]; its theoretical range is +// [-π/2.0; π/2.0]. +// +// Note that this function is not accurate for low-frequency input signals. +// In that case, the first-order ADAA asin() can be used. +// +// #### Usage +// ``` +// _ : aa.arcsin2 : _ +// ``` +//------------------------------------------ +declare arcsin2 author "Dario Sanfilippo"; +declare arcsin2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare arcsin2 license "LGPL v3.0 license"; +arcsin2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Rasin(x_f); + F1(x_F1) = x_F1 * f(x_F1) + Rsqrt(1.0 - x_F1 ^ 2.0) + const + with { + const = -1.0; // for F1(0) = 0 to minimise precision loss + }; + F2(x_F2) = .25 * (Rsqrt(1.0 - x_F2 ^ 2.0) * x_F2 + + (2.0 * x_F2 ^ 2.0 - 1.0) * f(x_F2)); + }; + + +//-------`(aa.)tangent`--------------------- +// +// First-order ADAA tan(). +// +// The domain of this function is [-π/2.0; π/2.0]; its theoretical range is ℝ. +// +// #### Usage +// ``` +// _ : aa.tangent : _ +// ``` +//------------------------------------------ +declare tangent author "Dario Sanfilippo"; +declare tangent copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare tangent license "LGPL v3.0 license"; +tangent(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Rtan(x_f); + F1(x_F1) = -1.0 * Rlog(cos(x_F1)); + }; + + +//-------`(aa.)atanh1`--------------------- +// +// First-order ADAA atanh(). +// +// The domain of this function is ]-1.0; 1.0[; its theoretical range is ℝ. +// +// #### Usage +// ``` +// _ : aa.atanh1 : _ +// ``` +//------------------------------------------ +declare atanh1 author "Dario Sanfilippo"; +declare atanh1 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare atanh1 license "LGPL v3.0 license"; +atanh1(x) = ADAA1(EPS, f, F1, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Ratanh(x_f); + F1(x_F1) = .5 * Rlog(1.0 - x_F1 ^ 2.0) + x_F1 * f(x_F1); + }; + + +//-------`(aa.)atanh2`--------------------- +// +// Second-order ADAA atanh(). +// +// The domain of this function is ]-1.0; 1.0[; its theoretical range is ℝ. +// +// #### Usage +// ``` +// _ : aa.atanh2 : _ +// ``` +//------------------------------------------ +declare atanh2 author "Dario Sanfilippo"; +declare atanh2 copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare atanh2 license "LGPL v3.0 license"; +atanh2(x) = ADAA2(EPS, f, F1, F2, x) + with { + EPS = 1.0 / ma.SR; + f(x_f) = Ratanh(x_f); + F1(x_F1) = .5 * Rlog(1.0 - x_F1 ^ 2.0) + x_F1 * f(x_F1); + F2(x_F2) = .5 * x_F2 ^ 2.0 * f(x_F2) + x_F2 / 2.0 + .25 * + Rlog(1.0 - x_F2) - .25 * Rlog(1.0 + x_F2); + }; diff --git a/dist/examples/LIBRARIES/all.lib b/dist/examples/LIBRARIES/all.lib new file mode 100644 index 00000000..6fb0574d --- /dev/null +++ b/dist/examples/LIBRARIES/all.lib @@ -0,0 +1,36 @@ +//##################################### all.lib ########################################## +// The purpose of this library is to give access to all the Faust standard libraries +// from a single point. +//######################################################################################## + +import("aanl.lib"); +import("analyzers.lib"); +import("basics.lib"); +import("compressors.lib"); +import("delays.lib"); +import("demos.lib"); +import("dx7.lib"); +import("envelopes.lib"); +import("fds.lib"); +import("filters.lib"); +import("hoa.lib"); +import("interpolators.lib"); +import("maths.lib"); +import("mi.lib"); +import("misceffects.lib"); +import("oscillators.lib"); +import("noises.lib"); +import("phaflangers.lib"); +import("physmodels.lib"); +import("quantizers.lib"); +import("reducemaps.lib"); +import("reverbs.lib"); +import("routes.lib"); +import("signals.lib"); +import("soundfiles.lib"); +import("spats.lib"); +import("synths.lib"); +import("vaeffects.lib"); +import("version.lib"); +import("wdmodels.lib"); +import("webaudio.lib"); diff --git a/dist/examples/LIBRARIES/analyzers.lib b/dist/examples/LIBRARIES/analyzers.lib new file mode 100644 index 00000000..cb79fd2a --- /dev/null +++ b/dist/examples/LIBRARIES/analyzers.lib @@ -0,0 +1,981 @@ +//################################ analyzers.lib ########################################## +// Analyzers library. Its official prefix is `an`. +// +// #### References +// * +//######################################################################################## + +ma = library("maths.lib"); +ba = library("basics.lib"); +ro = library("routes.lib"); +si = library("signals.lib"); +fi = library("filters.lib"); +an = library("analyzers.lib"); // for compatible copy/paste out of this file + +declare name "Faust Analyzer Library"; +declare version "0.2"; + +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2017 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +All MarkDown comments in this section is Copyright 2016-2017 by Romain +Michon and Julius O. Smith III, and is released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees) + +************************************************************************/ + +//==============================Amplitude Tracking======================================== +//======================================================================================== + +//------------------`(an.)abs_envelope_rect`----------------------------------- +// Absolute value average with moving-average algorithm. +// +// #### Usage +// +// ``` +// _ : abs_envelope_rect(period) : _ +// ``` +// +// Where: +// +// * `period`: sets the averaging frame in seconds +//----------------------------------------------------------------------------- +declare abs_envelope_rect author "Dario Sanfilippo and Julius O. Smith III"; +declare abs_envelope_rect copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare abs_envelope_rect license "MIT-style STK-4.3 license"; +abs_envelope_rect(period, x) = abs(x) : fi.avg_rect(period); + + +//------------------`(an.)abs_envelope_tau`------------------------------------ +// Absolute value average with one-pole lowpass and tau response. +// (See filters.lib.) +// +// #### Usage +// +// ``` +// _ : abs_envelope_tau(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 1/e) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare abs_envelope_tau author "Dario Sanfilippo and Julius O. Smith III"; +declare abs_envelope_tau copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare abs_envelope_tau license "MIT-style STK-4.3 license"; +abs_envelope_tau(period, x) = abs(x) : fi.avg_tau(period); + + +//------------------`(an.)abs_envelope_t60`------------------------------------ +// Absolute value average with one-pole lowpass and t60 response. +// (See filters.lib.) +// +// #### Usage +// +// ``` +// _ : abs_envelope_t60(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 60 dB) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare abs_envelope_t60 author "Dario Sanfilippo and Julius O. Smith III"; +declare abs_envelope_t60 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare abs_envelope_t60 license "MIT-style STK-4.3 license"; +abs_envelope_t60(period, x) = abs(x) : fi.avg_t60(period); + + +//------------------`(an.)abs_envelope_t19`------------------------------------ +// Absolute value average with one-pole lowpass and t19 response. +// (See filters.lib.) +// +// #### Usage +// +// ``` +// _ : abs_envelope_t19(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 1/e^2.2) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare abs_envelope_t19 author "Dario Sanfilippo and Julius O. Smith III"; +declare abs_envelope_t19 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare abs_envelope_t19 license "MIT-style STK-4.3 license"; +abs_envelope_t19(period, x) = abs(x) : fi.avg_t19(period); + + +//---------------------------`(an.)amp_follower`--------------------------- +// Classic analog audio envelope follower with infinitely fast rise and +// exponential decay. The amplitude envelope instantaneously follows +// the absolute value going up, but then floats down exponentially. +// +// `amp_follower` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : amp_follower(rel) : _ +// ``` +// +// Where: +// +// * `rel`: release time = amplitude-envelope time-constant (sec) going down +// +// #### References +// +// * Musical Engineer's Handbook, Bernie Hutchins, Ithaca NY +// * 1975 Electronotes Newsletter, Bernie Hutchins +//------------------------------------------------------------ +amp_follower(rel) = abs : env with { + p = ba.tau2pole(rel); + env(x) = x * (1.0 - p) : (+ : max(x,_)) ~ *(p); +}; + +peak_envelope = amp_follower; // Synonym for more standard naming + + +//---------------------------`(an.)amp_follower_ud`--------------------------- +// Envelope follower with different up and down time-constants +// (also called a "peak detector"). +// +// #### Usage +// +// ``` +// _ : amp_follower_ud(att,rel) : _ +// ``` +// +// Where: +// +// * `att`: attack time = amplitude-envelope time constant (sec) going up +// * `rel`: release time = amplitude-envelope time constant (sec) going down +// +// #### Note +// +// We assume rel >> att. Otherwise, consider rel ~ max(rel,att). +// For audio, att is normally faster (smaller) than rel (e.g., 0.001 and 0.01). +// Use `amp_follower_ar` below to remove this restriction. +// +// #### Reference +// +// * "Digital Dynamic Range Compressor Design --- A Tutorial and Analysis", by +// Dimitrios Giannoulis, Michael Massberg, and Joshua D. Reiss +// +//------------------------------------------------------------ +amp_follower_ud(att,rel) = amp_follower(rel) : si.smooth(ba.tau2pole(att)); + + +//---------------`(an.)amp_follower_ar`---------------- +// Envelope follower with independent attack and release times. The +// release can be shorter than the attack (unlike in `amp_follower_ud` +// above). +// +// #### Usage +// +// ``` +// _ : amp_follower_ar(att,rel) : _ +// ``` +// +// Where: +// +// * `att`: attack time = amplitude-envelope time constant (sec) going up +// * `rel`: release time = amplitude-envelope time constant (sec) going down +// +//--------------------------------------------------------- +declare amp_follower_ar author "Jonatan Liljedahl, revised by Romain Michon"; +amp_follower_ar(att,rel) = abs : si.onePoleSwitching(att,rel); + + +//------------------`(an.)ms_envelope_rect`------------------------------------ +// Mean square with moving-average algorithm. +// +// #### Usage +// +// ``` +// _ : ms_envelope_rect(period) : _ +// ``` +// +// Where: +// +// * `period`: sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare ms_envelope_rect author "Dario Sanfilippo and Julius O. Smith III"; +declare ms_envelope_rect copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare ms_envelope_rect license "MIT-style STK-4.3 license"; +ms_envelope_rect(period, x) = x * x : fi.avg_rect(period); + + +//------------------`(an.)ms_envelope_tau`------------------------------------- +// Mean square average with one-pole lowpass and tau response. +// (see `filters.lib`) +// +// #### Usage +// +// ``` +// _ : ms_envelope_tau(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 1/e) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare ms_envelope_tau author "Dario Sanfilippo and Julius O. Smith III"; +declare ms_envelope_tau copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare ms_envelope_tau license "MIT-style STK-4.3 license"; +ms_envelope_tau(period, x) = x * x : fi.avg_tau(period); + + +//------------------`(an.)ms_envelope_t60`------------------------------------- +// Mean square with one-pole lowpass and t60 response. +// (see `filters.lib`) +// +// #### Usage +// +// ``` +// _ : ms_envelope_t60(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 60 dB) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare ms_envelope_t60 author "Dario Sanfilippo and Julius O. Smith III"; +declare ms_envelope_t60 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare ms_envelope_t60 license "MIT-style STK-4.3 license"; +ms_envelope_t60(period, x) = x * x : fi.avg_t60(period); + + +//------------------`(an.)ms_envelope_t19`------------------------------------- +// Mean square with one-pole lowpass and t19 response. +// (see `filters.lib`) +// +// #### Usage +// +// ``` +// _ : ms_envelope_t19(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 1/e^2.2) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare ms_envelope_t19 author "Dario Sanfilippo and Julius O. Smith III"; +declare ms_envelope_t19 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare ms_envelope_t19 license "MIT-style STK-4.3 license"; +ms_envelope_t19(period, x) = x * x : fi.avg_t19(period); + + +//------------------`(an.)rms_envelope_rect`----------------------------------- +// Root mean square with moving-average algorithm. +// +// #### Usage +// +// ``` +// _ : rms_envelope_rect(period) : _ +// ``` +// +// Where: +// +// * `period`: sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare rms_envelope_rect author "Dario Sanfilippo and Julius O. Smith III"; +declare rms_envelope_rect copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare rms_envelope_rect license "MIT-style STK-4.3 license"; +rms_envelope_rect(period, x) = ms_envelope_rect(period, x) : sqrt; + + +//------------------`(an.)rms_envelope_tau`------------------------------------ +// Root mean square with one-pole lowpass and tau response. +// (see `filters.lib`) +// +// #### Usage +// +// ``` +// _ : rms_envelope_tau(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 1/e) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare rms_envelope_tau author "Dario Sanfilippo and Julius O. Smith III"; +declare rms_envelope_tau copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare rms_envelope_tau license "MIT-style STK-4.3 license"; +rms_envelope_tau(period, x) = ms_envelope_tau(period, x) : sqrt; + + +//------------------`(an.)rms_envelope_t60`------------------------------------ +// Root mean square with one-pole lowpass and t60 response. +// (see `filters.lib`) +// +// #### Usage +// +// ``` +// _ : rms_envelope_t60(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 60 dB) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare rms_envelope_t60 author "Dario Sanfilippo and Julius O. Smith III"; +declare rms_envelope_t60 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare rms_envelope_t60 license "MIT-style STK-4.3 license"; +rms_envelope_t60(period, x) = ms_envelope_t60(period, x) : sqrt; + + +//------------------`(an.)rms_envelope_t19`------------------------------------ +// Root mean square with one-pole lowpass and t19 response. +// (see `filters.lib`) +// +// #### Usage +// +// ``` +// _ : rms_envelope_t19(period) : _ +// ``` +// +// Where: +// +// * `period`: (time to decay by 1/e^2.2) sets the averaging frame in secs +//----------------------------------------------------------------------------- +declare rms_envelope_t19 author "Dario Sanfilippo and Julius O. Smith III"; +declare rms_envelope_t19 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare rms_envelope_t19 license "MIT-style STK-4.3 license"; +rms_envelope_t19(period, x) = ms_envelope_t19(period, x) : sqrt; + + +//-----------------------`(an.)zcr`-------------------------------------------- +// Zero-crossing rate (ZCR) with one-pole lowpass averaging based on the tau +// constant. It outputs an index between 0 and 1 at a desired analysis frame. +// The ZCR of a signal correlates with the noisiness [Gouyon et al. 2000] and +// the spectral centroid [Herrera-Boyer et al. 2006] of a signal. +// For sinusoidal signals, the ZCR can be multiplied by ma.SR/2 and used +// as a frequency detector. For example, it can be deployed as a +// computationally efficient adaptive mechanism for automatic Larsen +// suppression. +// +// #### Usage +// +// ``` +// _ : zcr(tau) : _ +// ``` +// +// Where: +// +// * `tau`: (time to decay by e^-1) sets the averaging frame in seconds. +declare zcr author "Dario Sanfilippo"; +declare zcr copyright "Copyright (C) 2020 Dario Sanfilippo + "; +declare zcr license "MIT-style STK-4.3 license"; +zcr(period, x) = ma.zc(x) : fi.lptau(period); + + +//============================================================================== +// Adaptive Frequency Analysis +//============================================================================== + +//--------------------`(an.)pitchTracker`--------------------------------------- +// +// This function implements a pitch-tracking algorithm by means of +// zero-crossing rate analysis and adaptive low-pass filtering. The design +// is based on the algorithm described in [this tutorial (section 2.2)](https://pdfslide.net/documents/faust-tutorial2.html). +// +// #### Usage +// +// ``` +// _ : pitchTracker(N, tau) : _ +// ``` +// +// Where: +// +// * `N`: compile-time constant, sets the order of the low-pass filter, which +// determines the sensitivity of the algorithm for signals where partials are +// stronger than the fundamental frequency. +// * `tau`: response time in seconds based on exponentially-weighted averaging with tau time-constant. See . +declare pitchTracker author "Dario Sanfilippo"; +declare pitchTracker copyright "Copyright (C) 2022 Dario Sanfilippo + "; +declare pitchTracker license "MIT License"; +pitchTracker(N, t, x) = loop ~ _ + with { + xHighpassed = fi.highpass(1, 20.0, x); + loop(y) = an.zcr(t, fi.lowpass(N, max(20.0, y), xHighpassed)) * ma.SR * .5; + }; + + +//--------------------`(an.)spectralCentroid`----------------------------------- +// +// This function implements a time-domain spectral centroid by means of RMS +// measurements and adaptive crossover filtering. The weight difference of the +// upper and lower spectral powers are used to recursively adjust the crossover +// cutoff so that the system (minimally) oscillates around a balancing point. +// +// Unlike block processing techniques such as FFT, this algorithm provides +// continuous measurements and fast response times. Furthermore, when providing +// input signals that are spectrally sparse, the algorithm will output a +// logarithmic measure of the centroid, which is perceptually desirable for +// musical applications. For example, if the input signal is the combination +// of three tones at 1000, 2000, and 4000 Hz, the centroid will be the middle +// octave. +// +// #### Usage +// +// ``` +// _ : spectralCentroid(nonlinearity, tau) : _ +// ``` +// +// Where: +// +// * `nonlinearity`: a boolean to activate or deactivate nonlinear integration. The +// nonlinear function is useful to improve stability with very short response times +// such as .001 <= tau <= .005 , otherwise, the nonlinearity may reduce precision. +// * `tau`: response time in seconds based on exponentially-weighted averaging with tau time-constant. See . +// +// #### Reference: +// Sanfilippo, D. (2021). Time-Domain Adaptive Algorithms for Low- and High-Level +// Audio Information Processing. Computer Music Journal, 45(1), 24-38. +// +// #### Example: +// +// `process = os.osc(500) + os.osc(1000) + os.osc(2000) + os.osc(4000) + os.osc(8000) : an.spectralCentroid(1, .001);` +// +declare spectralCentroid author "Dario Sanfilippo"; +declare spectralCentroid copyright "Copyright (C) 2022 Dario Sanfilippo + "; +declare spectralCentroid license "MIT License"; +spectralCentroid(nonlinearity, t, x) = loop ~ _ + with { + loop(fb) = centroid + with { + w(cf) = 2.0 * ma.PI * cf * ma.T; + integrator(t, x) = fi.pole(1.0, x * (1.0 / max(ma.EPSILON, t)) * ma.T); + lowpass(cf, x) = y + letrec { + 'y = (x - s) * G + s; + 's = 2 * (x - s) * G + s; + } + with { + G = tan(w(cf) / 2.0) / (1.0 + tan(w(cf) / 2.0)); + }; + highpass(cf, x) = x - lowpass(cf, x); + xRMS = an.rms_envelope_tau(t, x); + xLRMS = an.rms_envelope_tau(t, lowpass(fb, x)); + xHRMS = an.rms_envelope_tau(t, highpass(fb, x)); + diffRMS = (xHRMS - xLRMS) / max(ma.EPSILON, xRMS); + nonlinearIntegration = ba.if(nonlinearity, pow(diffRMS, 3), diffRMS); + diffInt = max(.0, min(1.0, integrator(t, nonlinearIntegration))); + centroid = max(20.0, diffInt * ma.SR * .5); + }; + }; + + +//=============================Spectrum-Analyzers========================================= +// Spectrum-analyzers split the input signal into a bank of parallel signals, one for +// each spectral band. They are related to the Mth-Octave Filter-Banks in `filters.lib`. +// The documentation of this library contains more details about the implementation. +// The parameters are: +// +// * `M`: number of band-slices per octave (>1) +// * `N`: total number of bands (>2) +// * `ftop` = upper bandlimit of the Mth-octave bands ( +//======================================================================================== + + +//-------------------------`(an.)mth_octave_analyzer`---------------------------- +// Octave analyzer. +// `mth_octave_analyzer[N]` are standard Faust functions. +// +// #### Usage +// ``` +// _ : mth_octave_analyzer(O,M,ftop,N) : par(i,N,_) // Oth-order Butterworth +// _ : mth_octave_analyzer6e(M,ftop,N) : par(i,N,_) // 6th-order elliptic +// ``` +// +// Also for convenience: +// +// ``` +// _ : mth_octave_analyzer3(M,ftop,N) : par(i,N,_) // 3d-order Butterworth +// _ : mth_octave_analyzer5(M,ftop,N) : par(i,N,_) // 5th-order Butterworth +// mth_octave_analyzer_default = mth_octave_analyzer6e; +// ``` +// +// Where: +// +// * `O`: order of filter used to split each frequency band into two +// * `M`: number of band-slices per octave +// * `ftop`: highest band-split crossover frequency (e.g., 20 kHz) +// * `N`: total number of bands (including dc and Nyquist) +//------------------------------------------------------------ +mth_octave_analyzer6e(M,ftop,N) = _ <: bsplit(N-1) with { + fc(n) = ftop * 2^(float(n-N+1)/float(M)); // -3dB crossover frequencies + lp(n) = fi.lowpass6e(fc(n)); // 6th-order elliptic - see other choices above + hp(n) = fi.highpass6e(fc(n)); // (search for lowpass* and highpass*) + bsplit(0) = _; + bsplit(i) = hp(i), (lp(i) <: bsplit(i-1)); +}; + +// Butterworth analyzers may be cascaded with allpass +// delay-equalizers to make (allpass-complementary) filter banks: + +mth_octave_analyzer(O,M,ftop,N) = _ <: bsplit(N-1) with { + fc(n) = ftop * 2^(float(n-N+1)/float(M)); + lp(n) = fi.lowpass(O,fc(n)); // Order O Butterworth + hp(n) = fi.highpass(O,fc(n)); + bsplit(0) = _; + bsplit(i) = hp(i), (lp(i) <: bsplit(i-1)); +}; + +mth_octave_analyzer3(M,ftop,N) = mth_octave_analyzer(3,M,ftop,N); +mth_octave_analyzer5(M,ftop,N) = mth_octave_analyzer(5,M,ftop,N); +mth_octave_analyzer_default = mth_octave_analyzer6e; // default analyzer + + +//============================Mth-Octave Spectral Level=================================== +// Spectral Level: Display (in bar graphs) the average signal level in each spectral band. +//======================================================================================== + + +//------------------------`(an.)mth_octave_spectral_level6e`------------------------- +// Spectral level display. +// +// #### Usage: +// +// ``` +// _ : mth_octave_spectral_level6e(M,ftop,NBands,tau,dB_offset) : _ +// ``` +// +// Where: +// +// * `M`: bands per octave +// * `ftop`: lower edge frequency of top band +// * `NBands`: number of passbands (including highpass and dc bands), +// * `tau`: spectral display averaging-time (time constant) in seconds, +// * `dB_offset`: constant dB offset in all band level meters. +// +// Also for convenience: +// +// ``` +// mth_octave_spectral_level_default = mth_octave_spectral_level6e; +// spectral_level = mth_octave_spectral_level(2,10000,20); +// ``` +//------------------------------------------------------------ +mth_octave_spectral_level6e(M,ftop,N,tau,dB_offset) = _<: + _,mth_octave_analyzer6e(M,ftop,N) : + _,(display:>_):attach with { + display = par(i,N,dbmeter(i)); + dbmeter(i) = abs : si.smooth(ba.tau2pole(tau)) : max(ma.EPSILON) : ba.linear2db : +(dB_offset) : + meter(N-i-1); + meter(i) = speclevel_group(vbargraph("[%2i] [unit:dB] + [tooltip: Spectral Band Level in dB]", -50, 10)); + O = int(((N-2)/M)+0.4999); + speclevel_group(x) = hgroup("[0] CONSTANT-Q SPECTRUM ANALYZER (6E), %N bands spanning + LP, %O octaves below %ftop Hz, HP + [tooltip: See Faust's filters.lib for documentation and references]", x); +}; + +mth_octave_spectral_level_default = mth_octave_spectral_level6e; +spectral_level = mth_octave_spectral_level(2,10000,20); // simple default + + +//---------------`(an.)[third|half]_octave_[analyzer|filterbank]`---------------- +// A bunch of special cases based on the different analyzer functions described above: +// +// ``` +// third_octave_analyzer(N) = mth_octave_analyzer_default(3,10000,N); +// third_octave_filterbank(N) = mth_octave_filterbank_default(3,10000,N); +// half_octave_analyzer(N) = mth_octave_analyzer_default(2,10000,N); +// half_octave_filterbank(N) = mth_octave_filterbank_default(2,10000,N); +// octave_filterbank(N) = mth_octave_filterbank_default(1,10000,N); +// octave_analyzer(N) = mth_octave_analyzer_default(1,10000,N); +// ``` +// +// #### Usage +// +// See `mth_octave_spectral_level_demo` in `demos.lib`. +//------------------------------------------------------------ +third_octave_analyzer(N) = mth_octave_analyzer_default(3,10000,N); +third_octave_filterbank(N) = mth_octave_filterbank_default(3,10000,N); +// Third-Octave Filter-Banks have been used in audio for over a century. +// See, e.g., +// Acoustics [the book], by L. L. Beranek +// Amer. Inst. Physics for the Acoustical Soc. America, +// + +// Third-octave bands across the audio spectrum are too wide for current +// typical computer screens, so half-octave bands are the default: +half_octave_analyzer(N) = mth_octave_analyzer_default(2,10000,N); +half_octave_filterbank(N) = mth_octave_filterbank_default(2,10000,N); + +octave_filterbank(N) = mth_octave_filterbank_default(1,10000,N); +octave_analyzer(N) = mth_octave_analyzer_default(1,10000,N); + + +//===============Arbritary-Crossover Filter-Banks and Spectrum Analyzers================== +// These are similar to the Mth-octave analyzers above, except that the +// band-split frequencies are passed explicitly as arguments. +//======================================================================================== + +// ACKNOWLEDGMENT +// Technique for processing a variable number of signal arguments due +// to Yann Orlarey (as is the entire Faust framework!) + +//---------------`(an.)analyzer`-------------------------- +// Analyzer. +// +// #### Usage +// +// ``` +// _ : analyzer(O,freqs) : par(i,N,_) // No delay equalizer +// ``` +// +// Where: +// +// * `O`: band-split filter order (ODD integer required for filterbank[i]) +// * `freqs`: (fc1,fc2,...,fcNs) [in numerically ascending order], where +// Ns=N-1 is the number of octave band-splits +// (total number of bands N=Ns+1). +// +// If frequencies are listed explicitly as arguments, enclose them in parens: +// +// ``` +// _ : analyzer(3,(fc1,fc2)) : _,_,_ +// ``` +//--------------------------------------------------- +analyzer(O,lfreqs) = _ <: bsplit(nb) +with { + nb = ba.count(lfreqs); + fc(n) = ba.take(n, lfreqs); + lp(n) = fi.lowpass(O,fc(n)); + hp(n) = fi.highpass(O,fc(n)); + bsplit(0) = _; + bsplit(i) = hp(i), (lp(i) <: bsplit(i-1)); +}; + +//================ Fast Fourier Transform (fft) and its Inverse (ifft) =================== +// Sliding FFTs that compute a rectangularly windowed FFT each sample. +//======================================================================================== + +//---------------`(an.)goertzelOpt` -------------------------- +// Optimized Goertzel filter. +// +// #### Usage +// +// ``` +// _ : goertzelOpt(freq,n) : _ +// ``` +// +// Where: +// +// * `freq`: frequency to be analyzed +// * `n`: the Goertzel block size +// +// #### Reference +// +// * +//--------------------------------------------------- +goertzelOpt(freq,n,x) = mg +with { + mg = sqrt(eq^2 + eq'^2-eq*eq'*c) : ba.sAndH(reset0); // magnitude + cnt = ba.time%n; // counter for windowing + reset0 = cnt == (n-1); // reset when end of window + reset1 = 1-(cnt == 0); // reset when beginning of window + k = 0.5 + n*freq/ma.SR; + w = (2*ma.PI/n)*k; + c = 2*cos(w); + eq = s // equation + letrec{ + 's = c*s*reset1 - s'*reset1*reset1' + x; + }; +}; + +//---------------`(an.)goertzelComp` -------------------------- +// Complex Goertzel filter. +// +// #### Usage +// +// ``` +// _ : goertzelComp(freq,n) : _ +// ``` +// +// Where: +// +// * `freq`: frequency to be analyzed +// * `n`: the Goertzel block size +// +// #### Reference +// +// * +//--------------------------------------------------- +goertzelComp(freq,n,x) = mg +with { + mg = sqrt(real^2 + imag^2); // magnitude + cnt = ba.time%n; // counter for windowing + reset0 = cnt == (n-1); // reset when end of window + reset1 = 1-(cnt == 0); // reset when beginning of window + k = 0.5 + n*freq/ma.SR; + w = (2*ma.PI/n)*k; + sine = sin(w); + cosine = cos(w); + c = 2*cosine; + eq = s + letrec{ + 's = c*s*reset1 - s'*reset1*reset1' + x; + }; + real = eq - eq'*cosine; + imag = eq'*sine; +}; + +//---------------`(an.)goertzel` -------------------------- +// Same as [`goertzelOpt`](#goertzelopt). +// +// #### Usage +// +// ``` +// _ : goertzel(freq,n) : _ +// ``` +// +// Where: +// +// * `freq`: frequency to be analyzed +// * `n`: the Goertzel block size +// +// #### Reference +// +// * +//--------------------------------------------------- +goertzel = goertzelOpt; + +// Undocumented utility functions used by fft and ifft: +c_magsq(N) = si.cbus(N) : par(i,N,(par(j,2,abs<:_*_):>_)) :> si.bus(N); +c_magdb(N) = si.cbus(N) : an.c_magsq(N) : par(i,N,(max(ma.EPSILON):log10:*(10.0))); +c_select_pos_freqs(2) = (_,_), (_,_); // both dc and SR/2 included with "positive frequencies" +c_select_pos_freqs(N) = si.cbus(N) : par(i,N/2+1,(_,_)),par(i,N/2-1,(!,!)) : si.cbus(N/2+1); // for complex spectra + select_pos_freqs(2) = _,_; // both dc and SR/2 included + select_pos_freqs(N) = si.bus(N) : par(i,N/2+1, _), par(i,N/2-1, !) : si. bus(N/2+1); // real power spectra etc. + +rtorv(N,x) = par(i,N,x@i); // convert real scalar signal to length N real vector +rtocv(N,x) = par(i,N,(x@i,0)); // convert real scalar signal to length N complex vector with 0 imag part +rvtocv(N) = si.bus(N), par(i,N,0) : ro.interleave(N,2); // convert real N-vector to complex with 0 imag part + +bit_reverse_selector(N,0) = 0; +bit_reverse_selector(N,i) = int(int(N)>>1)*(i&1) + bit_reverse_selector(int(N)>>1,(i>>1)); + +// decimation in time does this to the input: +bit_reverse_shuffle(N) = si.bus(N) <: par(i,N,bit_reverse_permuter(N,i)) with { + bit_reverse_permuter(N,k) = ba.selector(bit_reverse_selector(N,k),N); +}; + +c_bit_reverse_shuffle(N) = si.cbus(N) <: par(i,N,c_bit_reverse_permuter(N,i)) with { + c_bit_reverse_permuter(N,k) = ba.cselector(bit_reverse_selector(N,k),N); +}; + + +//---------------`(an.)fft` -------------------------- +// Fast Fourier Transform (FFT). +// +// #### Usage +// +// ``` +// si.cbus(N) : fft(N) : si.cbus(N) +// ``` +// +// Where: +// +// * `si.cbus(N)` is a bus of N complex signals, each specified by real and imaginary parts: +// (r0,i0), (r1,i1), (r2,i2), ... +// * `N` is the FFT size (must be a power of 2: 2,4,8,16,... known at compile time) +// * `fft(N)` performs a length `N` FFT for complex signals (radix 2) +// * The output is a bank of N complex signals containing the complex spectrum over time: +// (R0, I0), (R1,I1), ... +// - The dc component is (R0,I0), where I0=0 for real input signals. +// +// FFTs of Real Signals: +// +// * To perform a sliding FFT over a real input signal, you can say +// ``` +// process = signal : an.rtocv(N) : an.fft(N); +// ``` +// where `an.rtocv` converts a real (scalar) signal to a complex vector signal having a zero imaginary part. +// +// * See `an.rfft_analyzer_c` (in `analyzers.lib`) and related functions for more detailed usage examples. +// +// * Use `an.rfft_spectral_level(N,tau,dB_offset)` to display the power spectrum of a real signal. +// +// * See `dm.fft_spectral_level_demo(N)` in `demos.lib` for an example GUI driving `an.rfft_spectral_level()`. +// +// #### Reference +// +// * [Decimation-in-time (DIT) Radix-2 FFT](https://cnx.org/contents/zmcmahhR@7/Decimation-in-time-DIT-Radix-2) +// +//--------------------------------------------------- +fft(N) = si.cbus(N) : an.c_bit_reverse_shuffle(N) : an.fftb(N); // shuffle off to the butterflies: +fftb(1) = _,_; // each complex number is represented as (real,imag) +fftb(N) = si.cbus(N) : (fftb(No2) <: (si.cbus(No2), si.cbus(No2))), (fftb(No2) + <: (si.cbus(N):twiddleOdd(N))) :> si.cbus(N) +with { + No2 = int(N)>>1; + // Half of these multiplies can go away since w(k) = - w(k+N/2), and others as well (1,j,-j,-1,...) + twiddleOdd(N) = par(k,N,si.cmul(cos(w(k)),0-sin(w(k)))) + with { + w(k) = 2.0*ma.PI*float(k)/float(N); + }; +}; + +// `rfft` +// Slow to compile: rfft(N) = si.bus(N) : an.bit_reverse_shuffle(N) : an.rvtocv(N) : an.fftb(N); +// Order of magnitude faster to compile but takes a scalar input, so too different from fft: +// rfft(N) = an.rtocv(N) : an.fft(N); + +//---------------`(an.)ifft`-------------------------- +// Inverse Fast Fourier Transform (IFFT). +// +// #### Usage +// +// ``` +// si.cbus(N) : ifft(N) : si.cbus(N) +// ``` +// +// Where: +// +// * N is the IFFT size (power of 2) +// * Input is a complex spectrum represented as interleaved real and imaginary parts: +// (R0, I0), (R1,I1), (R2,I2), ... +// * Output is a bank of N complex signals giving the complex signal in the time domain: +// (r0, i0), (r1,i1), (r2,i2), ... +//--------------------------------------------------- +ifft(N) = si.cbus(N) : an.c_bit_reverse_shuffle(N) : an.ifftb(N); // input is shuffled off to the butterflies: +ifftb(1) = _,_; +ifftb(N) = si.cbus(N) : (ifftb(No2) <: (si.cbus(No2), si.cbus(No2))), (ifftb(No2) + <: (si.cbus(N):twiddleOddConj(N))) :> si.cbus(N) : par(i,2*N,/(2.0)) +with { + No2 = int(N)>>1; + // Half of these multiplies can go away since w(k) = - w(k+N/2), and others as well (1,j,-j,-1,...) + twiddleOddConj(N) = par(k,N,si.cmul(cos(w(k)),sin(w(k)))) + with { + w(k) = 2.0*ma.PI*float(k)/float(N); + }; +}; + + +// ========== FFT Analyzers ========== +rfft_analyzer_c(N) = an.rtocv(N) : an.fft(N) : an.c_select_pos_freqs(N); // complex spectral bins 0 to N/2 +rfft_analyzer_db(N) = an.rfft_analyzer_c(N) : an.c_magdb(N/2+1); // assumes real input +rfft_analyzer_magsq(N) = an.rfft_analyzer_c(N) : an.c_magsq(N/2+1); // assumes real input + +rfft_spectral_level(N,tau,dB_offset) = _<: _, an.rfft_analyzer_db(N) : _,(display:>_):attach with { + display = par(i,N/2+1,dbmeter(i)); + dbmeter(i) = si.smooth(ba.tau2pole(tau)) : +(dB_offset) : meter(i); + meter(i) = speclevel_group(vbargraph("[%2i] [unit:dB] + [tooltip: FFT Spectral Band Level in dB]", -50, 10)); + speclevel_group(x) = hgroup("[0] FFT SPECTRUM ANALYZER, %N bands + [tooltip: fft_spectral_level in Faust's analyzers.lib]", x); +}; + +// end jos section +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +// TODO: Add GRAME functions here + +//######################################################################################## +/************************************************************************ +FAUST library file, further contributions section + +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ diff --git a/dist/examples/LIBRARIES/basics.lib b/dist/examples/LIBRARIES/basics.lib new file mode 100644 index 00000000..1a964637 --- /dev/null +++ b/dist/examples/LIBRARIES/basics.lib @@ -0,0 +1,2061 @@ +//#################################### basics.lib ######################################## +// A library of basic elements. Its official prefix is `ba`. +// +// #### References +// * +//######################################################################################## +// A library of basic elements for Faust organized in 5 sections: +// +// * Conversion Tools +// * Counters and Time/Tempo Tools +// * Array Processing/Pattern Matching +// * Selectors (Conditions) +// * Other Tools (Misc) + +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +ro = library("routes.lib"); +ba = library("basics.lib"); // for compatible copy/paste out of this file +fi = library("filters.lib"); +it = library("interpolators.lib"); +si = library("signals.lib"); + +declare name "Faust Basic Element Library"; +declare version "0.9"; + +//=============================Conversion Tools=========================================== +//======================================================================================== + +//-------`(ba.)samp2sec`---------- +// Converts a number of samples to a duration in seconds at the current sampling rate (see `ma.SR`). +// `samp2sec` is a standard Faust function. +// +// #### Usage +// +// ``` +// samp2sec(n) : _ +// ``` +// +// Where: +// +// * `n`: number of samples +//---------------------------- +samp2sec(n) = n/ma.SR; + + +//-------`(ba.)sec2samp`---------- +// Converts a duration in seconds to a number of samples at the current sampling rate (see `ma.SR`). +// `samp2sec` is a standard Faust function. +// +// #### Usage +// +// ``` +// sec2samp(d) : _ +// ``` +// +// Where: +// +// * `d`: duration in seconds +//---------------------------- +sec2samp(d) = d*ma.SR; + + +//-------`(ba.)db2linear`---------- +// Converts a loudness in dB to a linear gain (0-1). +// `db2linear` is a standard Faust function. +// +// #### Usage +// +// ``` +// db2linear(l) : _ +// ``` +// +// Where: +// +// * `l`: loudness in dB +//----------------------------- +db2linear(l) = pow(10.0, l/20.0); + + +//-------`(ba.)linear2db`---------- +// Converts a linear gain (0-1) to a loudness in dB. +// `linear2db` is a standard Faust function. +// +// #### Usage +// +// ``` +// linear2db(g) : _ +// ``` +// +// Where: +// +// * `g`: a linear gain +//----------------------------- +linear2db(g) = 20.0*log10(max(ma.MIN, g)); + + +//----------`(ba.)lin2LogGain`------------------ +// Converts a linear gain (0-1) to a log gain (0-1). +// +// #### Usage +// +// ``` +// lin2LogGain(n) : _ +// ``` +// +// Where: +// +// * `n`: the linear gain +//--------------------------------------------- +lin2LogGain(n) = n*n; + + +//----------`(ba.)log2LinGain`------------------ +// Converts a log gain (0-1) to a linear gain (0-1). +// +// #### Usage +// +// ``` +// log2LinGain(n) : _ +// ``` +// +// Where: +// +// * `n`: the log gain +//--------------------------------------------- +log2LinGain(n) = sqrt(n); + + +// end GRAME section +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2017 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +The MarkDown comments in this section are Copyright 2016-2017 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees) + +************************************************************************/ + +//-------`(ba.)tau2pole`---------- +// Returns a real pole giving exponential decay. +// Note that t60 (time to decay 60 dB) is ~6.91 time constants. +// `tau2pole` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : smooth(tau2pole(tau)) : _ +// ``` +// +// Where: +// +// * `tau`: time-constant in seconds +//----------------------------- +// tau2pole(tau) = exp(-1.0/(tau*ma.SR)); + +tau2pole(tau) = ba.if(clipCond, 0.0, exp(-1.0/(tauCenterClipped*float(ma.SR)))) +with { + clipCond = abs(tau) x'; }; + + +//----------------------------`(ba.)countdown`------------------------------ +// Starts counting down from n included to 0. While trig is 1 the output is n. +// The countdown starts with the transition of trig from 1 to 0. At the end +// of the countdown the output value will remain at 0 until the next trig. +// `countdown` is a standard Faust function. +// +// #### Usage +// +// ``` +// countdown(n,trig) : _ +// ``` +// +// Where: +// +// * `n`: the starting point of the countdown +// * `trig`: the trigger signal (1: start at `n`; 0: decrease until 0) +//----------------------------------------------------------------------------- +countdown(n, trig) = \(c).(if(trig>0, n, max(0, c-1))) ~ _; + + +//----------------------------`(ba.)countup`-------------------------------- +// Starts counting up from 0 to n included. While trig is 1 the output is 0. +// The countup starts with the transition of trig from 1 to 0. At the end +// of the countup the output value will remain at n until the next trig. +// `countup` is a standard Faust function. +// +// #### Usage +// +// ``` +// countup(n,trig) : _ +// ``` +// +// Where: +// +// * `n`: the maximum count value +// * `trig`: the trigger signal (1: start at 0; 0: increase until `n`) +//----------------------------------------------------------------------------- +countup(n, trig) = \(c).(if(trig>0, 0, min(n, c+1))) ~ _; + + +//--------------------`(ba.)sweep`-------------------------- +// Counts from 0 to `period-1` repeatedly, generating a +// sawtooth waveform, like `os.lf_rawsaw`, +// starting at 1 when `run` transitions from 0 to 1. +// Outputs zero while `run` is 0. +// +// #### Usage +// +// ``` +// sweep(period,run) : _ +// ``` +//----------------------------------------------------------------- +declare sweep author "Jonatan Liljedahl"; + +sweep = %(int(*:max(1)))~+(1); + + +//-------`(ba.)time`---------- +// A simple timer that counts every samples from the beginning of the process. +// `time` is a standard Faust function. +// +// #### Usage +// +// ``` +// time : _ +// ``` +//------------------------ +time = (+(1)~_) - 1; + + +//-------`(ba.)ramp`---------- +// A linear ramp with a slope of '(+/-)1/n' samples to reach the next value. +// +// #### Usage +// +// ``` +// _ : ramp(n) : _ +// ``` +// Where: +// +// * `n`: number of samples to increment/decrement the value by one +//------------------------ +ramp = case { + (0) => _; + (n) => \(y,x).(if(y+1.0/n < x, y+1.0/n, if(y-1.0/n > x, y-1.0/n, x))) ~ _; +}; + + +//-------`(ba.)line`---------- +// A linear ramp to reach a next value in 'n' samples. +// Note that the interpolation process is restarted every time +// the desired output value changes, the interpolation time is sampled only then. +// +// #### Usage +// +// ``` +// _ : line(n) : _ +// ``` +// Where: +// +// * `n`: number of samples to reach the next value +//------------------------ +line(n, x) = state ~ (_,_) : !,_ +with { + state(t, c) = nt,nc + with { + nt = ba.if(x != x', n, t-1); + nc = ba.if(nt > 0, c + (x - c)/nt, x); + }; +}; + + +//-------`(ba.)tempo`---------- +// Converts a tempo in BPM into a number of samples. +// +// #### Usage +// +// ``` +// tempo(t) : _ +// ``` +// +// Where: +// +// * `t`: tempo in BPM +//------------------------ +tempo(t) = (60*ma.SR)/t; + + +//-------`(ba.)period`---------- +// Basic sawtooth wave of period `p`. +// +// #### Usage +// +// ``` +// period(p) : _ +// ``` +// +// Where: +// +// * `p`: period as a number of samples +//------------------------ +// NOTE: may be this should go in oscillators.lib +period(p) = %(int(p))~+(1'); + + +//-------`(ba.)pulse`---------- +// Pulses (like 10000) generated at period `p`. +// +// #### Usage +// +// ``` +// pulse(p) : _ +// ``` +// +// Where: +// +// * `p`: period as a number of samples +//------------------------ +// NOTE: may be this should go in oscillators.lib +pulse(p) = period(p) : \(x).(x <= x'); + + +//-------`(ba.)pulsen`---------- +// Pulses (like 11110000) of length `n` generated at period `p`. +// +// #### Usage +// +// ``` +// pulsen(n,p) : _ +// ``` +// +// Where: +// +// * `n`: pulse length as a number of samples +// * `p`: period as a number of samples +//------------------------ +// NOTE: may be this should go in oscillators.lib +pulsen(n,p) = period(p)= n); +}; + + +//-----------------------`(ba.)resetCtr`------------------------ +// Function that lets through the mth impulse out of +// each consecutive group of `n` impulses. +// +// #### Usage +// +// ``` +// _ : resetCtr(n,m) : _ +// ``` +// +// Where: +// +// * `n`: the total number of impulses being split +// * `m`: index of impulse to allow to be output +//--------------------------------------------------------- +declare resetCtr author "Mike Olsen"; + +resetCtr(n,m) = _ <: (_,pulse_countup_loop(n-1,1)) : (_,(_==m)) : *; + + +//===============================Array Processing/Pattern Matching======================== +//======================================================================================== + +//---------------------------------`(ba.)count`--------------------------------- +// Count the number of elements of list l. +// `count` is a standard Faust function. +// +// #### Usage +// +// ``` +// count(l) +// count((10,20,30,40)) -> 4 +// ``` +// +// Where: +// +// * `l`: list of elements +//----------------------------------------------------------------------------- +count((xs, xxs)) = 1 + count(xxs); +count(xx) = 1; + + +//-------------------------------`(ba.)take`----------------------------------- +// Take an element from a list. +// `take` is a standard Faust function. +// +// #### Usage +// +// ``` +// take(P,l) +// take(3,(10,20,30,40)) -> 30 +// ``` +// +// Where: +// +// * `P`: position (int, known at compile time, P > 0) +// * `l`: list of elements +//----------------------------------------------------------------------------- +take(1, (xs, xxs)) = xs; +take(1, xs) = xs; +take(N, (xs, xxs)) = take(N-1, xxs); + + +//----------------------------`(ba.)subseq`-------------------------------- +// Extract a part of a list. +// +// #### Usage +// +// ``` +// subseq(l, P, N) +// subseq((10,20,30,40,50,60), 1, 3) -> (20,30,40) +// subseq((10,20,30,40,50,60), 4, 1) -> 50 +// ``` +// +// Where: +// +// * `l`: list +// * `P`: start point (int, known at compile time, 0: begin of list) +// * `N`: number of elements (int, known at compile time) +// +// #### Note: +// +// Faust doesn't have proper lists. Lists are simulated with parallel +// compositions and there is no empty list. +//----------------------------------------------------------------------------- +subseq((head, tail), 0, 1) = head; +subseq((head, tail), 0, N) = head, subseq(tail, 0, N-1); +subseq((head, tail), P, N) = subseq(tail, P-1, N); +subseq(head, 0, N) = head; + + +//============================Function tabulation========================================= +// The purpose of function tabulation is to speed up the computation of heavy functions over an interval, +// so that the computation at runtime can be faster than directly using the function. +// Two techniques are implemented: +// +// * `tabulate` computes the function in a table and read the points using interpolation +// +// * `tabulate_chebychev` uses Chebyshev polynomial approximation +// +// #### Comparison program example +// ``` +///* Both tabulate() and tabulate_chebychev() create rdtable of size = 200, both use */ +///* cubic polynomials, so this comparison is more or less fair. */ +// process = line(50000, r0, r1) <: FX-tb,FX-ch : par(i, 2, maxerr) +// with { +// C = 0; +// FX = sin; +// NX = 50; +// CD = 3; +// r0 = 0; +// r1 = ma.PI; +// tb(x) = ba.tabulate(C, FX, NX*(CD+1), r0, r1, x).cub; +// ch(x) = ba.tabulate_chebychev(C, FX, NX, CD, r0, r1, x); +// maxerr = abs : max ~ _; +// line(n, x0, x1) = x0 + (ba.time%n)/n * (x1-x0); +// }; +// ``` +// +//-------`(ba.)tabulate`---------- +// Tabulate a 1D function over the range [r0, r1] for access via nearest-value, linear, cubic interpolation. +// In other words, the uniformly tabulated function can be evaluated using interpolation of order 0 (none), 1 (linear), or 3 (cubic). +// +// #### Usage +// +// ``` +// tabulate(C, FX, S, r0, r1, x).(val|lin|cub) : _ +// ``` +// +// * `C`: whether to dynamically force the `x` value to the range [r0, r1]: 1 forces the check, 0 deactivates it (constant numerical expression) +// * `FX`: unary function Y=F(X) with one output (scalar function of one variable) +// * `S`: size of the table in samples (constant numerical expression) +// * `r0`: minimum value of argument x +// * `r1`: maximum value of argument x +// +// ``` +// tabulate(C, FX, S, r0, r1, x).val uses the value in the table closest to x +// ``` +// +// ``` +// tabulate(C, FX, S, r0, r1, x).lin evaluates at x using linear interpolation between the closest stored values +// ``` +// +// ``` +// tabulate(C, FX, S, r0, r1, x).cub evaluates at x using cubic interpolation between the closest stored values +// ``` +// +// #### Example test program +// +// ``` +// midikey2hz(mk) = ba.tabulate(1, ba.midikey2hz, 512, 0, 127, mk).lin; +// process = midikey2hz(ba.time), ba.midikey2hz(ba.time); +// ``` +// +//-------------------------------------------- +tabulate(C, FX, S, r0, r1, x) = environment { + + // Maximum index to access + mid = S-1; + + // Create the table + wf = r0 + float(ba.time)*(r1-r0)/float(mid) : FX; + + // Prepare the 'float' table read index + id = (x-r0)/(r1-r0)*mid; + + // Limit the table read index in [0, mid] if C = 1 + rid(x, 0) = x; + rid(x, 1) = max(0, min(x, mid)); + + // Tabulate an unary 'FX' function on a range [r0, r1] + val = y0 with { y0 = rdtable(S, wf, rid(int(id), C)); }; + + // Tabulate an unary 'FX' function over the range [r0, r1] with linear interpolation + lin = it.interpolate_linear(d,y0,y1) + with { + x0 = int(id); + x1 = x0+1; + d = id-x0; + y0 = rdtable(S, wf, rid(x0, C)); + y1 = rdtable(S, wf, rid(x1, C)); + }; + + // Tabulate an unary 'FX' function over the range [r0, r1] with cubic interpolation + cub = it.interpolate_cubic(d,y0,y1,y2,y3) + with { + x0 = x1-1; + x1 = int(id); + x2 = x1+1; + x3 = x2+1; + d = id-x1; + y0 = rdtable(S, wf, rid(x0, C)); + y1 = rdtable(S, wf, rid(x1, C)); + y2 = rdtable(S, wf, rid(x2, C)); + y3 = rdtable(S, wf, rid(x3, C)); + }; +}; + +declare tabulate author "Stephane Letz"; + + +//-------`(ba.)tabulate_chebychev`---------- +// Tabulate a 1D function over the range [r0, r1] for access via Chebyshev polynomial approximation. +// In contrast to `(ba.)tabulate`, which interpolates only between tabulated samples, `(ba.)tabulate_chebychev` +// stores coefficients of Chebyshev polynomials that are evaluated to provide better approximations in many cases. +// Two new arguments controlling this are NX, the number of segments into which [r0, r1] is divided, and CD, +// the maximum Chebyshev polynomial degree to use for each segment. A `rdtable` of size NX*(CD+1) is internally used. +// +// Note that processing `r1` the last point in the interval is not safe. So either be sure the input stays in [r0, r1[ +// or use `C = 1`. +// +// #### Usage +// +// ``` +// _ : tabulate_chebychev(C, FX, NX, CD, r0, r1) : _ +// ``` +// +// * `C`: whether to dynamically force the value to the range [r0, r1]: 1 forces the check, 0 deactivates it (constant numerical expression) +// * `FX`: unary function Y=F(X) with one output (scalar function of one variable) +// * `NX`: number of segments for uniformly partitioning [r0, r1] (constant numerical expression) +// * `CD`: maximum polynomial degree for each Chebyshev polynomial (constant numerical expression) +// * `r0`: minimum value of argument x +// * `r1`: maximum value of argument x +// +// #### Example test program +// +// ``` +// midikey2hz_chebychev(mk) = ba.tabulate_chebychev(1, ba.midikey2hz, 100, 4, 0, 127, mk); +// process = midikey2hz_chebychev(ba.time), ba.midikey2hz(ba.time); +// ``` +// +//-------------------------------------------- +tabulate_chebychev(C, FX, NX, CD, r0, r1, x) = y with { + ck(0) = _; + ck(1) = max(0) : min(NX-1); + + // number of chebyshev coefficients + NC = CD + 1; + // length of the segments + DX = (r1 - r0) / NX; + // number of segment 'x' falls in + nx = (x - r0) / DX : int : ck(C); + // center of n's segment + xc(n) = r0 + DX * (n + 1/2); + // so ch(0) .. ch(NC) are the coeffs we use for approximation + // on nx's segment + ch(i) = chtab(NC * nx + i); + + // map the input in segment [nx*DX, (nx+1)*DX] to [-1,1] + y = (x - xc(nx)) * 2/DX <: sum(i, NC, ch(i) * ma.chebychev(i)); + + // map [-1,1] to the segment [nx*DX, (nx+1)*DX] so mapfx(nx) + // is simply the "renormalized" FX defined on [-1,1] + mapfx(nx, x) = FX(xc(nx) + DX/2 * x); + + // calculate the nc's chebyshev coefficient we use on nx's segment + gench(nx, nc) = (1+(nc!=0))/NC * sum(k,NC, + mapfx(nx, cos(ma.PI*(k+1/2)/NC)) * cos(ma.PI*nc*(k+1/2)/NC)); + + // record gench(nx, nc) in rdtable() to avoid the run-time calculations + chtab = rdtable(NX*NC, (ba.time <: int(/(NC)), %(NC) : gench)); +}; + +declare tabulate_chebychev author "Oleg Nesterov"; +declare tabulate_chebychev copyright "Copyright (C) 2022 Oleg Nesterov "; +declare tabulate_chebychev license "MIT-style STK-4.3 license"; + + +//============================Selectors (Conditions)====================================== +//======================================================================================== + +//-----------------------------`(ba.)if`----------------------------------- +// if-then-else implemented with a select2. WARNING: since `select2` is strict (always evaluating both branches), +// the resulting if does not have the usual "lazy" semantic of the C if form, and thus cannot be used to +// protect against forbidden computations like division-by-zero for instance. +// +// #### Usage +// +// * `if(cond, then, else) : _` +// +// Where: +// +// * `cond`: condition +// * `then`: signal selected while cond is true +// * `else`: signal selected while cond is false +//----------------------------------------------------------------------------- +if(cond,then,else) = select2(cond,else,then); +// TODO: perhaps it would make more sense to have an if(a,b) and an ifelse(a,b,c)? + + +//-----------------------------`(ba.)selector`--------------------------------- +// Selects the ith input among n at compile time. +// +// #### Usage +// +// ``` +// selector(I,N) +// _,_,_,_ : selector(2,4) : _ // selects the 3rd input among 4 +// ``` +// +// Where: +// +// * `I`: input to select (int, numbered from 0, known at compile time) +// * `N`: number of inputs (int, known at compile time, N > I) +// +// There is also cselector for selecting among complex input signals of the form (real,imag). +// +//----------------------------------------------------------------------------- +selector(i,n) = par(j, n, S(i, j)) with { S(i,i) = _; S(i,j) = !; }; +cselector(i,n) = par(j, n, S(i, j)) with { S(i,i) = (_,_); S(i,j) = (!,!); }; // for complex numbers + + +//--------------------`(ba.)select2stereo`-------------------- +// Select between 2 stereo signals. +// +// #### Usage +// +// ``` +// _,_,_,_ : select2stereo(bpc) : _,_ +// ``` +// +// Where: +// +// * `bpc`: the selector switch (0/1) +//------------------------------------------------------------ +select2stereo(bpc) = ro.cross2 : select2(bpc), select2(bpc) : _,_; + + +//-----------------------------`(ba.)selectn`--------------------------------- +// Selects the ith input among N at run time. +// +// #### Usage +// +// ``` +// selectn(N,i) +// _,_,_,_ : selectn(4,2) : _ // selects the 3rd input among 4 +// ``` +// +// Where: +// +// * `N`: number of inputs (int, known at compile time, N > 0) +// * `i`: input to select (int, numbered from 0) +// +// #### Example test program +// +// ``` +// N = 64; +// process = par(n, N, (par(i,N,i) : selectn(N,n))); +// ``` +//----------------------------------------------------------------------------- +selectn(N,i) = selectnX(N,i,selector) +with { + selector(i,j,x,y) = select2((i >= j), x, y); +}; + + +// The generic version with a 'sel' function to be applied on: +// - the channel index as a (possibly) fractional value +// - the next channel index as an integer value +// - the 2 signals to be selected between + +selectnX(N,i,sel) = S(N,0) +with { + S(1,offset) = _; + S(n,offset) = S(left, offset), S(right, offset+left) : sel(i, offset+left) + with { + right = int(n/2); + left = n-right; + }; +}; + + +//-----------------------------`(ba.)selectmulti`--------------------------------- +// Selects the ith circuit among N at run time (all should have the same number of inputs and outputs) +// with a crossfade. +// +// #### Usage +// +// ``` +// selectmulti(n,lgen,id) +// ``` +// +// Where: +// +// * `n`: crossfade in samples +// * `lgen`: list of circuits +// * `id`: circuit to select (int, numbered from 0) +// +// #### Example test program +// +// ``` +// process = selectmulti(ma.SR/10, ((3,9),(2,8),(5,7)), nentry("choice", 0, 0, 2, 1)); +// process = selectmulti(ma.SR/10, ((_*3,_*9),(_*2,_*8),(_*5,_*7)), nentry("choice", 0, 0, 2, 1)); +// ``` +//----------------------------------------------------------------------------- +selectmulti(n, lgen, id) = selectmultiX(ins, lgen, id) +with { + selectmultiX(0, lgen, id) = selector; // No inputs + selectmultiX(N, lgen, id) = par(i, ins, _) <: selector; // General case + + selector = lgen : ro.interleave(outs, N) : par(i, outs, selectnX(N, id, xfade)) + with { + // crossfade of 'n' samples between 'x' and 'y' channels when the channel index changes + xfade(i, j, x, y) = x*(1-xb) + y*xb with { xb = ramp(n, (i >= j)); }; + }; + + outs = outputs(take(1, lgen)); // Number of outputs of the first circuit (all should have the same value) + ins = inputs(take(1, lgen)); // Number of inputs of the first circuit (all should have the same value) + N = outputs(lgen)/outs; // Number of items in the list +}; + + +//-----------------------------`(ba.)selectoutn`--------------------------------- +// Route input to the output among N at run time. +// +// #### Usage +// +// ``` +// _ : selectoutn(N, i) : si.bus(N) +// ``` +// +// Where: +// +// * `N`: number of outputs (int, known at compile time, N > 0) +// * `i`: output number to route to (int, numbered from 0) (i.e. slider) +// +// #### Example test program +// +// ``` +// process = 1 : selectoutn(3, sel) : par(i, 3, vbargraph("v.bargraph %i", 0, 1)); +// sel = hslider("volume", 0, 0, 2, 1) : int; +// ``` +//-------------------------------------------------------------------------- +declare selectoutn author "Vince"; + +selectoutn(N, s) = _ <: par(i, N, *(s==i)); + + +//=====================================Other============================================== +//======================================================================================== + +//----------------------------`(ba.)latch`-------------------------------- +// Latch input on positive-going transition of trig:"records" the input when trig +// switches from 0 to 1, outputs a frozen values everytime else. +// +// #### Usage +// +// ``` +// _ : latch(trig) : _ +// ``` +// +// Where: +// +// * `trig`: hold trigger (0 for hold, 1 for bypass) +//------------------------------------------------------------ +latch(trig, x) = x * s : + ~ *(1-s) with { s = (trig' <= 0) & (trig > 0); }; + + +//--------------------------`(ba.)sAndH`------------------------------- +// Sample And Hold: "records" the input when trig is 1, outputs a frozen value when trig is 0. +// `sAndH` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : sAndH(trig) : _ +// ``` +// +// Where: +// +// * `trig`: hold trigger (0 for hold, 1 for bypass) +//---------------------------------------------------------------- +declare sAndH author "Romain Michon"; + +sAndH(trig) = select2(trig,_,_) ~ _; + + +//--------------------------`(ba.)downSample`------------------------------- +// Down sample a signal. WARNING: this function doesn't change the +// rate of a signal, it just holds samples... +// `downSample` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : downSample(freq) : _ +// ``` +// +// Where: +// +// * `freq`: new rate in Hz +//---------------------------------------------------------------- +declare downSample author "Romain Michon"; + +downSample(freq) = sAndH(hold) +with { + hold = time%int(ma.SR/freq) == 0; +}; + + +//------------------`(ba.)peakhold`--------------------------- +// Outputs current max value above zero. +// +// #### Usage +// +// ``` +// _ : peakhold(mode) : _ +// ``` +// +// Where: +// +// `mode` means: +// 0 - Pass through. A single sample 0 trigger will work as a reset. +// 1 - Track and hold max value. +//---------------------------------------------------------------- +declare peakhold author "Jonatan Liljedahl, revised by Romain Michon"; + +peakhold = (*,_ : max) ~ _; + +//------------------`(ba.)peakholder`------------------------------------------- +// +// While peak-holder functions are scarcely discussed in the literature +// (please do send me an email if you know otherwise), common sense +// tells that the expected behaviour should be as follows: the absolute +// value of the input signal is compared with the output of the peak-holder; +// if the input is greater or equal to the output, a new peak is detected +// and sent to the output; otherwise, a timer starts and the current peak +// is held for N samples; once the timer is out and no new peaks have been +// detected, the absolute value of the current input becomes the new peak. +// +// #### Usage +// +// ``` +// _ : peakholder(holdTime) : _ +// ``` +// +// Where: +// +// * `holdTime`: hold time in samples +//------------------------------------------------------------------------------ +declare peakholder author "Dario Sanfilippo"; +declare peakholder copyright + "Copyright (C) 2022 Dario Sanfilippo "; +declare peakholder license "MIT-style STK-4.3 license"; +peakholder(holdTime, x) = loop ~ si.bus(2) : ! , _ + with { + loop(timerState, outState) = timer , output + with { + isNewPeak = abs(x) >= outState; + isTimeOut = timerState >= holdTime; + bypass = isNewPeak | isTimeOut; + timer = ba.if(bypass, 0, timerState + 1); + output = ba.if(bypass, abs(x), outState); + }; + }; + + +/* +// Alternate version with branchless code +//---------------------------------------- +peakholder(holdTime, x) = loop ~ si.bus(2) : ! , _ + with { + loop(timerState, outState) = timer , output + with { + isNewPeak = abs(x) >= outState; + isTimeOut = timerState >= holdTime; + bypass = isNewPeak | isTimeOut; + timer = (1 - bypass) * (timerState + 1); + output = bypass * (abs(x) - outState) + outState; + }; + }; +*/ + +/* +// The function below is kept for back-compatibility in case any user relies +// on it for their software. However, the function behaves differently than +// expected: currently, the timer is not reset when a new peak is detected. +//------------------------------------------------------------------------------ +declare peakholder author "Jonatan Liljedahl"; +peakholder(n) = peakhold2 ~ reset : (!,_) with { + reset = sweep(n) > 0; + // first out is gate that is 1 while holding last peak + peakhold2 = _,abs <: peakhold,!,_ <: >=,_,!; +}; +*/ + + +//--------------------------`(ba.)impulsify`--------------------------- +// Turns a signal into an impulse with the value of the current sample +// (0.3,0.2,0.1 becomes 0.3,0.0,0.0). This function is typically used with a +// `button` to turn its output into an impulse. `impulsify` is a standard Faust +// function. +// +// #### Usage +// +// ``` +// button("gate") : impulsify; +// ``` +//---------------------------------------------------------------- +impulsify = _ <: _,mem : - <: >(0)*_; + + +//-----------------------`(ba.)automat`------------------------------ +// Record and replay in a loop the successives values of the input signal. +// +// #### Usage +// +// ``` +// hslider(...) : automat(t, size, init) : _ +// ``` +// +// Where: +// +// * `t`: tempo in BPM +// * `size`: number of items in the loop +// * `init`: init value in the loop +//----------------------------------------------------------------------- +automat(t, size, init, input) = rwtable(size+1, init, windex, input, rindex) +with { + clock = beat(t); + rindex = int(clock) : (+ : %(size)) ~ _; // each clock read the next entry of the table + windex = if(timeToRenew, rindex, size); // we ignore input unless it is time to renew + timeToRenew = int(clock) & (inputHasMoved | (input <= init)); + inputHasMoved = abs(input-input') : countfrom(int(clock)') : >(0); + countfrom(reset) = (+ : if(reset, 0, _)) ~ _; +}; + + +//-----------------`(ba.)bpf`------------------- +// bpf is an environment (a group of related definitions) that can be used to +// create break-point functions. It contains three functions: +// +// * `start(x,y)` to start a break-point function +// * `end(x,y)` to end a break-point function +// * `point(x,y)` to add intermediate points to a break-point function +// +// A minimal break-point function must contain at least a start and an end point: +// +// ``` +// f = bpf.start(x0,y0) : bpf.end(x1,y1); +// ``` +// +// A more involved break-point function can contains any number of intermediate +// points: +// +// ``` +// f = bpf.start(x0,y0) : bpf.point(x1,y1) : bpf.point(x2,y2) : bpf.end(x3,y3); +// ``` +// +// In any case the `x_{i}` must be in increasing order (for all `i`, `x_{i} < x_{i+1}`). +// For example the following definition: +// +// ``` +// f = bpf.start(x0,y0) : ... : bpf.point(xi,yi) : ... : bpf.end(xn,yn); +// ``` +// +// implements a break-point function f such that: +// +// * `f(x) = y_{0}` when `x < x_{0}` +// * `f(x) = y_{n}` when `x > x_{n}` +// * `f(x) = y_{i} + (y_{i+1}-y_{i})*(x-x_{i})/(x_{i+1}-x_{i})` when `x_{i} <= x` +// and `x < x_{i+1}` +// +// `bpf` is a standard Faust function. +//-------------------------------------------------------- +bpf = environment +{ + // Start a break-point function + start(x0,y0) = \(x).(x0,y0,x,y0); + // Add a break-point + point(x1,y1) = \(x0,y0,x,y).(x1, y1, x, if(x < x0, y, if(x < x1, y0 + (x-x0)*(y1-y0)/(x1-x0), y1))); + // End a break-point function + end(x1,y1) = \(x0,y0,x,y).(if(x < x0, y, if(x < x1, y0 + (x-x0)*(y1-y0)/(x1-x0), y1))); +}; + + +//-------------------`(ba.)listInterp`------------------------- +// Linearly interpolates between the elements of a list. +// +// #### Usage +// +// ``` +// index = 1.69; // range is 0-4 +// process = listInterp((800,400,350,450,325),index); +// ``` +// +// Where: +// +// * `index`: the index (float) to interpolate between the different values. +// The range of `index` depends on the size of the list. +//------------------------------------------------------------ +declare listInterp author "Romain Michon"; + +listInterp(v) = + bpf.start(0,take(1,v)) : + seq(i,count(v)-2,bpf.point(i+1,take(i+2,v))) : + bpf.end(count(v)-1,take(count(v),v)); + + +//-------------------`(ba.)bypass1`------------------------- +// Takes a mono input signal, route it to `e` and bypass it if `bpc = 1`. +// When bypassed, `e` is feed with zeros so that its state is cleanup up. +// `bypass1` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : bypass1(bpc,e) : _ +// ``` +// +// Where: +// +// * `bpc`: bypass switch (0/1) +// * `e`: a mono effect +//------------------------------------------------------------ +declare bypass1 author "Julius Smith"; +// License: STK-4.3 + +bypass1(bpc,e) = _ <: select2(bpc,(inswitch:e),_) +with { + inswitch = select2(bpc,_,0); +}; + + +//-------------------`(ba.)bypass2`------------------------- +// Takes a stereo input signal, route it to `e` and bypass it if `bpc = 1`. +// When bypassed, `e` is feed with zeros so that its state is cleanup up. +// `bypass2` is a standard Faust function. +// +// #### Usage +// +// ``` +// _,_ : bypass2(bpc,e) : _,_ +// ``` +// +// Where: +// +// * `bpc`: bypass switch (0/1) +// * `e`: a stereo effect +//------------------------------------------------------------ +declare bypass2 author "Julius Smith"; +// License: STK-4.3 + +bypass2(bpc,e) = _,_ <: ((inswitch:e),_,_) : select2stereo(bpc) +with { + inswitch = _,_ : (select2(bpc,_,0), select2(bpc,_,0)) : _,_; +}; + + +//-------------------`(ba.)bypass1to2`------------------------- +// Bypass switch for effect `e` having mono input signal and stereo output. +// Effect `e` is bypassed if `bpc = 1`.When bypassed, `e` is feed with zeros +// so that its state is cleanup up. +// `bypass1to2` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : bypass1to2(bpc,e) : _,_ +// ``` +// +// Where: +// +// * `bpc`: bypass switch (0/1) +// * `e`: a mono-to-stereo effect +//------------------------------------------------------------ +declare bypass1to2 author "Julius Smith"; +// License: STK-4.3 + +bypass1to2(bpc,e) = _ <: ((inswitch:e),_,_) : select2stereo(bpc) +with { + inswitch = select2(bpc,_,0); +}; + + +//-------------------`(ba.)bypass_fade`------------------------- +// Bypass an arbitrary (N x N) circuit with 'n' samples crossfade. +// Inputs and outputs signals are faded out when 'e' is bypassed, +// so that 'e' state is cleanup up. +// Once bypassed the effect is replaced by `par(i,N,_)`. +// Bypassed circuits can be chained. +// +// #### Usage +// +// ``` +// _ : bypass_fade(n,b,e) : _ +// or +// _,_ : bypass_fade(n,b,e) : _,_ +// ``` +// * `n`: number of samples for the crossfade +// * `b`: bypass switch (0/1) +// * `e`: N x N circuit +// +// #### Example test program +// +// ``` +// process = bypass_fade(ma.SR/10, checkbox("bypass echo"), echo); +// process = bypass_fade(ma.SR/10, checkbox("bypass reverb"), freeverb); +// ``` +//--------------------------------------------------------------- +bypass_fade(n, b, e) = par(i, ins, _) + <: (par(i, ins, *(1-xb)) : e : par(i, outs, *(1-xb))), par(i, ins, *(xb)) + :> par(i, outs, _) +with { + ins = inputs(e); + outs = outputs(e); + xb = ramp(n, b); +}; + + +//----------------------------`(ba.)toggle`------------------------------------------ +// Triggered by the change of 0 to 1, it toggles the output value +// between 0 and 1. +// +// #### Usage +// +// ``` +// _ : toggle : _ +// ``` +// #### Example test program +// +// ``` +// button("toggle") : toggle : vbargraph("output", 0, 1) +// (an.amp_follower(0.1) > 0.01) : toggle : vbargraph("output", 0, 1) // takes audio input +// ``` +// +//------------------------------------------------------------------------------ +declare toggle author "Vince"; + +toggle = trig : loop +with { + trig(x) = (x-x') == 1; + loop = != ~ _; +}; + + +//----------------------------`(ba.)on_and_off`------------------------------------------ +// The first channel set the output to 1, the second channel to 0. +// +// #### Usage +// +// ``` +// _,_ : on_and_off : _ +// ``` +// +// #### Example test program +// +// ``` +// button("on"), button("off") : on_and_off : vbargraph("output", 0, 1) +// ``` +// +//------------------------------------------------------------------------------ +declare on_and_off author "Vince"; + +on_and_off(a, b) = (a : trig) : loop(b) +with { + trig(x) = (x-x') == 1; + loop(b) = + ~ (_ >= 1) * ((b : trig) == 0); +}; + + +//----------------------------`(ba.)bitcrusher`------------------------------------------ +// Produce distortion by reduction of the signal resolution. +// +// #### Usage +// +// ``` +// _ : bitcrusher(nbits) : _ +// ``` +// +// Where: +// +// * `nbits`: the number of bits of the wanted resolution +// +//------------------------------------------------------------------------------ +declare bitcrusher author "Julius O. Smith III, revised by Stephane Letz"; + +bitcrusher(nbits,x) = round(x * scaler) / scaler +with { + scaler = float(2^nbits - 1); + round(x) = floor(x + 0.5); +}; + + +//=================================Sliding Reduce========================================= +// Provides various operations on the last n samples using a high order +// `slidingReduce(op,n,maxN,disabledVal,x)` fold-like function: +// +// * `slidingSum(n)`: the sliding sum of the last n input samples, CPU-light +// * `slidingSump(n,maxN)`: the sliding sum of the last n input samples, numerically stable "forever" +// * `slidingMax(n,maxN)`: the sliding max of the last n input samples +// * `slidingMin(n,maxN)`: the sliding min of the last n input samples +// * `slidingMean(n)`: the sliding mean of the last n input samples, CPU-light +// * `slidingMeanp(n,maxN)`: the sliding mean of the last n input samples, numerically stable "forever" +// * `slidingRMS(n)`: the sliding RMS of the last n input samples, CPU-light +// * `slidingRMSp(n,maxN)`: the sliding RMS of the last n input samples, numerically stable "forever" +// +// #### Working Principle +// +// If we want the maximum of the last 8 values, we can do that as: +// +// ``` +// simpleMax(x) = +// ( +// ( +// max(x@0,x@1), +// max(x@2,x@3) +// ) :max +// ), +// ( +// ( +// max(x@4,x@5), +// max(x@6,x@7) +// ) :max +// ) +// :max; +// ``` +// +// `max(x@2,x@3)` is the same as `max(x@0,x@1)@2` but the latter re-uses a +// value we already computed,so is more efficient. Using the same trick for +// values 4 trough 7, we can write: +// +// ``` +// efficientMax(x)= +// ( +// ( +// max(x@0,x@1), +// max(x@0,x@1)@2 +// ) :max +// ), +// ( +// ( +// max(x@0,x@1), +// max(x@0,x@1)@2 +// ) :max@4 +// ) +// :max; +// ``` +// +// We can rewrite it recursively, so it becomes possible to get the maximum at +// have any number of values, as long as it's a power of 2. +// +// ``` +// recursiveMax = +// case { +// (1,x) => x; +// (N,x) => max(recursiveMax(N/2,x), recursiveMax(N/2,x)@(N/2)); +// }; +// ``` +// +// What if we want to look at a number of values that's not a power of 2? +// For each value, we will have to decide whether to use it or not. +// If n is bigger than the index of the value, we use it, otherwise we replace +// it with (`0-(ma.MAX)`): +// +// ``` +// variableMax(n,x) = +// max( +// max( +// ( +// (x@0 : useVal(0)), +// (x@1 : useVal(1)) +// ):max, +// ( +// (x@2 : useVal(2)), +// (x@3 : useVal(3)) +// ):max +// ), +// max( +// ( +// (x@4 : useVal(4)), +// (x@5 : useVal(5)) +// ):max, +// ( +// (x@6 : useVal(6)), +// (x@7 : useVal(7)) +// ):max +// ) +// ) +// with { +// useVal(i) = select2((n>=i) , (0-(ma.MAX)),_); +// }; +// ``` +// +// Now it becomes impossible to re-use any values. To fix that let's first look +// at how we'd implement it using recursiveMax, but with a fixed n that is not +// a power of 2. For example, this is how you'd do it with `n=3`: +// +// ``` +// binaryMaxThree(x) = +// ( +// recursiveMax(1,x)@0, // the first x +// recursiveMax(2,x)@1 // the second and third x +// ):max; +// ``` +// +// `n=6` +// +// ``` +// binaryMaxSix(x) = +// ( +// recursiveMax(2,x)@0, // first two +// recursiveMax(4,x)@2 // third trough sixth +// ):max; +// ``` +// +// Note that `recursiveMax(2,x)` is used at a different delay then in +// `binaryMaxThree`, since it represents 1 and 2, not 2 and 3. Each block is +// delayed the combined size of the previous blocks. +// +// `n=7` +// +// ``` +// binaryMaxSeven(x) = +// ( +// ( +// recursiveMax(1,x)@0, // first x +// recursiveMax(2,x)@1 // second and third +// ):max, +// ( +// recursiveMax(4,x)@3 // fourth trough seventh +// ) +// ):max; +// ``` +// +// To make a variable version, we need to know which powers of two are used, +// and at which delay time. +// +// Then it becomes a matter of: +// +// * lining up all the different block sizes in parallel: `sequentialOperatorParOut()` +// * delaying each the appropriate amount: `sumOfPrevBlockSizes()` +// * turning it on or off: `useVal()` +// * getting the maximum of all of them: `parallelOp()` +// +// In Faust, we can only do that for a fixed maximum number of values: `maxN`, known at compile time. + +//======================================================================================== +// Section contributed by Bart Brouns (bart@magnetophon.nl). +// SPDX-License-Identifier: GPL-3.0 +// Copyright (C) 2018 Bart Brouns + + +//-----------------------------`(ba.)slidingReduce`----------------------------- +// Fold-like high order function. Apply a commutative binary operation `op` to +// the last `n` consecutive samples of a signal `x`. For example : +// `slidingReduce(max,128,128,0-(ma.MAX))` will compute the maximum of the last +// 128 samples. The output is updated each sample, unlike reduce, where the +// output is constant for the duration of a block. +// +// #### Usage +// +// ``` +// _ : slidingReduce(op,n,maxN,disabledVal) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +// * `maxN`: the maximum number of values to process (int, known at compile time, maxN > 0) +// * `op`: the operator. Needs to be a commutative one. +// * `disabledVal`: the value to use when we want to ignore a value. +// +// In other words, `op(x,disabledVal)` should equal to `x`. For example, +// `+(x,0)` equals `x` and `min(x,ma.MAX)` equals `x`. So if we want to +// calculate the sum, we need to give 0 as `disabledVal`, and if we want the +// minimum, we need to give `ma.MAX` as `disabledVal`. +//------------------------------------------------------------------------------ +slidingReduce(op,n,0,disabledVal) = 0:!; +slidingReduce(op,n,1,disabledVal) = _; +slidingReduce(op,n,maxN,disabledVal) = + sequentialOperatorParOut(maxNrBits(maxN)-1,op) : par(i, maxNrBits(maxN), _@sumOfPrevBlockSizes(i) : useVal(i)) : parallelOp(op, maxNrBits(maxN)) + with { + sequentialOperatorParOut(N,op) = seq(i, N, operator(i)); + operator(i) = si.bus(i), (_<: _ , op(_,_@(pow2(i)))); + + // The sum of all the sizes of the previous blocks + sumOfPrevBlockSizes(0) = 0; + sumOfPrevBlockSizes(i) = (ba.subseq((allBlockSizes),0,i):>_); + + allBlockSizes = par(i, maxNrBits(maxN-1), (pow2(i)) * isUsed(i)); + maxNrBits(n) = int2nrOfBits(n); + + // Decide wether or not to use a certain value, based on n + useVal(i) = select2(isUsed(i), disabledVal, _); + + isUsed(i) = ba.take(i+1, (int2bin(n,(maxN-1)*2+1))); + pow2(i) = 1< -; + + +//------------------------------`(ba.)slidingSump`------------------------------ +// The sliding sum of the last n input samples. +// +// It uses a lot more CPU than `ba.slidingSum`, but is numerically stable "forever" in return. +// +// #### Usage +// +// ``` +// _ : slidingSump(n,maxN) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +// * `maxN`: the maximum number of values to process (int, known at compile time, maxN > 0) +//------------------------------------------------------------------------------ +slidingSump(n,maxN) = slidingReduce(+,n,maxN,0); + + +//----------------------------`(ba.)slidingMax`-------------------------------- +// The sliding maximum of the last n input samples. +// +// #### Usage +// +// ``` +// _ : slidingMax(n,maxN) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +// * `maxN`: the maximum number of values to process (int, known at compile time, maxN > 0) +//------------------------------------------------------------------------------ +slidingMax(n,maxN) = slidingReduce(max,n,maxN,0-(ma.MAX)); + +//----------------------------`(ba.)slidingMin`-------------------------------- +// The sliding minimum of the last n input samples. +// +// #### Usage +// +// ``` +// _ : slidingMin(n,maxN) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +// * `maxN`: the maximum number of values to process (int, known at compile time, maxN > 0) +//------------------------------------------------------------------------------ +slidingMin(n,maxN) = slidingReduce(min,n,maxN,ma.MAX); + + +//----------------------------`(ba.)slidingMean`------------------------------- +// The sliding mean of the last n input samples. +// +// It will eventually run into numerical trouble when there is a persistent dc component. +// If that matters in your application, use the more CPU-intensive `ba.slidingMeanp`. +// +// #### Usage +// +// ``` +// _ : slidingMean(n) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +//------------------------------------------------------------------------------ +slidingMean(n) = slidingSum(n)/n; + + +//----------------------------`(ba.)slidingMeanp`------------------------------- +// The sliding mean of the last n input samples. +// +// It uses a lot more CPU than `ba.slidingMean`, but is numerically stable "forever" in return. +// +// #### Usage +// +// ``` +// _ : slidingMeanp(n,maxN) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +// * `maxN`: the maximum number of values to process (int, known at compile time, maxN > 0) +//------------------------------------------------------------------------------ +slidingMeanp(n,maxN) = slidingSump(n,maxN)/n; + + +//---------------------------`(ba.)slidingRMS`--------------------------------- +// The root mean square of the last n input samples. +// +// It will eventually run into numerical trouble when there is a persistent dc component. +// If that matters in your application, use the more CPU-intensive `ba.slidingRMSp`. + +// +// #### Usage +// +// ``` +// _ : slidingRMS(n) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +//------------------------------------------------------------------------------ +slidingRMS(n) = pow(2) : slidingMean(n) : sqrt; + + +//---------------------------`(ba.)slidingRMSp`--------------------------------- +// The root mean square of the last n input samples. +// +// It uses a lot more CPU than `ba.slidingRMS`, but is numerically stable "forever" in return. +// +// #### Usage +// +// ``` +// _ : slidingRMSp(n,maxN) : _ +// ``` +// +// Where: +// +// * `n`: the number of values to process +// * `maxN`: the maximum number of values to process (int, known at compile time, maxN > 0) +//------------------------------------------------------------------------------ +slidingRMSp(n,maxn) = pow(2) : slidingMeanp(n,maxn) : sqrt; + + +//======================================================================================== +// section contributed by Bart Brouns (bart@magnetophon.nl). +// spdx-license-identifier: gpl-3.0 +// copyright (c) 2020 Bart Brouns + +//=================================Parallel Operators========================================= +// Provides various operations on N parallel inputs using a high order +// `parallelOp(op,N,x)` function: +// +// * `parallelMax(N)`: the max of n parallel inputs +// * `parallelMin(N)`: the min of n parallel inputs +// * `parallelMean(N)`: the mean of n parallel inputs +// * `parallelRMS(N)`: the RMS of n parallel inputs + +//-----------------------------`(ba.)parallelOp`----------------------------- +// Apply a commutative binary operation `op` to N parallel inputs. +// +// #### usage +// +// ``` +// si.bus(N) : parallelOp(op,N) : _ +// ``` +// +// where: +// +// * `N`: the number of parallel inputs known at compile time +// * `op`: the operator which needs to be commutative +// +//------------------------------------------------------------------------------ + +parallelOp(op,1) = _; +parallelOp(op,2) = op; +parallelOp(op,n) = op(parallelOp(op,n-1)); + +declare parallelOp author "Bart Brouns"; +declare parallelOp licence "GPL-3.0"; +declare parallelOp copyright "Copyright (c) 2020 Bart Brouns "; + + +//---------------------------`(ba.)parallelMax`--------------------------------- +// The maximum of N parallel inputs. +// +// #### Usage +// +// ``` +// si.bus(N) : parallelMax(N) : _ +// ``` +// +// Where: +// +// * `N`: the number of parallel inputs known at compile time +//------------------------------------------------------------------------------ +parallelMax(n) = parallelOp(max,n); + +declare parallelMax author "Bart Brouns"; +declare parallelMax licence "GPL-3.0"; +declare parallelMax copyright "Copyright (c) 2020 Bart Brouns "; + + +//---------------------------`(ba.)parallelMin`--------------------------------- +// The minimum of N parallel inputs. +// +// #### Usage +// +// ``` +// si.bus(N) : parallelMin(N) : _ +// ``` +// +// Where: +// +// * `N`: the number of parallel inputs known at compile time +//------------------------------------------------------------------------------ +parallelMin(n) = parallelOp(min,n); + +declare parallelMin author "Bart Brouns"; +declare parallelMin licence "GPL-3.0"; +declare parallelMin copyright "Copyright (c) 2020 Bart Brouns "; + + +//---------------------------`(ba.)parallelMean`--------------------------------- +// The mean of N parallel inputs. +// +// #### Usage +// +// ``` +// si.bus(N) : parallelMean(N) : _ +// ``` +// +// Where: +// +// * `N`: the number of parallel inputs known at compile time +//------------------------------------------------------------------------------ +parallelMean(n) = si.bus(n):>_/n; + +declare parallelMean author "Bart Brouns"; +declare parallelMean licence "GPL-3.0"; +declare parallelMean copyright "Copyright (c) 2020 Bart Brouns "; + +//---------------------------`(ba.)parallelRMS`--------------------------------- +// The RMS of N parallel inputs. +// +// #### Usage +// +// ``` +// si.bus(N) : parallelRMS(N) : _ +// ``` +// +// Where: +// +// * `N`: the number of parallel inputs known at compile time +//------------------------------------------------------------------------------ +parallelRMS(n) = par(i, n, pow(2)) : parallelMean(n) : sqrt; + +declare parallelRMS author "Bart Brouns"; +declare parallelRMS licence "GPL-3.0"; +declare parallelRMS copyright "Copyright (c) 2020 Bart Brouns "; + +//////////////////////////////////Deprecated Functions//////////////////////////////////// +// This section implements functions that used to be in music.lib but that are now +// considered as "deprecated". +////////////////////////////////////////////////////////////////////////////////////////// + +millisec = ma.SR/1000.0; + +time1s = hslider("time", 0, 0, 1000, 0.1)*millisec; +time2s = hslider("time", 0, 0, 2000, 0.1)*millisec; +time5s = hslider("time", 0, 0, 5000, 0.1)*millisec; +time10s = hslider("time", 0, 0, 10000, 0.1)*millisec; +time21s = hslider("time", 0, 0, 21000, 0.1)*millisec; +time43s = hslider("time", 0, 0, 43000, 0.1)*millisec; diff --git a/dist/examples/LIBRARIES/compressors.lib b/dist/examples/LIBRARIES/compressors.lib new file mode 100644 index 00000000..571647fb --- /dev/null +++ b/dist/examples/LIBRARIES/compressors.lib @@ -0,0 +1,1340 @@ +//#################################### compressors.lib ################################### +// A library of compressor effects. Its official prefix is `co`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2003-2016 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ba = library("basics.lib"); +si = library("signals.lib"); +an = library("analyzers.lib"); +ro = library("routes.lib"); +ma = library("maths.lib"); +it = library("interpolators.lib"); + +declare name "Faust Compressor Effect Library"; +declare version "0.4"; + +//=============================Functions Reference======================================== +//======================================================================================== + +//--------------------`(co.)peak_compression_gain_mono_db`------------------- +// Mono dynamic range compressor gain computer with dB output. +// `peak_compression_gain_mono_db` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : peak_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost) : _ +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare peak_compression_gain_mono_db author "Bart Brouns"; +declare peak_compression_gain_mono_db license "GPLv3"; + +peak_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost) = + abs : ba.bypass1(prePost,si.onePoleSwitching(att,rel)) : ba.linear2db : gain_computer(strength,thresh,knee) : ba.bypass1((prePost !=1),si.onePoleSwitching(rel,att)) +with { + gain_computer(strength,thresh,knee,level) = + select3((level>(thresh-(knee/2)))+(level>(thresh+(knee/2))), + 0, + ((level-thresh+(knee/2)) : pow(2)/(2*max(ma.EPSILON,knee))), + (level-thresh)) + : max(0)*-strength; +}; + + +//--------------------`(co.)peak_compression_gain_N_chan_db`------------------- +// N channels dynamic range compressor gain computer with dB output. +// `peak_compression_gain_N_chan_db` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : peak_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare peak_compression_gain_N_chan_db author "Bart Brouns"; +declare peak_compression_gain_N_chan_db license "GPLv3"; + +// generalise compression gains for N channels. +// first we define a mono version: +peak_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,1) = + peak_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost); + +// The actual N-channels version: +// Calculate the maximum gain reduction of N channels, +// and then crossfade between that and each channel's own gain reduction, +// to link/unlink channels +peak_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N) = + par(i, N, peak_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost)) + <: (si.bus(N),(ba.parallelMin(N) <: si.bus(N))) : ro.interleave(N,2) : par(i,N,(it.interpolate_linear(link))); + + +//--------------------`(co.)FFcompressor_N_chan`------------------- +// Feed forward N channels dynamic range compressor. +// `FFcompressor_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : FFcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,meter,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `meter`: a gain reduction meter. It can be implemented like so: +// `meter = _<:(_, (ba.linear2db:max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare FFcompressor_N_chan author "Bart Brouns"; +declare FFcompressor_N_chan license "GPLv3"; + +// feed forward compressor +FFcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,meter,N) = + si.bus(N) <: (peak_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N),si.bus(N)) : ro.interleave(N,2) : par(i,N,(meter: ba.db2linear)*_); + + +//--------------------`(co.)FBcompressor_N_chan`------------------- +// Feed back N channels dynamic range compressor. +// `FBcompressor_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : FBcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,meter,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `meter`: a gain reduction meter. It can be implemented like so: +// `meter = _ <: (_,(ba.linear2db:max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// or it can be omitted by defining `meter = _;`. +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare FBcompressor_N_chan author "Bart Brouns"; +declare FBcompressor_N_chan license "GPLv3"; + +FBcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,meter,N) = + (peak_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N),si.bus(N) : (ro.interleave(N,2) : par(i,N,(meter : ba.db2linear)*_))) ~ si.bus(N); + + +//--------------------`(co.)FBFFcompressor_N_chan`------------------- +// Feed forward / feed back N channels dynamic range compressor. +// The feedback part has a much higher strength, so they end up sounding similar. +// `FBFFcompressor_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : FBFFcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,FBFF,meter,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `FBFF`: fade between feed forward (0) and feed back (1) compression. +// * `meter`: a gain reduction meter. It can be implemented like so: +// `meter = _<:(_,(max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare FBFFcompressor_N_chan author "Bart Brouns"; +declare FBFFcompressor_N_chan license "GPLv3"; + +FBFFcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,FBFF,meter,N) = + si.bus(N) <: si.bus(N*2) : + ( + ((par(i,2,peak_compression_gain_N_chan_db(strength*(1+((i==0)*2)),thresh,att,rel,knee,prePost,link,N)) : ro.interleave(N,2) : par(i,N,it.interpolate_linear(FBFF))),si.bus(N)) + : (ro.interleave(N,2) : par(i,N,(meter : ba.db2linear)*_)) + ) + ~ si.bus(N); + + +//--------------------`(co.)RMS_compression_gain_mono_db`------------------- +// Mono RMS dynamic range compressor gain computer with dB output. +// `RMS_compression_gain_mono_db` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : RMS_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost) : _ +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare RMS_compression_gain_mono_db author "Bart Brouns"; +declare RMS_compression_gain_mono_db license "GPLv3"; + +RMS_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost) = + RMS(rel) : ba.bypass1(prePost,si.onePoleSwitching(att,0)) : ba.linear2db : gain_computer(strength,thresh,knee) : ba.bypass1((prePost!=1),si.onePoleSwitching(0,att)) + with { + gain_computer(strength,thresh,knee,level) = + select3((level>(thresh-(knee/2)))+(level>(thresh+(knee/2))), + 0, + ((level-thresh+(knee/2)) : pow(2)/(2*max(ma.EPSILON,knee))), + (level-thresh)) + : max(0)*-strength; + RMS(time) = ba.slidingRMS(s) with { + s = ba.sec2samp(time):int:max(1); + }; + }; + +//--------------------`(co.)RMS_compression_gain_N_chan_db`------------------- +// RMS N channels dynamic range compressor gain computer with dB output. +// `RMS_compression_gain_N_chan_db` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : RMS_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `N`: the number of channels of the compressor +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare RMS_compression_gain_N_chan_db author "Bart Brouns"; +declare RMS_compression_gain_N_chan_db license "GPLv3"; + +RMS_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,1) = + RMS_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost); + +RMS_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N) = + par(i,N,RMS_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost)) + <: (si.bus(N),(ba.parallelMin(N) <: si.bus(N))) : ro.interleave(N,2) : par(i,N,(it.interpolate_linear(link))); + + +//--------------------`(co.)RMS_FBFFcompressor_N_chan`------------------- +// RMS feed forward / feed back N channels dynamic range compressor. +// the feedback part has a much higher strength, so they end up sounding similar +// `RMS_FBFFcompressor_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : RMS_FBFFcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,FBFF,meter,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `FBFF`: fade between feed forward (0) and feed back (1) compression. +// * `meter`: a gain reduction meter. It can be implemented like so: +// `meter = _<:(_,(max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// To save CPU we cheat a bit, in a similar way as in the original libs: +// instead of crosfading between two sets of gain calculators as above, +// we take the abs of the audio from both the FF and FB, and crossfade between those, +// and feed that into one set of gain calculators +// again the strength is much higher when in FB mode, but implemented differently. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare RMS_FBFFcompressor_N_chan author "Bart Brouns"; +declare RMS_FBFFcompressor_N_chan license "GPLv3"; + +RMS_FBFFcompressor_N_chan(strength,thresh,att,rel,knee,prePost,link,FBFF,meter,N) = + si.bus(N) <: si.bus(N*2): + ( + ((ro.interleave(N,2) : par(i,N*2,abs) :par(i,N,it.interpolate_linear(FBFF)) : RMS_compression_gain_N_chan_db(strength*(1+((FBFF*-1)+1)),thresh,att,rel,knee,prePost,link,N)),si.bus(N)) + : (ro.interleave(N,2) : par(i,N,(meter: ba.db2linear)*_)) + ) + ~ si.bus(N); + + +//--------------------`(co.)RMS_FBcompressor_peak_limiter_N_chan`------------------- +// N channel RMS feed back compressor into peak limiter feeding back into the FB compressor. +// By combining them this way, they complement each other optimally: +// the RMS compressor doesn't have to deal with the peaks, +// and the peak limiter get's spared from the steady state signal. +// The feedback part has a much higher strength, so they end up sounding similar. +// `RMS_FBcompressor_peak_limiter_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : RMS_FBcompressor_peak_limiter_N_chan(strength,thresh,threshLim,att,rel,knee,link,meter,meterLim,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `threshLim`: dB level threshold above which the brickwall limiter kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// this is also used as the release time of the limiter +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// the limiter uses a knee half this size +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `meter`: compressor gain reduction meter. It can be implemented like so: +// `meter = _<:(_,(max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// * `meterLim`: brickwall limiter gain reduction meter. It can be implemented like so: +// `meterLim = _<:(_,(max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare RMS_FBcompressor_peak_limiter_N_chan author "Bart Brouns"; +declare RMS_FBcompressor_peak_limiter_N_chan license "GPLv3"; + +RMS_FBcompressor_peak_limiter_N_chan(strength,thresh,threshLim,att,rel,knee,link,meter,meterLim,N) = + (((RMS_compression_gain_N_chan_db(strength,thresh,att,rel,knee,0,link,N)),si.bus(N)) : ro.interleave(N,2) : par(i,N,(meter : ba.db2linear)*_) : FFcompressor_N_chan(1,threshLim,0,att:min(rel),knee*0.5,0,link,meterLim : ba.db2linear,N)) + ~ si.bus(N); + + +//===========================Linear gain computer section================================= +// The gain computer functions in this section have been replaced by a version that outputs dBs, +// but we retain the linear output version for backward compatibility. +//======================================================================================== +// +//--------------------`(co.)peak_compression_gain_mono`------------------- +// Mono dynamic range compressor gain computer with linear output. +// `peak_compression_gain_mono` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : peak_compression_gain_mono(strength,thresh,att,rel,knee,prePost) : _ +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare peak_compression_gain_mono author "Bart Brouns"; +declare peak_compression_gain_mono license "GPLv3"; + +peak_compression_gain_mono(strength,thresh,att,rel,knee,prePost) = + peak_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost):ba.db2linear; + + +//--------------------`(co.)peak_compression_gain_N_chan`------------------- +// N channels dynamic range compressor gain computer with linear output. +// `peak_compression_gain_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : peak_compression_gain_N_chan(strength,thresh,att,rel,knee,prePost,link,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare peak_compression_gain_N_chan author "Bart Brouns"; +declare peak_compression_gain_N_chan license "GPLv3"; + +// generalise compression gains for N channels. +// first we define a mono version: +peak_compression_gain_N_chan(strength,thresh,att,rel,knee,prePost,link,N) = + peak_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N) + : par(i, N, ba.db2linear); + +//--------------------`(co.)RMS_compression_gain_mono`------------------- +// Mono RMS dynamic range compressor gain computer with linear output. +// `RMS_compression_gain_mono` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : RMS_compression_gain_mono(strength,thresh,att,rel,knee,prePost) : _ +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare RMS_compression_gain_mono author "Bart Brouns"; +declare RMS_compression_gain_mono license "GPLv3"; + +RMS_compression_gain_mono(strength,thresh,att,rel,knee,prePost) = + RMS_compression_gain_mono_db(strength,thresh,att,rel,knee,prePost):ba.db2linear; + + +//--------------------`(co.)RMS_compression_gain_N_chan`------------------- +// RMS N channels dynamic range compressor gain computer with linear output. +// `RMS_compression_gain_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : RMS_compression_gain_N_chan(strength,thresh,att,rel,knee,prePost,link,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the compression (0 = no compression, 1 means hard limiting, >1 means over-compression) +// * `thresh`: dB level threshold above which compression kicks in +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// * `knee`: a gradual increase in gain reduction around the threshold: +// below thresh-(knee/2) there is no gain reduction, +// above thresh+(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-threshold detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `N`: the number of channels of the compressor, known at compile time +// +// It uses a strength parameter instead of the traditional ratio, in order to be able to +// function as a hard limiter. +// For that you'd need a ratio of infinity:1, and you cannot express that in Faust. +// +// Sometimes even bigger ratios are useful: +// for example a group recording where one instrument is recorded with both a close microphone and a room microphone, +// and the instrument is loud enough in the room mic when playing loud, but you want to boost it when it is playing soft. +// +// #### References +// +// * +// * Digital Dynamic Range Compressor Design, +// A Tutorial and Analysis, +// Dimitrios GIANNOULIS (), +// Michael MASSBERG (), +// and Josuah D.REISS () +//------------------------------------------------------------ + +declare RMS_compression_gain_N_chan author "Bart Brouns"; +declare RMS_compression_gain_N_chan license "GPLv3"; + +RMS_compression_gain_N_chan(strength,thresh,att,rel,knee,prePost,link,N) = + RMS_compression_gain_N_chan_db(strength,thresh,att,rel,knee,prePost,link,N) + : par(i, N, ba.db2linear); + + +//=============================Original versions section============================= +// The functions in this section are largely superseded by the limiters above, but we +// retain them for backward compatibility and for situations in which a more permissive, +// MIT-style license is required. +//======================================================================================== + +//--------------------`(co.)compressor_lad_mono`------------------- +// Mono dynamic range compressor with lookahead delay. +// `compressor_lad_mono` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : compressor_lad_mono(lad,ratio,thresh,att,rel) : _ +// ``` +// +// Where: +// +// * `lad`: lookahead delay in seconds (nonnegative) - gets rounded to nearest sample. +// The effective attack time is a good setting. +// * `ratio`: compression ratio (1 = no compression, >1 means compression) +// Ratios: 4 is moderate compression, 8 is strong compression, +// 12 is mild limiting, and 20 is pretty hard limiting at the threshold. +// * `thresh`: dB level threshold above which compression kicks in (0 dB = max level) +// * `att`: attack time = time constant (sec) when level & compression are going up +// * `rel`: release time = time constant (sec) coming out of compression +// +// #### References +// +// * +// * +// * Albert Graef's "faust2pd"/examples/synth/compressor_.dsp +// * More features: +//------------------------------------------------------------ +declare compressor_lad_mono author "Julius O. Smith III"; +declare compressor_lad_mono copyright + "Copyright (C) 2014-2020 by Julius O. Smith III "; +declare compressor_lad_mono license "MIT-style STK-4.3 license"; +compressor_lad_mono(lad,ratio,thresh,att,rel,x) + = x@max(0,floor(0.5+ma.SR*lad)) * compression_gain_mono(ratio,thresh,att,rel,x); + +//--------------------`(co.)compressor_mono`------------------- +// Mono dynamic range compressors. +// `compressor_mono` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : compressor_mono(ratio,thresh,att,rel) : _ +// ``` +// +// Where: +// +// * `ratio`: compression ratio (1 = no compression, >1 means compression) +// Ratios: 4 is moderate compression, 8 is strong compression, +// 12 is mild limiting, and 20 is pretty hard limiting at the threshold. +// * `thresh`: dB level threshold above which compression kicks in (0 dB = max level) +// * `att`: attack time = time constant (sec) when level & compression are going up +// * `rel`: release time = time constant (sec) coming out of compression +// +// #### References +// +// * +// * +// * Albert Graef's "faust2pd"/examples/synth/compressor_.dsp +// * More features: +//------------------------------------------------------------ +declare compressor_mono author "Julius O. Smith III"; +declare compressor_mono copyright + "Copyright (C) 2014-2020 by Julius O. Smith III "; +declare compressor_mono license "MIT-style STK-4.3 license"; +compressor_mono = compressor_lad_mono(0); + +//--------------------`(co.)compressor_stereo`------------------- +// Stereo dynamic range compressors. +// +// #### Usage +// +// ``` +// _,_ : compressor_stereo(ratio,thresh,att,rel) : _,_ +// ``` +// +// Where: +// +// * `ratio`: compression ratio (1 = no compression, >1 means compression) +// * `thresh`: dB level threshold above which compression kicks in (0 dB = max level) +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// +// #### References +// +// * +// * +// * Albert Graef's "faust2pd"/examples/synth/compressor_.dsp +// * More features: +//------------------------------------------------------------ +declare compressor_stereo author "Julius O. Smith III"; +declare compressor_stereo copyright + "Copyright (C) 2014-2020 by Julius O. Smith III "; +declare compressor_stereo license "MIT-style STK-4.3 license"; +compressor_stereo(ratio,thresh,att,rel,x,y) = cgm*x, cgm*y with { + cgm = compression_gain_mono(ratio,thresh,att,rel,abs(x)+abs(y)); +}; + +//--------------------`(co.)compression_gain_mono`------------------- +// Compression-gain calculation for dynamic range compressors. +// +// #### Usage +// +// ``` +// _ : compression_gain_mono(ratio,thresh,att,rel) : _ +// ``` +// +// Where: +// +// * `ratio`: compression ratio (1 = no compression, >1 means compression) +// * `thresh`: dB level threshold above which compression kicks in (0 dB = max level) +// * `att`: attack time = time constant (sec) when level & compression going up +// * `rel`: release time = time constant (sec) coming out of compression +// +// #### References +// +// * +// * +// * Albert Graef's "faust2pd"/examples/synth/compressor_.dsp +// * More features: +//------------------------------------------------------------ +declare compression_gain_mono author "Julius O. Smith III"; +declare compression_gain_mono copyright + "Copyright (C) 2014-2020 by Julius O. Smith III "; +declare compression_gain_mono license "MIT-style STK-4.3 license"; +compression_gain_mono(ratio,thresh,att,rel) = + an.amp_follower_ar(att,rel) : ba.linear2db : outminusindb(ratio,thresh) : + kneesmooth(att) : ba.db2linear +with { + // kneesmooth(att) installs a "knee" in the dynamic-range compression, + // where knee smoothness is set equal to half that of the compression-attack. + // A general 'knee' parameter could be used instead of tying it to att/2: + kneesmooth(att) = si.smooth(ba.tau2pole(att/2.0)); + // compression gain in dB: + outminusindb(ratio,thresh,level) = max(level-thresh,0.0) * (1.0/max(ma.EPSILON,float(ratio))-1.0); + // Note: "float(ratio)" REQUIRED when ratio is an integer > 1! +}; + +//----------------`(co.)limiter_1176_R4_mono`---------------------- +// A limiter guards against hard-clipping. It can be +// implemented as a compressor having a high threshold (near the +// clipping level), fast attack, and high ratio. Since +// the compression ratio is so high, some knee smoothing is +// desirable (for softer limiting). This example is intended +// to get you started using compressors as limiters, so all +// parameters are hardwired here to nominal values. +// +// Ratio: 4 (moderate compression) +// See `compressor_mono` comments for a guide to other choices. +// Mike Shipley likes this (lowest) setting on the 1176. +// (Grammy award-winning mixer for Queen, Tom Petty, etc.). +// +// Thresh: -6 dB, meaning 4:1 compression begins at amplitude 1/2. +// +// Att: 800 MICROseconds (Note: scaled by ratio in the 1176) +// The 1176 range is said to be 20-800 microseconds. +// Faster attack gives "more bite" (e.g. on vocals), +// and makes hard-clipping less likely on fast overloads. +// +// Rel: 0.5 s (Note: scaled by ratio in the 1176) +// The 1176 range is said to be 50-1100 ms. +// +// The 1176 also has a "bright, clear eq effect" (use filters.lib if desired). +// `limiter_1176_R4_mono` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : limiter_1176_R4_mono : _ +// ``` +// +// #### Reference: +// +// +//------------------------------------------------------------ +declare limiter_1176_R4_mono author "Julius O. Smith III"; +declare limiter_1176_R4_mono copyright + "Copyright (C) 2014-2020 by Julius O. Smith III "; +declare limiter_1176_R4_mono license "MIT-style STK-4.3 license"; +limiter_1176_R4_mono = compressor_mono(4,-6,0.0008,0.5); + +//-------------------`(co.)limiter_1176_R4_stereo`--------------------- +// A limiter guards against hard-clipping. It can be +// implemented as a compressor having a high threshold (near the +// clipping level), fast attack and release, and high ratio. Since +// the ratio is so high, some knee smoothing is +// desirable ("soft limiting"). This example is intended +// to get you started using compressor_* as a limiter, so all +// parameters are hardwired to nominal values here. +// +// Ratios: 4 (moderate compression), 8 (severe compression), +// 12 (mild limiting), or 20 to 1 (hard limiting). +// +// Att: 20-800 MICROseconds (Note: scaled by ratio in the 1176). +// +// Rel: 50-1100 ms (Note: scaled by ratio in the 1176). +// +// Mike Shipley likes 4:1 (Grammy-winning mixer for Queen, Tom Petty, etc.) +// Faster attack gives "more bite" (e.g. on vocals). +// He hears a bright, clear eq effect as well (not implemented here). +// +// #### Usage +// +// ``` +// _,_ : limiter_1176_R4_stereo : _,_ +// ``` +// +// #### Reference: +// +// +//------------------------------------------------------------ +declare limiter_1176_R4_stereo author "Julius O. Smith III"; +declare limiter_1176_R4_stereo copyright + "Copyright (C) 2014-2020 by Julius O. Smith III "; +declare limiter_1176_R4_stereo license "MIT-style STK-4.3 license"; +limiter_1176_R4_stereo = compressor_stereo(4,-6,0.0008,0.5); + + +//==================================Expanders============================================= +//======================================================================================== + +//--------------------`(co.)peak_expansion_gain_N_chan_db`------------------- +// N channels dynamic range expander gain computer. +// `peak_expansion_gain_N_chan_db` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : peak_expansion_gain_N_chan_db(strength,thresh,range,att,hold,rel,knee,prePost,link,maxHold,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the expansion (0 = no expansion, 100 means gating, <1 means upward compression) +// * `thresh`: dB level threshold below which expansion kicks in +// * `range`: maximum amount of expansion in dB +// * `att`: attack time = time constant (sec) coming out of expansion +// * `hold` : hold time (sec) +// * `rel`: release time = time constant (sec) going into expansion +// * `knee`: a gradual increase in gain reduction around the threshold: +// above thresh+(knee/2) there is no gain reduction, +// below thresh-(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-range detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `maxHold`: the maximum hold time in samples, known at compile time +// * `N`: the number of channels of the gain computer, known at compile time +// +//------------------------------------------------------------ + +declare peak_expansion_gain_N_chan_db author "Bart Brouns"; +declare peak_expansion_gain_N_chan_db license "GPLv3"; + +// generalise expansion gains for N channels. +// first we define a mono version: +peak_expansion_gain_N_chan_db(strength,thresh,range,att,hold,rel,knee,prePost,link,maxHold,1) = + peak_expansion_gain_mono_db(maxHold,strength,thresh,range,att,hold,rel,knee,prePost); + +// The actual N-channels version: +// Calculate the maximum gain reduction of N channels, +// and then crossfade between that and each channel's own gain reduction, +// to link/unlink channels +peak_expansion_gain_N_chan_db(strength,thresh,range,att,hold,rel,knee,prePost,link,maxHold,N) = + par(i, N, peak_expansion_gain_mono_db(maxHold,strength,thresh,range,att,hold,rel,knee,prePost)) + + <: (si.bus(N),(ba.parallelMax(N) <: si.bus(N))) : ro.interleave(N,2) : par(i,N,(it.interpolate_linear(link))); + + +peak_expansion_gain_mono_db(maxHold,strength,thresh,range,attack,hold,release,knee,prePost) = + level(hold,maxHold):ba.bypass1(prePost,si.lag_ud(attack,release)) :ba.linear2db : gain_computer(strength,thresh,range,knee) : ba.bypass1((prePost !=1),si.lag_ud(att,rel)) +with { + gain_computer(strength,thresh,range,knee,level) = + (select3((level>(thresh-(knee/2)))+(level>(thresh+(knee/2))) + , (level-thresh) + , ((level-thresh-(knee/2)):pow(2) /(min(ma.EPSILON,knee*-2))) + , 0 + ) *abs(strength):max(range) * (-1+(2*(strength>0))) + ); + att = select2((strength>0),release,attack); + rel = select2((strength>0),attack,release); + level(hold,maxHold,x) = x : abs : ba.slidingMax(hold*ma.SR,maxHold); +}; + + +//--------------------`(co.)expander_N_chan`------------------- +// Feed forward N channels dynamic range expander. +// `expander_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : expander_N_chan(strength,thresh,range,att,hold,rel,knee,prePost,link,meter,maxHold,N) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the expansion (0 = no expansion, 100 means gating, <1 means upward compression) +// * `thresh`: dB level threshold below which expansion kicks in +// * `range`: maximum amount of expansion in dB +// * `att`: attack time = time constant (sec) coming out of expansion +// * `hold` : hold time +// * `rel`: release time = time constant (sec) going into expansion +// * `knee`: a gradual increase in gain reduction around the threshold: +// above thresh+(knee/2) there is no gain reduction, +// below thresh-(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-range detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `meter`: a gain reduction meter. It can be implemented like so: +// `meter = _<:(_, (ba.linear2db:max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// * `maxHold`: the maximum hold time in samples, known at compile time +// * `N`: the number of channels of the expander, known at compile time +// +//------------------------------------------------------------ + +declare expander_N_chan author "Bart Brouns"; +declare expander_N_chan license "GPLv3"; + +// Feed forward expander +expander_N_chan(strength,thresh,range,att,hold,rel,knee,prePost,link,meter,maxHold,N) = + expanderSC_N_chan(strength,thresh,range,att,hold,rel,knee,prePost,link,meter,maxHold,N,_,0,0); + +//--------------------`(co.)expanderSC_N_chan`------------------- +// Feed forward N channels dynamic range expander with sidechain. +// `expanderSC_N_chan` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : expanderSC_N_chan(strength,thresh,range,att,hold,rel,knee,prePost,link,meter,maxHold,N,SCfunction,SCswitch,SCsignal) : si.bus(N) +// ``` +// +// Where: +// +// * `strength`: strength of the expansion (0 = no expansion, 100 means gating, <1 means upward compression) +// * `thresh`: dB level threshold below which expansion kicks in +// * `range`: maximum amount of expansion in dB +// * `att`: attack time = time constant (sec) coming out of expansion +// * `hold` : hold time +// * `rel`: release time = time constant (sec) going into expansion +// * `knee`: a gradual increase in gain reduction around the threshold: +// above thresh+(knee/2) there is no gain reduction, +// below thresh-(knee/2) there is the same gain reduction as without a knee, +// and in between there is a gradual increase in gain reduction. +// * `prePost`: places the level detector either at the input or after the gain computer; +// this turns it from a linear return-to-zero detector into a log domain return-to-range detector +// * `link`: the amount of linkage between the channels. 0 = each channel is independent, 1 = all channels have the same amount of gain reduction +// * `meter`: a gain reduction meter. It can be implemented like so: +// `meter = _<:(_, (ba.linear2db:max(maxGR):meter_group((hbargraph("[1][unit:dB][tooltip: gain reduction in dB]", maxGR, 0))))):attach;` +// * `maxHold`: the maximum hold time in samples, known at compile time +// * `N`: the number of channels of the expander, known at compile time +// * `SCfunction` : a function that get's placed before the level-detector, needs to have a single input and output +// * `SCswitch` : use either the regular audio input or the SCsignal as the input for the level detector +// * `SCsignal` : an audio signal, to be used as the input for the level detector when SCswitch is 1 +// +//------------------------------------------------------------ + +declare expanderSC_N_chan author "Bart Brouns"; +declare expanderSC_N_chan license "GPLv3"; + +// Feed forward expander with sidechain +expanderSC_N_chan(strength,thresh,range,att,hold,rel,knee,prePost,link,meter,maxHold,N,SCfunction,SCswitch,SCsignal) = + si.bus(N) <: + ((par(i, N, select2(SCswitch,_,SCsignal):SCfunction) + : peak_expansion_gain_N_chan_db(strength,thresh,range,att,hold,rel,knee,prePost,link,maxHold,N)) + ,si.bus(N)) + : ro.interleave(N,2) + : par(i,N,(meter:ba.db2linear)*_); + + +//=============================Lookahead Limiters======================================== +//======================================================================================== + +//-----------------------`(co.)limiter_lad_N`--------------------------------- +// N-channels lookahead limiter inspired by IOhannes Zmölnig's post, which is +// in turn based on the thesis by Peter Falkner "Entwicklung eines digitalen +// Stereo-Limiters mit Hilfe des Signalprozessors DSP56001". +// This version of the limiter uses a peak-holder with smoothed +// attack and release based on tau time constant filters. +// +// It is also possible to use a time constant that is 2PI*tau by dividing +// the attack and release times by 2PI. This time constant allows for +// the amplitude profile to reach 1 - e^(-2PI) of the final +// peak after the attack time. The input path can be delayed by the same +// amount as the attack time to synchronise input and amplitude profile, +// realising a system that is particularly effective as a colourless +// (ideally) brickwall limiter. +// +// Note that the effectiveness of the ceiling settings are dependent on +// the other parameters, especially the time constant used for the +// smoothing filters and the lookahead delay. +// +// Similarly, the colourless characteristics are also dependent on attack, +// hold, and release times. Since fluctuations above ~15 Hz are +// perceived as timbral effects, [Vassilakis and Kendall 2010] it is +// reasonable to set the attack time to 1/15 seconds for a smooth amplitude +// modulation. On the other hand, the hold time can be set to the +// peak-to-peak period of the expected lowest frequency in the signal, +// which allows for minimal distortion of the low frequencies. The +// release time can then provide a perceptually linear and gradual gain +// increase determined by the user for any specific application. +// +// The scaling factor for all the channels is determined by the loudest peak +// between them all, so that amplitude ratios between the signals are kept. +// +// #### Usage +// +// ``` +// si.bus(N) : limiter_lad_N(N, LD, ceiling, attack, hold, release) : si.bus(N) +// ``` +// +// Where: +// +// * `N` is the number of channels, known at compile-time +// * `LD` is the lookahead delay in seconds, known at compile-time +// * `ceiling` is the linear amplitude output limit +// * `attack` is the attack time in seconds +// * `hold` is the hold time in seconds +// * `release` is the release time in seconds +// +// Example for a stereo limiter: `limiter_lad_N(2, .01, 1, .01, .1, 1);` +// +// #### Reference: +// +// +//------------------------------------------------------------------------------ +declare limiter_lad_N author "Dario Sanfilippo"; +declare limiter_lad_N copyright "Copyright (C) 2020 Dario Sanfilippo + "; +declare limiter_lad_N license "GPLv3 license"; +limiter_lad_N(N, LD, ceiling, attack, hold, release) = + si.bus(N) <: par(i, N, @(LD * ma.SR)), + (scaling <: si.bus(N)) : ro.interleave(N, 2) : par(i, N, *) + with { + scaling = ceiling / max(amp_profile, ma.EPSILON) : min(1); + amp_profile = par(i, N, abs) : maxN(N) : ba.peakholder(hold * ma.SR) : + att_smooth(attack) : rel_smooth(release); + att_smooth(time, in) = si.smooth(ba.tau2pole(time), in); + rel_smooth(time, in) = an.peak_envelope(time, in); + maxN(1) = _; + maxN(2) = max; + maxN(N) = max(maxN(N - 1)); + }; + +//-------------`(co.)limiter_lad_mono`---------------------------------------- +// +// Specialised case of `limiter_lad_N` mono limiter. +// +// #### Usage +// +// ``` +// _ : limiter_lad_mono(LD, ceiling, attack, hold, release) : _ +// ``` +// +// Where: +// +// * `LD` is the lookahead delay in seconds, known at compile-time +// * `ceiling` is the linear amplitude output limit +// * `attack` is the attack time in seconds +// * `hold` is the hold time in seconds +// * `release` is the release time in seconds +// +// #### Reference: +// +// +//------------------------------------------------------------------------------ +declare limiter_lad_mono author "Dario Sanfilippo"; +declare limiter_lad_mono copyright "Copyright (C) 2020 Dario Sanfilippo + "; +declare limiter_lad_mono license "GPLv3 license"; +limiter_lad_mono(LD) = limiter_lad_N(1, LD); + +//-------------`(co.)limiter_lad_stereo`-------------------------------------- +// +// Specialised case of `limiter_lad_N` stereo limiter. +// +// #### Usage +// +// ``` +// _,_ : limiter_lad_stereo(LD, ceiling, attack, hold, release) : _,_ +// ``` +// +// Where: +// +// * `LD` is the lookahead delay in seconds, known at compile-time +// * `ceiling` is the linear amplitude output limit +// * `attack` is the attack time in seconds +// * `hold` is the hold time in seconds +// * `release` is the release time in seconds +// +// #### Reference: +// +// +//------------------------------------------------------------------------------ +declare limiter_lad_stereo author "Dario Sanfilippo"; +declare limiter_lad_stereo copyright "Copyright (C) 2020 Dario Sanfilippo + "; +declare limiter_lad_stereo license "GPLv3 license"; +limiter_lad_stereo(LD) = limiter_lad_N(2, LD); + +//-------------`(co.)limiter_lad_quad`---------------------------------------- +// +// Specialised case of `limiter_lad_N` quadraphonic limiter. +// +// #### Usage +// +// ``` +// si.bus(4) : limiter_lad_quad(LD, ceiling, attack, hold, release) : si.bus(4) +// ``` +// +// Where: +// +// * `LD` is the lookahead delay in seconds, known at compile-time +// * `ceiling` is the linear amplitude output limit +// * `attack` is the attack time in seconds +// * `hold` is the hold time in seconds +// * `release` is the release time in seconds +// +// #### Reference: +// +// +//------------------------------------------------------------------------------ +declare limiter_lad_quad author "Dario Sanfilippo"; +declare limiter_lad_quad copyright "Copyright (C) 2020 Dario Sanfilippo + "; +declare limiter_lad_quad license "GPLv3 license"; +limiter_lad_quad(LD) = limiter_lad_N(4, LD); + +//-------------`(co.)limiter_lad_bw`----------------------------------------- +// +// Specialised case of `limiter_lad_N` and ready-to-use unit-amplitude mono +// limiting function. This implementation, in particular, uses `2PI*tau` +// time constant filters for attack and release smoothing with +// synchronised input and gain signals. +// +// This function's best application is to be used as a brickwall limiter with +// the least colouring artefacts while keeping a not-so-slow release curve. +// Tests have shown that, given a pop song with 60 dB of amplification +// and a 0-dB-ceiling, the loudest peak recorded was ~0.38 dB. +// +// #### Usage +// +// ``` +// _ : limiter_lad_bw : _ +// ``` +// +// #### Reference: +// +// +//------------------------------------------------------------------------------ +declare limiter_lad_bw author "Dario Sanfilippo"; +declare limiter_lad_bw copyright "Copyright (C) 2020 Dario Sanfilippo + "; +declare limiter_lad_bw license "GPLv3 license"; +limiter_lad_bw = limiter_lad_mono(.01, 1, 0.01/twopi, .1, 1/twopi) +with { + twopi = 2 * ma.PI; +}; diff --git a/dist/examples/LIBRARIES/delays.lib b/dist/examples/LIBRARIES/delays.lib new file mode 100644 index 00000000..49a1a235 --- /dev/null +++ b/dist/examples/LIBRARIES/delays.lib @@ -0,0 +1,401 @@ + +//#################################### delays.lib ######################################### +// This library contains a collection of delay functions. Its official prefix is `de`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2003-2016 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +ba = library("basics.lib"); +si = library("signals.lib"); +fi = library("filters.lib"); + +declare name "Faust Delay Library"; +declare version "0.1"; + +//==================================Basic Delay Functions================================= +//======================================================================================== + +//-------`(de.)delay`---------- +// Simple `d` samples delay where `n` is the maximum delay length as a number of +// samples. Unlike the `@` delay operator, here the delay signal `d` is explicitly +// bounded to the interval [0..n]. The consequence is that delay will compile even +// if the interval of d can't be computed by the compiler. +// `delay` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : delay(n,d) : _ +// ``` +// +// Where: +// +// * `n`: the max delay length in samples +// * `d`: the delay length in samples (integer) +//----------------------------- +// TODO: add MBH np2 +delay(n,d,x) = x @ min(n, max(0,d)); + + +//-------`(de.)fdelay`---------- +// Simple `d` samples fractional delay based on 2 interpolated delay lines where `n` is +// the maximum delay length as a number of samples. + +// `fdelay` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : fdelay(n,d) : _ +// ``` +// +// Where: +// +// * `n`: the max delay length in samples +// * `d`: the delay length in samples (float) +//----------------------------- +fdelay(n,d,x) = delay(n+1,int(d),x)*(1 - ma.frac(d)) + delay(n+1,int(d)+1,x)*ma.frac(d); + + +//--------------------------`(de.)sdelay`---------------------------- +// s(mooth)delay: a mono delay that doesn't click and doesn't +// transpose when the delay time is changed. +// +// #### Usage +// +// ``` +// _ : sdelay(n,it,d) : _ +// ``` +// +// Where : +// +// * `n`: the max delay length in samples +// * `it`: interpolation time (in samples), for example 1024 +// * `d`: the delay length in samples (float) +//-------------------------------------------------------------------------- +sdelay(n, it, d) = ctrl(it,d),_ : ddi(n) +with { + // ddi(n,i,d0,d1) + // DDI (Double Delay with Interpolation) : the input signal is sent to two + // delay lines. The outputs of these delay lines are crossfaded with + // an interpolation stage. By acting on this interpolation value one + // can move smoothly from one delay to another. When is 0 we can + // freely change the delay time of line 1, when it is 1 we can freely change + // the delay time of line 0. + // + // = maximal delay in samples + // = interpolation value between 0 and 1 used to crossfade the outputs of the + // two delay lines (0.0: first delay line, 1.0: second delay line) + // = delay time of delay line 0 in samples between 0 and -1 + // = delay time of delay line 1 in samples between 0 and -1 + // < > = the input signal we want to delay + ddi(n, i, d0, d1) = _ <: delay(n,d0), delay(n,d1) : si.interpolate(i); + + // ctrl(it,d) + // Control logic for a Double Delay with Interpolation according to two + // + // USAGE : ctrl(it,d) + // where : + // an interpolation time (in samples, for example 256) + // a delay time (in samples) + // + // ctrl produces 3 outputs : an interpolation value and two delay + // times and . These signals are used to control a ddi (Double Delay with Interpolation). + // The principle is to detect changes in the input delay time d, then to + // change the delay time of the delay line currently unused and then by a + // smooth crossfade to remove the first delay line and activate the second one. + // + // The control logic has an internal state controlled by 4 elements + // : the interpolation variation (0, 1/it, -1/it) + // : the interpolation value (between 0 and 1) + // : the delay time of line 0 + // : the delay time of line 1 + // + // Please note that the last stage (!,_,_,_) cut because it is only + // used internally. + ctrl(it, d) = \(v,ip,d0,d1).((nv, nip, nd0, nd1) + with { + // interpolation variation + nv = ba.if (v!=0.0, // if variation we are interpolating + ba.if ((ip>0.0) & (ip<1.0), v, 0), // should we continue or not ? + ba.if ((ip==0.0) & (d!=d0), 1.0/it, // if true xfade from dl0 to dl1 + ba.if ((ip==1.0) & (d!=d1), -1.0/it, // if true xfade from dl1 to dl0 + 0))); // nothing to change + // interpolation value + nip = ip+nv : min(1.0) : max(0.0); + + // update delay time of line 0 if needed + nd0 = ba.if ((ip >= 1.0) & (d1!=d), d, d0); + + // update delay time of line 0 if needed + nd1 = ba.if ((ip <= 0.0) & (d0!=d), d, d1); + }) ~ (_,_,_,_) : (!,_,_,_); +}; + + +// ----------`(de.)prime_power_delays`----------- +// Prime Power Delay Line Lengths. +// +// #### Usage +// +// ``` +// si.bus(N) : prime_power_delays(N,pathmin,pathmax) : si.bus(N); +// ``` +// +// Where: +// +// * `N`: positive integer up to 16 (for higher powers of 2, extend 'primes' array below) +// * `pathmin`: minimum acoustic ray length in the reverberator (in meters) +// * `pathmax`: maximum acoustic ray length (meters) - think "room size" +// +// #### Reference +// +// +//------------------------------------------------------------ +declare prime_power_delays author "Julius O. Smith III"; + +prime_power_delays(N,pathmin,pathmax) = par(i,N,delayvals(i)) with { + Np = 16; + primes = 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53; + prime(n) = primes : ba.selector(n,Np); // math.lib + + // Prime Power Bounds [matlab: floor(log(maxdel)./log(primes(53)))] + maxdel = 8192; // more than 63 meters at 44100 samples/sec & 343 m/s + ppbs = 13,8,5,4, 3,3,3,3, 2,2,2,2, 2,2,2,2; // 8192 is enough for all + ppb(i) = ba.take(i+1,ppbs); + + // Approximate desired delay-line lengths using powers of distinct primes: + c = 343; // soundspeed in m/s at 20 degrees C for dry air + dmin = ma.SR*pathmin/c; + dmax = ma.SR*pathmax/c; + dl(i) = dmin * (dmax/dmin)^(i/float(N-1)); // desired delay in samples + ppwr(i) = floor(0.5+log(dl(i))/log(prime(i))); // best prime power + delayvals(i) = prime(i)^ppwr(i); // each delay a power of a distinct prime +}; + + +//===============================Lagrange Interpolation=================================== +//======================================================================================== + +//----------------------`(de.)fdelaylti` and `(de.)fdelayltv`------------------------- +// Fractional delay line using Lagrange interpolation. +// +// #### Usage +// +// ``` +// _ : fdelaylt[i|v](N, n, d) : _ +// ``` +// +// Where: +// +// * `N=1,2,3,...` is the order of the Lagrange interpolation polynomial (constant numerical expression) +// * `n`: the max delay length in samples +// * `d`: the delay length in samples +// +// `fdelaylti` is most efficient, but designed for constant/slowly-varying delay. +// `fdelayltv` is more expensive and more robust when the delay varies rapidly. +// +// Note: the requested delay should not be less than `(N-1)/2`. +// +// #### References +// +// * +// - [fixed-delay case](https://ccrma.stanford.edu/~jos/Interpolation/Efficient_Time_Invariant_Lagrange_Interpolation.html) +// - [variable-delay case](https://ccrma.stanford.edu/~jos/Interpolation/Time_Varying_Lagrange_Interpolation.html) +// * Timo I. Laakso et al., "Splitting the Unit Delay - Tools for Fractional +// Delay Filter Design", IEEE Signal Processing Magazine, +// vol. 13, no. 1, pp. 30-60, Jan 1996. +// * Philippe Depalle and Stephan Tassart, "Fractional Delay Lines using +// Lagrange Interpolators", ICMC Proceedings, pp. 341-343, 1996. +//------------------------------------------------------------ +declare fdelaylti author "Julius O. Smith III"; + +fdelaylti(N,n,d,x) = delay(n,id,x) <: seq(i,N,section(i)) : !,_ +with { + o = (N-1.00001)/2; // offset to ~center FIR interpolator + dmo = d - o; // assumed nonnegative [d > (N-1)/2] + id = int(dmo); + fd = o + ma.frac(dmo); + section(i,x,y) = (x-x') * c(i) <: _,+(y); + c(i) = (i - fd)/(i+1); +}; + +declare fdelayltv author "Julius O. Smith III"; + +fdelayltv(N,n,d,x) = sum(i, N+1, delay(n,id+i,x) * h(N,fd,i)) +with { + o = (N-1.00001)/2; // ~center FIR interpolator + dmo = d - o; // assumed nonnegative [d > (N-1)/2] + id = int(dmo); + fd = o + ma.frac(dmo); + h(N,d,n) = facs1(N,d,n) * facs2(N,d,n); + facs1(N,d,n) = select2(n,1,prod(k,max(1,n),select2(k +//======================================================================================== + +//----------------`(de.)fdelay[N]a`------------- +// Delay lines interpolated using Thiran allpass interpolation. +// +// #### Usage +// +// ``` +// _ : fdelay[N]a(n, d) : _ +// ``` +// +// (exactly like `fdelay`) +// +// Where: +// +// * `N=1,2,3, or 4` is the order of the Thiran interpolation filter (constant numerical expression), +// and the delay argument is at least `N-1/2`. First-order: `d` at least 0.5, second-order: `d` at least 1.5, +// third-order: `d` at least 2.5, fourth-order: `d` at least 3.5. +// * `n`: the max delay length in samples +// * `d`: the delay length in samples +// +// #### Note +// +// The interpolated delay should not be less than `N-1/2`. +// (The allpass delay ranges from `N-1/2` to `N+1/2`). +// This constraint can be alleviated by altering the code, +// but be aware that allpass filters approach zero delay +// by means of pole-zero cancellations. +// +// Delay arguments too small will produce an UNSTABLE allpass! +// +// Because allpass interpolation is recursive, it is not as robust +// as Lagrange interpolation under time-varying conditions +// (you may hear clicks when changing the delay rapidly). +// +//------------------------------------------------------------ +declare fdelay1a author "Julius O. Smith III"; + +fdelay1a(n,d,x) = delay(n,id,x) : fi.tf1(eta,1,eta) +with { + o = 0.49999; // offset to make life easy for allpass + dmo = d - o; // assumed nonnegative + id = int(dmo); + fd = o + ma.frac(dmo); + eta = (1-fd)/(1+fd); // allpass coefficient +}; + +declare fdelay2a author "Julius O. Smith III"; +fdelay2a(n,d,x) = delay(n,id,x) : fi.tf2(a2,a1,1,a1,a2) +with { + o = 1.49999; + dmo = d - o; // delay range is [order-1/2, order+1/2] + id = int(dmo); + fd = o + ma.frac(dmo); + a1o2 = (2-fd)/(1+fd); // share some terms (the compiler does this anyway) + a1 = 2*a1o2; + a2 = a1o2*(1-fd)/(2+fd); +}; + +declare fdelay3a author "Julius O. Smith III"; +fdelay3a(n,d,x) = delay(n,id,x) : fi.iir((a3,a2,a1,1),(a1,a2,a3)) +with { + o = 2.49999; + dmo = d - o; + id = int(dmo); + fd = o + ma.frac(dmo); + a1o3 = (3-fd)/(1+fd); + a2o3 = a1o3*(2-fd)/(2+fd); + a1 = 3*a1o3; + a2 = 3*a2o3; + a3 = a2o3*(1-fd)/(3+fd); +}; + +declare fdelay4a author "Julius O. Smith III"; +fdelay4a(n,d,x) = delay(n,id,x) : fi.iir((a4,a3,a2,a1,1),(a1,a2,a3,a4)) +with { + o = 3.49999; + dmo = d - o; + id = int(dmo); + fd = o + ma.frac(dmo); + a1o4 = (4-fd)/(1+fd); + a2o6 = a1o4*(3-fd)/(2+fd); + a3o4 = a2o6*(2-fd)/(3+fd); + a1 = 4*a1o4; + a2 = 6*a2o6; + a3 = 4*a3o4; + a4 = a3o4*(1-fd)/(4+fd); +}; + +//////////////////////////////////Deprecated Functions//////////////////////////////////// +// This section implements functions that used to be in music.lib but that are now +// considered as "deprecated". +////////////////////////////////////////////////////////////////////////////////////////// + +delay1s(d) = delay(65536,d); +delay2s(d) = delay(131072,d); +delay5s(d) = delay(262144,d); +delay10s(d) = delay(524288,d); +delay21s(d) = delay(1048576,d); +delay43s(d) = delay(2097152,d); + +fdelay1s(d) = fdelay(65536,d); +fdelay2s(d) = fdelay(131072,d); +fdelay5s(d) = fdelay(262144,d); +fdelay10s(d) = fdelay(524288,d); +fdelay21s(d) = fdelay(1048576,d); +fdelay43s(d) = fdelay(2097152,d); diff --git a/dist/examples/LIBRARIES/demos.lib b/dist/examples/LIBRARIES/demos.lib new file mode 100644 index 00000000..a3b481db --- /dev/null +++ b/dist/examples/LIBRARIES/demos.lib @@ -0,0 +1,1556 @@ +//#################################### demos.lib ########################################## +// This library contains a set of demo functions based on examples located in the +// `/examples` folder. Its official prefix is `dm`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +ba = library("basics.lib"); +de = library("delays.lib"); +si = library("signals.lib"); +an = library("analyzers.lib"); +fi = library("filters.lib"); +os = library("oscillators.lib"); +no = library("noises.lib"); +ef = library("misceffects.lib"); +co = library("compressors.lib"); +ve = library("vaeffects.lib"); +pf = library("phaflangers.lib"); +re = library("reverbs.lib"); +en = library("envelopes.lib"); + +declare name "Faust Demos Library"; +declare version "0.1"; + +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2019 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +MarkDown comments in this section are Copyright 2016-2019 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees!) + +************************************************************************/ + +//====================================Analyzers=========================================== +//======================================================================================== + +//----------------------`(dm.)mth_octave_spectral_level_demo`---------------------- +// Demonstrate mth_octave_spectral_level in a standalone GUI. +// +// #### Usage +// ``` +// _ : mth_octave_spectral_level_demo(BandsPerOctave) : _ +// _ : spectral_level_demo : _ // 2/3 octave +// ``` +//------------------------------------------------------------ +declare mth_octave_spectral_level_demo author "Julius O. Smith III and Yann Orlarey"; +declare mth_octave_spectral_level_demo licence "MIT"; + +mth_octave_spectral_level_demo(BPO) = an.mth_octave_spectral_level_default(M,ftop,N,tau,dB_offset) +with{ + M = BPO; + ftop = 16000; + Noct = 10; // number of octaves down from ftop + // Lowest band-edge is at ftop*2^(-Noct+2) = 62.5 Hz when ftop=16 kHz: + N = int(Noct*M); // without 'int()', segmentation fault observed for M=1.67 + ctl_group(x) = hgroup("[1] SPECTRUM ANALYZER CONTROLS", x); + tau = ctl_group(hslider("[0] Level Averaging Time [unit:ms] [scale:log] + [tooltip: band-level averaging time in milliseconds]", + 100,1,10000,1)) * 0.001; + dB_offset = ctl_group(hslider("[1] Level dB Offset [unit:dB] + [tooltip: Level offset in decibels]", + 50,-50,100,1)); +}; + +spectral_level_demo = mth_octave_spectral_level_demo(1.5); // 2/3 octave + + +//======================================Filters=========================================== +//======================================================================================== + +//--------------------------`(dm.)parametric_eq_demo`------------------------------ +// A parametric equalizer application. +// +// #### Usage: +// +// ``` +// _ : parametric_eq_demo : _ +// ``` +//------------------------------------------------------------ +declare parametric_eq_demo author "Julius O. Smith III"; +declare parametric_eq_demo licence "MIT"; + +parametric_eq_demo = fi.low_shelf(LL,FL) : fi.peak_eq(LP,FP,BP) : fi.high_shelf(LH,FH) +with{ + eq_group(x) = hgroup("[0] PARAMETRIC EQ SECTIONS [tooltip: See Faust's filters.lib + for info and pointers]",x); + ls_group(x) = eq_group(vgroup("[1] Low Shelf",x)); + + LL = ls_group(hslider("[0] Low Boost|Cut [unit:dB] [style:knob] + [tooltip: Amount of low-frequency boost or cut in decibels]",0,-40,40,0.1)); + FL = ls_group(hslider("[1] Transition Frequency [unit:Hz] [style:knob] [scale:log] + [tooltip: Transition-frequency from boost (cut) to unity gain]",200,1,5000,1)); + + pq_group(x) = eq_group(vgroup("[2] Peaking Equalizer[tooltip: Parametric Equalizer + sections from filters.lib]",x)); + LP = pq_group(hslider("[0] Peak Boost|Cut [unit:dB] [style:knob][tooltip: Amount of + local boost or cut in decibels]",0,-40,40,0.1)); + FP = pq_group(hslider("[1] Peak Frequency [unit:PK] [style:knob] [tooltip: Peak + Frequency in Piano Key (PK) units (A440 = 49PK)]",49,1,100,1)) : si.smooth(0.999) + : ba.pianokey2hz; + Q = pq_group(hslider("[2] Peak Q [style:knob] [scale:log] [tooltip: Quality factor + (Q) of the peak = center-frequency/bandwidth]",40,1,1000,0.1)); + + BP = FP/Q; + + hs_group(x) = eq_group(vgroup("[3] High Shelf [tooltip: A high shelf provides a boost + or cut above some frequency]",x)); + LH = hs_group(hslider("[0] High Boost|Cut [unit:dB] [style:knob] [tooltip: Amount of + high-frequency boost or cut in decibels]",0,-40,40,.1)); + FH = hs_group(hslider("[1] Transition Frequency [unit:Hz] [style:knob] [scale:log] + [tooltip: Transition-frequency from boost (cut) to unity gain]",8000,20,10000,1)); +}; + + +//-------------------`(dm.)spectral_tilt_demo`----------------------- +// A spectral tilt application. +// +// #### Usage +// +// ``` +// _ : spectral_tilt_demo(N) : _ +// ``` +// +// Where: +// +// * `N`: filter order (integer) +// +// All other parameters interactive +//------------------------------------------------------------ +declare spectral_tilt_demo author "Julius O. Smith III"; +declare spectral_tilt_demo licence "MIT"; + +spectral_tilt_demo(N) = fi.spectral_tilt(O,f0,bw,alpha) +with{ + O = N; + alpha = hslider("[1] Slope of Spectral Tilt across Band",-1/2,-1,1,0.001); + f0 = hslider("[2] Band Start Frequency [unit:Hz]",100,20,10000,1); + bw = hslider("[3] Band Width [unit:Hz]",5000,100,10000,1); +}; + + +//---------`(dm.)mth_octave_filterbank_demo` and `(dm.)filterbank_demo`------------- +// Graphic Equalizer: each filter-bank output signal routes through a fader. +// +// #### Usage +// +// ``` +// _ : mth_octave_filterbank_demo(M) : _ +// _ : filterbank_demo : _ +// ``` +// +// Where: +// +// * `M`: number of bands per octave +//-------------------------------------------------------------- +declare mth_octave_filterbank_demo author "Julius O. Smith III"; +declare mth_octave_filterbank_demo licence "MIT"; + +mth_octave_filterbank_demo(O) = bp1(bp,mthoctavefilterbankdemo) +with{ + M = O; + bp1 = ba.bypass1; + mofb_group(x) = vgroup("CONSTANT-Q FILTER BANK (Butterworth dyadic tree) + [tooltip: See Faust's filters.lib for documentation and references]", x); + bypass_group(x) = mofb_group(hgroup("[0]", x)); + slider_group(x) = mofb_group(hgroup("[1]", x)); + + N = 10*M; // total number of bands (highpass band, octave-bands, dc band) + ftop = 10000; + mthoctavefilterbankdemo = chan; + chan = fi.mth_octave_filterbank_default(M,ftop,N) : sum(i,N,(*(ba.db2linear(fader(N-i))))); + fader(i) = slider_group(vslider("Band%2i [unit:dB] [tooltip: Bandpass filter + gain in dB]", -10, -70, 10, 0.1)) : si.smoo; + bp = bypass_group(checkbox("[0] Bypass + [tooltip: When this is checked, the filter-bank has no effect]")); +}; + +filterbank_demo = mth_octave_filterbank_demo(1); // octave-bands = default + + +//======================================Effects=========================================== +//======================================================================================== + +//---------------------------`(dm.)cubicnl_demo`-------------------------- +// Distortion demo application. +// +// #### Usage: +// +// ``` +// _ : cubicnl_demo : _ +// ``` +//------------------------------------------------------------ +declare cubicnl_demo author "Julius O. Smith III"; +declare cubicnl_demo licence "MIT"; + +cubicnl_demo = ba.bypass1(bp, ef.cubicnl_nodc(drive:si.smoo,offset:si.smoo)) +with{ + cnl_group(x) = vgroup("CUBIC NONLINEARITY cubicnl [tooltip: Reference: + https://ccrma.stanford.edu/~jos/pasp/Cubic_Soft_Clipper.html]", x); + bp = cnl_group(checkbox("[0] Bypass [tooltip: When this is checked, the + nonlinearity has no effect]")); + drive = cnl_group(hslider("[1] Drive [tooltip: Amount of distortion]", + 0, 0, 1, 0.01)); + offset = cnl_group(hslider("[2] Offset [tooltip: Brings in even harmonics]", + 0, 0, 1, 0.01)); +}; + + +//----------------------------`(dm.)gate_demo`------------------------- +// Gate demo application. +// +// #### Usage +// +// ``` +// _,_ : gate_demo : _,_ +// ``` +//------------------------------------------------------------ +declare gate_demo author "Julius O. Smith III"; +declare gate_demo licence "MIT"; + +gate_demo = ba.bypass2(gbp,gate_stereo_demo) +with{ + gate_group(x) = vgroup("GATE [tooltip: Reference: + http://en.wikipedia.org/wiki/Noise_gate]", x); + meter_group(x) = gate_group(hgroup("[0]", x)); + knob_group(x) = gate_group(hgroup("[1]", x)); + + gbp = meter_group(checkbox("[0] Bypass [tooltip: When this is checked, + the gate has no effect]")); + + gateview = ef.gate_gain_mono(gatethr,gateatt,gatehold,gaterel) : ba.linear2db : + meter_group(hbargraph("[1] Gate Gain [unit:dB] [tooltip: Current gain of the + gate in dB]", -50,+10)); // [style:led] + + gate_stereo_demo(x,y) = attach(x,gateview(abs(x)+abs(y))),y : + ef.gate_stereo(gatethr,gateatt,gatehold,gaterel); + + gatethr = knob_group(hslider("[1] Threshold [unit:dB] [style:knob] [tooltip: When + the signal level falls below the Threshold (expressed in dB), the signal is + muted]", -30, -120, 0, 0.1)); + + gateatt = knob_group(hslider("[2] Attack [unit:us] [style:knob] [scale:log] + [tooltip: Time constant in MICROseconds (1/e smoothing time) for the gate + gain to go (exponentially) from 0 (muted) to 1 (unmuted)]", + 10, 10, 10000, 1)) : *(0.000001) : max(1.0/float(ma.SR)); + + gatehold = knob_group(hslider("[3] Hold [unit:ms] [style:knob] [scale:log] + [tooltip: Time in ms to keep the gate open (no muting) after the signal + level falls below the Threshold]", 200, 1, 1000, 1)) : *(0.001) : + max(1.0/float(ma.SR)); + + gaterel = knob_group(hslider("[4] Release [unit:ms] [style:knob] [scale:log] + [tooltip: Time constant in ms (1/e smoothing time) for the gain to go + (exponentially) from 1 (unmuted) to 0 (muted)]", + 100, 1, 1000, 1)) : *(0.001) : max(1.0/float(ma.SR)); +}; + + +//----------------------------`(dm.)compressor_demo`------------------------- +// Compressor demo application. +// +// #### Usage +// +// ``` +// _,_ : compressor_demo : _,_ +// ``` +//------------------------------------------------------------ +declare compressor_demo author "Julius O. Smith III"; +declare compressor_demo licence "MIT"; + +compressor_demo = ba.bypass2(cbp,compressor_stereo_demo) +with{ + comp_group(x) = vgroup("COMPRESSOR [tooltip: Reference: + http://en.wikipedia.org/wiki/Dynamic_range_compression]", x); + + meter_group(x) = comp_group(hgroup("[0]", x)); + knob_group(x) = comp_group(hgroup("[1]", x)); + + cbp = meter_group(checkbox("[0] Bypass [tooltip: When this is checked, the compressor + has no effect]")); + gainview = co.compression_gain_mono(ratio,threshold,attack,release) : ba.linear2db : + meter_group(hbargraph("[1] Compressor Gain [unit:dB] [tooltip: Current gain of + the compressor in dB]",-50,+10)); + + displaygain = _,_ <: _,_,(abs,abs:+) : _,_,gainview : _,attach; + + compressor_stereo_demo = + displaygain(co.compressor_stereo(ratio,threshold,attack,release)) : + *(makeupgain), *(makeupgain); + + ctl_group(x) = knob_group(hgroup("[3] Compression Control", x)); + + ratio = ctl_group(hslider("[0] Ratio [style:knob] + [tooltip: A compression Ratio of N means that for each N dB increase in input + signal level above Threshold, the output level goes up 1 dB]", + 5, 1, 20, 0.1)); + + threshold = ctl_group(hslider("[1] Threshold [unit:dB] [style:knob] + [tooltip: When the signal level exceeds the Threshold (in dB), its level + is compressed according to the Ratio]", + -30, -100, 10, 0.1)); + + env_group(x) = knob_group(hgroup("[4] Compression Response", x)); + + attack = env_group(hslider("[1] Attack [unit:ms] [style:knob] [scale:log] + [tooltip: Time constant in ms (1/e smoothing time) for the compression gain + to approach (exponentially) a new lower target level (the compression + `kicking in')]", 50, 1, 1000, 0.1)) : *(0.001) : max(1/ma.SR); + + release = env_group(hslider("[2] Release [unit:ms] [style: knob] [scale:log] + [tooltip: Time constant in ms (1/e smoothing time) for the compression gain + to approach (exponentially) a new higher target level (the compression + 'releasing')]", 500, 1, 1000, 0.1)) : *(0.001) : max(1/ma.SR); + + makeupgain = comp_group(hslider("[5] Makeup Gain [unit:dB] + [tooltip: The compressed-signal output level is increased by this amount + (in dB) to make up for the level lost due to compression]", + 40, -96, 96, 0.1)) : ba.db2linear; +}; + + +//-------------------------`(dm.)moog_vcf_demo`--------------------------- +// Illustrate and compare all three Moog VCF implementations above. +// +// #### Usage +// +// ``` +// _ : moog_vcf_demo : _ +// ``` +//------------------------------------------------------------ +declare moog_vcf_demo author "Julius O. Smith III"; +declare moog_vcf_demo licence "MIT"; + +moog_vcf_demo = ba.bypass1(bp,vcf) +with{ + mvcf_group(x) = hgroup("MOOG VCF (Voltage Controlled Filter) [tooltip: See Faust's + vaeffects.lib for info and references]",x); + cb_group(x) = mvcf_group(hgroup("[0]",x)); + + bp = cb_group(checkbox("[0] Bypass [tooltip: When this is checked, the Moog VCF + has no effect]")); + archsw = cb_group(checkbox("[1] Use Biquads [tooltip: Select moog_vcf_2b (two-biquad) + implementation, instead of the default moog_vcf (analog style) implementation]")); + bqsw = cb_group(checkbox("[2] Normalized Ladders [tooltip: If using biquads, make + them normalized ladders (moog_vcf_2bn)]")); + + freq = mvcf_group(hslider("[1] Corner Frequency [unit:PK] [tooltip: The VCF resonates + at the corner frequency (specified in PianoKey (PK) units, with A440 = 49 PK). + The VCF response is flat below the corner frequency, and rolls off -24 dB per + octave above.]", + 25, 1, 88, 0.01) : ba.pianokey2hz) : si.smoo; + + res = mvcf_group(hslider("[2] Corner Resonance [style:knob] [tooltip: Amount of + resonance near VCF corner frequency (specified between 0 and 1)]", 0.9, 0, 1, 0.01)); + + outgain = mvcf_group(hslider("[3] VCF Output Level [unit:dB] [style:knob] [tooltip: + output level in decibels]", 5, -60, 20, 0.1)) : ba.db2linear : si.smoo; + + vcfbq = _ <: select2(bqsw, ve.moog_vcf_2b(res,freq), ve.moog_vcf_2bn(res,freq)); + vcfarch = _ <: select2(archsw, ve.moog_vcf(res^4,freq), vcfbq); + vcf = vcfarch : *(outgain); +}; + + +//-------------------------`(dm.)wah4_demo`--------------------------- +// Wah pedal application. +// +// #### Usage +// +// ``` +// _ : wah4_demo : _ +// ``` +//------------------------------------------------------------ +declare wah4_demo author "Julius O. Smith III"; +declare wah4_demo licence "MIT"; + +wah4_demo = ba.bypass1(bp, ve.wah4(fr)) +with{ + wah4_group(x) = hgroup("WAH4 [tooltip: Fourth-order wah effect made using moog_vcf]", x); + bp = wah4_group(checkbox("[0] Bypass [tooltip: When this is checked, the wah pedal has + no effect]")); + fr = wah4_group(hslider("[1] Resonance Frequency [scale:log] [tooltip: wah resonance + frequency in Hz]", 200,100,2000,1)); + // Avoid dc with the moog_vcf (amplitude too high when freq comes up from dc) + // Also, avoid very high resonance frequencies (e.g., 5kHz or above). +}; + +//-------------------------`(dm.)crybaby_demo`--------------------------- +// Crybaby effect application. +// +// #### Usage +// +// ``` +// _ : crybaby_demo : _ +// ``` +//------------------------------------------------------------ +declare crybaby_demo author "Julius O. Smith III"; +declare crybaby_demo licence "MIT"; + +crybaby_demo = ba.bypass1(bp, ve.crybaby(wah)) +with{ + crybaby_group(x) = hgroup("CRYBABY [tooltip: Reference: + https://ccrma.stanford.edu/~jos/pasp/vegf.html]", x); + bp = crybaby_group(checkbox("[0] Bypass [tooltip: When this is checked, the wah + pedal has no effect]")); + wah = crybaby_group(hslider("[1] Wah parameter [tooltip: wah pedal angle between + 0 (rocked back) and 1 (rocked forward)]",0.8,0,1,0.01)); +}; + +//-------------------------`(dm.)flanger_demo`--------------------------- +// Flanger effect application. +// +// #### Usage +// +// ``` +// _,_ : flanger_demo : _,_ +// ``` +//------------------------------------------------------------ +declare flanger_demo author "Julius O. Smith III"; +declare flanger_demo licence "MIT"; + +flanger_demo = ba.bypass2(fbp,flanger_stereo_demo) +with{ + flanger_group(x) = vgroup("FLANGER + [tooltip: Reference: https://ccrma.stanford.edu/~jos/pasp/Flanging.html]", x); + meter_group(x) = flanger_group(hgroup("[0]", x)); + ctl_group(x) = flanger_group(hgroup("[1]", x)); + del_group(x) = flanger_group(hgroup("[2] Delay Controls", x)); + lvl_group(x) = flanger_group(hgroup("[3]", x)); + + fbp = meter_group(checkbox("[0] Bypass [tooltip: When this is checked, the flanger + has no effect]")); + invert = meter_group(checkbox("[1] Invert Flange Sum")); + + // FIXME: This should be an amplitude-response display: + flangeview = lfor(freq) + lfol(freq) : meter_group(hbargraph("[2] Flange LFO + [style: led] [tooltip: Display sum of flange delays]", -1.5,+1.5)); + + flanger_stereo_demo(x,y) = attach(x,flangeview),y : + *(level),*(level) : pf.flanger_stereo(dmax,curdel1,curdel2,depth,fb,invert); + + lfol = os.oscrs; + lfor = os.oscrc; + + dmax = 2048; + dflange = 0.001 * ma.SR * + del_group(hslider("[1] Flange Delay [unit:ms] [style:knob]", 10, 0, 20, 0.001)); + odflange = 0.001 * ma.SR * + del_group(hslider("[2] Delay Offset [unit:ms] [style:knob]", 1, 0, 20, 0.001)); + freq = ctl_group(hslider("[1] Speed [unit:Hz] [style:knob]", 0.5, 0, 10, 0.01)); + depth = ctl_group(hslider("[2] Depth [style:knob]", 1, 0, 1, 0.001)); + fb = ctl_group(hslider("[3] Feedback [style:knob]", 0, -0.999, 0.999, 0.001)); + level = lvl_group(hslider("Flanger Output Level [unit:dB]", 0, -60, 10, 0.1)) : + ba.db2linear; + curdel1 = odflange+dflange*(1 + lfol(freq))/2; + curdel2 = odflange+dflange*(1 + lfor(freq))/2; +}; + + +//-------------------------`(dm.)phaser2_demo`--------------------------- +// Phaser effect demo application. +// +// #### Usage +// +// ``` +// _,_ : phaser2_demo : _,_ +// ``` +//------------------------------------------------------------ +declare phaser2_demo author "Julius O. Smith III"; +declare phaser2_demo licence "MIT"; + +phaser2_demo = ba.bypass2(pbp,phaser2_stereo_demo) +with{ + phaser2_group(x) = vgroup("PHASER2 [tooltip: Reference: + https://ccrma.stanford.edu/~jos/pasp/Flanging.html]", x); + meter_group(x) = phaser2_group(hgroup("[0]", x)); + ctl_group(x) = phaser2_group(hgroup("[1]", x)); + nch_group(x) = phaser2_group(hgroup("[2]", x)); + lvl_group(x) = phaser2_group(hgroup("[3]", x)); + + pbp = meter_group(checkbox("[0] Bypass [tooltip: When this is checked, the phaser + has no effect]")); + invert = meter_group(checkbox("[1] Invert Internal Phaser Sum")); + vibr = meter_group(checkbox("[2] Vibrato Mode")); // In this mode you can hear any "Doppler" + + // FIXME: This should be an amplitude-response display: + // flangeview = phaser2_amp_resp : meter_group(hspectrumview("[2] Phaser Amplitude Response", 0,1)); + // phaser2_stereo_demo(x,y) = attach(x,flangeview),y : ... + + phaser2_stereo_demo = *(level),*(level) : + pf.phaser2_stereo(Notches,width,frqmin,fratio,frqmax,speed,mdepth,fb,invert); + + Notches = 4; // Compile-time parameter: 2 is typical for analog phaser stomp-boxes + + // FIXME: Add tooltips + speed = ctl_group(hslider("[1] Speed [unit:Hz] [style:knob]", 0.5, 0, 10, 0.001)); + depth = ctl_group(hslider("[2] Notch Depth (Intensity) [style:knob]", 1, 0, 1, 0.001)); + fb = ctl_group(hslider("[3] Feedback Gain [style:knob]", 0, -0.999, 0.999, 0.001)); + + width = nch_group(hslider("[1] Notch width [unit:Hz] [style:knob] [scale:log]", + 1000, 10, 5000, 1)); + frqmin = nch_group(hslider("[2] Min Notch1 Freq [unit:Hz] [style:knob] [scale:log]", + 100, 20, 5000, 1)); + frqmax = nch_group(hslider("[3] Max Notch1 Freq [unit:Hz] [style:knob] [scale:log]", + 800, 20, 10000, 1)) : max(frqmin); + fratio = nch_group(hslider("[4] Notch Freq Ratio: NotchFreq(n+1)/NotchFreq(n) [style:knob]", + 1.5, 1.1, 4, 0.001)); + + level = lvl_group(hslider("Phaser Output Level [unit:dB]", 0, -60, 10, 0.1)) : + ba.db2linear; + + mdepth = select2(vibr,depth,2); // Improve "ease of use" +}; + +//======================================Reverbs=========================================== +//======================================================================================== + +//----------------------------`(dm.)freeverb_demo`------------------------- +// Freeverb demo application. +// +// #### Usage +// +// ``` +// _,_ : freeverb_demo : _,_ +// ``` +//------------------------------------------------------------ +declare freeverb_demo author " Romain Michon"; +declare freeverb_demo licence "LGPL"; + +freeverb_demo = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ +with{ + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + parameters(x) = hgroup("Freeverb",x); + knobGroup(x) = parameters(vgroup("[0]",x)); + damping = knobGroup(vslider("[0] Damp [style: knob] [tooltip: Somehow control the + density of the reverb.]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR); + combfeed = knobGroup(vslider("[1] RoomSize [style: knob] [tooltip: The room size + between 0 and 1 with 1 for the largest room.]", 0.5, 0, 1, 0.025)*scaleroom* + origSR/ma.SR + offsetroom); + spatSpread = knobGroup(vslider("[2] Stereo Spread [style: knob] [tooltip: Spatial + spread between 0 and 1 with 1 for maximum spread.]",0.5,0,1,0.01)*46*ma.SR/origSR + : int); + g = parameters(vslider("[1] Wet [tooltip: The amount of reverb applied to the signal + between 0 and 1 with 1 for the maximum amount of reverb.]", 0.3333, 0, 1, 0.025)); +}; + +//---------------------`(dm.)stereo_reverb_tester`-------------------- +// Handy test inputs for reverberator demos below. +// +// #### Usage +// +// ``` +// _ : stereo_reverb_tester : _ +// ``` +//------------------------------------------------------------ +declare stereo_reverb_tester author "Julius O. Smith III"; +declare stereo_reverb_tester licence "MIT"; + +stereo_reverb_tester(revin_group,x,y) = reverb_tester(_) +with { + reverb_tester(revin_group,x,y) = inx,iny with { + ck_group(x) = revin_group(vgroup("[1] Input Config",x)); + mutegain = 1 - ck_group(checkbox("[1] Mute Ext Inputs + [tooltip: When this is checked, the stereo external audio inputs are + disabled (good for hearing the impulse response or pink-noise response alone)]")); + pinkin = ck_group(checkbox("[2] Pink Noise + [tooltip: Pink Noise (or 1/f noise) is Constant-Q Noise (useful for adjusting + the EQ sections)]")); + + imp_group(x) = revin_group(hgroup("[2] Impulse Selection",x)); + pulseL = imp_group(button("[1] Left + [tooltip: Send impulse into LEFT channel]")) : ba.impulsify; + pulseC = imp_group(button("[2] Center + [tooltip: Send impulse into LEFT and RIGHT channels]")) : ba.impulsify; + pulseR = imp_group(button("[3] Right + [tooltip: Send impulse into RIGHT channel]")) : ba.impulsify; + + inx = x*mutegain + (pulseL+pulseC) + pn; + iny = y*mutegain + (pulseR+pulseC) + pn; + pn = 0.1*pinkin*no.pink_noise; + }; +}; + + +//-------------------------`(dm.)fdnrev0_demo`--------------------------- +// A reverb application using `fdnrev0`. +// +// #### Usage +// +// ``` +// _,_,_,_ : fdnrev0_demo(N,NB,BBSO) : _,_ +// ``` +// +// Where: +// +// * `N`: feedback Delay Network (FDN) order / number of delay lines used = +// order of feedback matrix / 2, 4, 8, or 16 [extend primes array below for +// 32, 64, ...] +// * `NB`: number of frequency bands / Number of (nearly) independent T60 controls +// / Integer 3 or greater +// * `BBSO` : butterworth band-split order / order of lowpass/highpass bandsplit +// used at each crossover freq / odd positive integer +//------------------------------------------------------------ +declare fdnrev0_demo author "Julius O. Smith III"; +declare fdnrev0_demo licence "MIT"; + +fdnrev0_demo(N,NB,BBSO) = stereo_reverb_tester(revin_group) + <: re.fdnrev0(MAXDELAY,delays,BBSO,freqs,durs,loopgainmax,nonl) + :> *(gain),*(gain) +with{ + MAXDELAY = 8192; // sync w delays and prime_power_delays above + defdurs = (8.4,6.5,5.0,3.8,2.7); // NB default durations (sec) + deffreqs = (500,1000,2000,4000); // NB-1 default crossover frequencies (Hz) + deflens = (56.3,63.0); // 2 default min and max path lengths + + fdn_group(x) = vgroup("FEEDBACK DELAY NETWORK (FDN) REVERBERATOR, ORDER 16 + [tooltip: See Faust's reverbs.lib for documentation and references]", x); + + freq_group(x) = fdn_group(vgroup("[1] Band Crossover Frequencies", x)); + t60_group(x) = fdn_group(hgroup("[2] Band Decay Times (T60)", x)); + path_group(x) = fdn_group(vgroup("[3] Room Dimensions", x)); + revin_group(x) = fdn_group(hgroup("[4] Input Controls", x)); + nonl_group(x) = revin_group(vgroup("[4] Nonlinearity",x)); + quench_group(x) = revin_group(vgroup("[3] Reverb State",x)); + + nonl = nonl_group(hslider("[style:knob] [tooltip: nonlinear mode coupling]", + 0, -0.999, 0.999, 0.001)); + loopgainmax = 1.0-0.5*quench_group(button("[1] Quench + [tooltip: Hold down 'Quench' to clear the reverberator]")); + + pathmin = path_group(hslider("[1] min acoustic ray length [unit:m] [scale:log] + [tooltip: This length (in meters) determines the shortest delay-line used in the FDN + reverberator. Think of it as the shortest wall-to-wall separation in the room.]", + 46, 0.1, 63, 0.1)); + pathmax = path_group(hslider("[2] max acoustic ray length [unit:m] [scale:log] + [tooltip: This length (in meters) determines the longest delay-line used in the + FDN reverberator. Think of it as the largest wall-to-wall separation in the room.]", + 63, 0.1, 63, 0.1)); + + durvals(i) = t60_group(vslider("[%i] %i [unit:s] [scale:log][tooltip: T60 is the 60dB + decay-time in seconds. For concert halls, an overall reverberation time (T60) near + 1.9 seconds is typical [Beranek 2004]. Here we may set T60 independently in each + frequency band. In real rooms, higher frequency bands generally decay faster due + to absorption and scattering.]",ba.take(i+1,defdurs), 0.1, 100, 0.1)); + durs = par(i,NB,durvals(NB-1-i)); + + freqvals(i) = freq_group(hslider("[%i] Band %i upper edge in Hz [unit:Hz] [scale:log] + [tooltip: Each delay-line signal is split into frequency-bands for separate + decay-time control in each band]",ba.take(i+1,deffreqs), 100, 10000, 1)); + freqs = par(i,NB-1,freqvals(i)); + + delays = de.prime_power_delays(N,pathmin,pathmax); + + gain = hslider("[3] Output Level (dB) [unit:dB][tooltip: Output scale factor]", + -40, -70, 20, 0.1) : ba.db2linear; + // (can cause infinite loop:) with { db2linear(x) = pow(10, x/20.0); }; +}; + +//---------------------------`(dm.)zita_rev_fdn_demo`------------------------------ +// Reverb demo application based on `zita_rev_fdn`. +// +// #### Usage +// +// ``` +// si.bus(8) : zita_rev_fdn_demo : si.bus(8) +// ``` +//------------------------------------------------------------ +declare zita_rev_fdn_demo author "Julius O. Smith III"; +declare zita_rev_fdn_demo licence "MIT"; + +zita_rev_fdn_demo = re.zita_rev_fdn(f1,f2,t60dc,t60m,fsmax) +with{ + fsmax = 48000.0; + fdn_group(x) = hgroup("Zita_Rev Internal FDN Reverb [tooltip: ~ Zita_Rev's internal + 8x8 Feedback Delay Network (FDN) & Schroeder allpass-comb reverberator. See + Faust's reverbs.lib for documentation and references]",x); + t60dc = fdn_group(vslider("[1] Low RT60 [unit:s] [style:knob][style:knob] + [tooltip: T60 = time (in seconds) to decay 60dB in low-frequency band]", + 3, 1, 8, 0.1)); + f1 = fdn_group(vslider("[2] LF X [unit:Hz] [style:knob] [scale:log] + [tooltip: Crossover frequency (Hz) separating low and middle frequencies]", + 200, 50, 1000, 1)); + t60m = fdn_group(vslider("[3] Mid RT60 [unit:s] [style:knob] [scale:log] + [tooltip: T60 = time (in seconds) to decay 60dB in middle band]", + 2, 1, 8, 0.1)); + f2 = fdn_group(vslider("[4] HF Damping [unit:Hz] [style:knob] [scale:log] + [tooltip: Frequency (Hz) at which the high-frequency T60 is half the middle-band's T60]", + 6000, 1500, 0.49*fsmax, 1)); +}; + +//---------------------------`(dm.)zita_light`------------------------------ +// Light version of `dm.zita_rev1` with only 2 UI elements. +// +// #### Usage +// +// ``` +// _,_ : zita_light : _,_ +// ``` +//------------------------------------------------------------ +declare zita_light author "Julius O. Smith III"; +declare zita_light licence "MIT"; + +zita_light = hgroup("Zita Light",(_,_ <: re.zita_rev1_stereo(rdel,f1,f2,t60dc,t60m,fsmax),_,_ : + out_eq,_,_ : dry_wet : out_level)) +with{ + fsmax = 48000.0; // highest sampling rate that will be used + rdel = 60; + f1 = 200; + t60dc = 3; + t60m = 2; + f2 = 6000; + out_eq = pareq_stereo(eq1f,eq1l,eq1q) : pareq_stereo(eq2f,eq2l,eq2q); + pareq_stereo(eqf,eql,Q) = fi.peak_eq_rm(eql,eqf,tpbt), fi.peak_eq_rm(eql,eqf,tpbt) + with { + tpbt = wcT/sqrt(max(0,g)); // tan(PI*B/SR), B bw in Hz (Q^2 ~ g/4) + wcT = 2*ma.PI*eqf/ma.SR; // peak frequency in rad/sample + g = ba.db2linear(eql); // peak gain + }; + eq1f = 315; + eq1l = 0; + eq1q = 3; + eq2f = 1500; + eq2l = 0; + eq2q = 3; + dry_wet(x,y) = *(wet) + dry*x, *(wet) + dry*y + with { + wet = 0.5*(drywet+1.0); + dry = 1.0-wet; + }; + drywet = vslider("[1] Dry/Wet Mix [style:knob] [tooltip: -1 = dry, 1 = wet]", + 0,-1.0,1.0,0.01) : si.smoo; + gain = vslider("[2] Level [unit:dB] [style:knob] [tooltip: Output scale + factor]", -6, -70, 40, 0.1) : ba.db2linear : si.smoo; + out_level = *(gain),*(gain); +}; + +//----------------------------------`(dm.)zita_rev1`------------------------------ +// Example GUI for `zita_rev1_stereo` (mostly following the Linux `zita-rev1` GUI). +// +// Only the dry/wet and output level parameters are "dezippered" here. If +// parameters are to be varied in real time, use `smooth(0.999)` or the like +// in the same way. +// +// #### Usage +// +// ``` +// _,_ : zita_rev1 : _,_ +// ``` +// +// #### Reference +// +// +//------------------------------------------------------------ +declare zita_rev1 author "Julius O. Smith III"; +declare zita_rev1 licence "MIT"; + +zita_rev1 = _,_ <: re.zita_rev1_stereo(rdel,f1,f2,t60dc,t60m,fsmax),_,_ : out_eq,_,_ : + dry_wet : out_level +with{ + fsmax = 48000.0; // highest sampling rate that will be used + + fdn_group(x) = hgroup( + "[0] Zita_Rev1 [tooltip: ~ ZITA REV1 FEEDBACK DELAY NETWORK (FDN) & SCHROEDER + ALLPASS-COMB REVERBERATOR (8x8). See Faust's reverbs.lib for documentation and + references]", x); + + in_group(x) = fdn_group(hgroup("[1] Input", x)); + + rdel = in_group(vslider("[1] In Delay [unit:ms] [style:knob] [tooltip: Delay in ms + before reverberation begins]",60,20,100,1)); + + freq_group(x) = fdn_group(hgroup("[2] Decay Times in Bands (see tooltips)", x)); + + f1 = freq_group(vslider("[1] LF X [unit:Hz] [style:knob] [scale:log] [tooltip: + Crossover frequency (Hz) separating low and middle frequencies]", 200, 50, 1000, 1)); + + t60dc = freq_group(vslider("[2] Low RT60 [unit:s] [style:knob] [scale:log] + [style:knob] [tooltip: T60 = time (in seconds) to decay 60dB in low-frequency band]", + 3, 1, 8, 0.1)); + + t60m = freq_group(vslider("[3] Mid RT60 [unit:s] [style:knob] [scale:log] [tooltip: + T60 = time (in seconds) to decay 60dB in middle band]",2, 1, 8, 0.1)); + + f2 = freq_group(vslider("[4] HF Damping [unit:Hz] [style:knob] [scale:log] + [tooltip: Frequency (Hz) at which the high-frequency T60 is half the middle-band's T60]", + 6000, 1500, 0.49*fsmax, 1)); + + out_eq = pareq_stereo(eq1f,eq1l,eq1q) : pareq_stereo(eq2f,eq2l,eq2q); + // Zolzer style peaking eq (not used in zita-rev1) (filters.lib): + // pareq_stereo(eqf,eql,Q) = peak_eq(eql,eqf,eqf/Q), peak_eq(eql,eqf,eqf/Q); + // Regalia-Mitra peaking eq with "Q" hard-wired near sqrt(g)/2 (filters.lib): + pareq_stereo(eqf,eql,Q) = fi.peak_eq_rm(eql,eqf,tpbt), fi.peak_eq_rm(eql,eqf,tpbt) + with { + tpbt = wcT/sqrt(max(0,g)); // tan(PI*B/SR), B bw in Hz (Q^2 ~ g/4) + wcT = 2*ma.PI*eqf/ma.SR; // peak frequency in rad/sample + g = ba.db2linear(eql); // peak gain + }; + + eq1_group(x) = fdn_group(hgroup("[3] RM Peaking Equalizer 1", x)); + + eq1f = eq1_group(vslider("[1] Eq1 Freq [unit:Hz] [style:knob] [scale:log] [tooltip: + Center-frequency of second-order Regalia-Mitra peaking equalizer section 1]", + 315, 40, 2500, 1)); + + eq1l = eq1_group(vslider("[2] Eq1 Level [unit:dB] [style:knob] [tooltip: Peak level + in dB of second-order Regalia-Mitra peaking equalizer section 1]", 0, -15, 15, 0.1)); + + eq1q = eq1_group(vslider("[3] Eq1 Q [style:knob] [tooltip: Q = centerFrequency/bandwidth + of second-order peaking equalizer section 1]", 3, 0.1, 10, 0.1)); + + eq2_group(x) = fdn_group(hgroup("[4] RM Peaking Equalizer 2", x)); + + eq2f = eq2_group(vslider("[1] Eq2 Freq [unit:Hz] [style:knob] [scale:log] [tooltip: + Center-frequency of second-order Regalia-Mitra peaking equalizer section 2]", + 1500, 160, 10000, 1)); + + eq2l = eq2_group(vslider("[2] Eq2 Level [unit:dB] [style:knob] [tooltip: Peak level + in dB of second-order Regalia-Mitra peaking equalizer section 2]", 0, -15, 15, 0.1)); + + eq2q = eq2_group(vslider("[3] Eq2 Q [style:knob] [tooltip: Q = centerFrequency/bandwidth + of second-order peaking equalizer section 2]", 3, 0.1, 10, 0.1)); + + out_group(x) = fdn_group(hgroup("[5] Output", x)); + + dry_wet(x,y) = *(wet) + dry*x, *(wet) + dry*y with { + wet = 0.5*(drywet+1.0); + dry = 1.0-wet; + }; + + drywet = out_group(vslider("[1] Dry/Wet Mix [style:knob] [tooltip: -1 = dry, 1 = wet]", + 0, -1.0, 1.0, 0.01)) : si.smoo; + + out_level = *(gain),*(gain); + + gain = out_group(vslider("[2] Level [unit:dB] [style:knob] [tooltip: Output scale + factor]", -20, -70, 40, 0.1)) : ba.db2linear : si.smoo; +}; + +//----------------------------------`(dm.)dattorro_rev_demo`------------------------------ +// Example GUI for `dattorro_rev` with all parameters exposed. With additional +// dry/wet and output gain control. +// +// #### Usage +// +// ``` +// _,_ : dattorro_rev_demo : _,_ +// ``` +// +//------------------------------------------------------------ +declare dattorro_rev_demo author "Jakob Zerbian"; +declare dattorro_rev_demo license "MIT-style STK-4.3 license"; + +dattorro_rev_demo = _,_ <: re.dattorro_rev(pre_delay, bw, i_diff1, i_diff2, decay, d_diff1, d_diff2, damping),_,_: + dry_wet : out_level +with { + rev_group(x) = hgroup("[0] Dattorro Reverb",x); + + in_group(x) = rev_group(hgroup("[0] Input",x)); + pre_delay = 0; + bw = in_group(vslider("[1] Prefilter [style:knob] [tooltip: lowpass-like filter, 0 = no signal, 1 = no filtering]",0.7,0.0,1.0,0.001) : si.smoo); + i_diff1 = in_group(vslider("[2] Diffusion 1 [style:knob] [tooltip: diffusion factor, influences reverb color and density]",0.625,0.0,1.0,0.001) : si.smoo); + i_diff2 = in_group(vslider("[3] Diffusion 2 [style:knob] [tooltip: diffusion factor, influences reverb color and density]",0.625,0.0,1.0,0.001) : si.smoo); + + fdb_group(x) = rev_group(hgroup("[1] Feedback",x)); + d_diff1 = fdb_group(vslider("[1] Diffusion 1 [style:knob] [tooltip: diffusion factor, influences reverb color and density]",0.625,0.0,1.0,0.001) : si.smoo); + d_diff2 = fdb_group(vslider("[2] Diffusion 2 [style:knob] [tooltip: diffusion factor, influences reverb color and density]",0.625,0.0,1.0,0.001) : si.smoo); + decay = fdb_group(vslider("[3] Decay Rate [style:knob] [tooltip: decay length, 1 = infinite]",0.7,0.0,1.0,0.001) : si.smoo); + damping = fdb_group(vslider("[4] Damping [style:knob] [tooltip: dampening in feedback network]",0.625,0.0,1.0,0.001) : si.smoo); + + out_group(x) = rev_group(hgroup("[2] Output",x)); + dry_wet(x,y) = *(dry) + wet*x, *(dry) + wet*y + with { + wet = 0.5*(drywet+1.0); + dry = 1.0-wet; + }; + drywet = out_group(vslider("[1] Dry/Wet Mix [style:knob] [tooltip: -1 = dry, 1 = wet]",0,-1.0,1.0,0.01) : si.smoo); + gain = out_group(vslider("[2] Level [unit:dB] [style:knob] [tooltip: Output Gain]", -6, -70, 40, 0.1) : ba.db2linear : si.smoo); + out_level = *(gain),*(gain); +}; + +//----------------------------------`(dm.)jprev_demo`------------------------------ +// Example GUI for `jprev` with all parameters exposed. +// +// #### Usage +// +// ``` +// _,_ : jprev_demo : _,_ +// ``` +// +//------------------------------------------------------------ +declare jprev_demo author "Till Bovermann"; +declare jprev_demo license "GPL2+"; + +jprev_demo = re.jpverb(t60, damp, size, early_diff, mod_depth, mod_freq, low, mid, high, low_cutoff, high_cutoff) +with { + rev_group(x) = vgroup("[0] JPrev",x); + + mix_group(x) = rev_group(hgroup("[0] Mix",x)); + early_diff = mix_group(hslider("[1]earlyDiff [style:knob]", 0.707, 0, 0.990, 0.001)); + size = mix_group(hslider("[2]size [style:knob]", 1, 0.5, 3, 0.01)); + t60 = mix_group(hslider("[3]t60 [style:knob]", 1, 0.1, 60, 0.1)); + damp = mix_group(hslider("[4]damp [style:knob]", 0, 0, 0.999, 0.0001)); + + eq_group(x) = rev_group(hgroup("[1] EQ",x)); + low = eq_group(hslider("[07]lowX [style:knob]", 1, 0, 1, 0.01)); + mid = eq_group(hslider("[08]midX [style:knob]", 1, 0, 1, 0.01)); + high = eq_group(hslider("[09]highX [style:knob]", 1, 0, 1, 0.01)); + low_cutoff = eq_group(hslider("[10]lowBand [style:knob]", 500, 100, 6000, 0.1)); + high_cutoff = eq_group(hslider("[11]highBand [style:knob]", 2000, 1000, 10000, 0.1)); + + mod_group(x) = rev_group(hgroup("[2] Mod",x)); + mod_depth = mod_group(hslider("[1]mDepth [style:knob]", 0.1, 0, 1, 0.001)); + mod_freq = mod_group(hslider("[2]mFreq [style:knob]", 2, 0, 10, 0.010)); +}; + + +//----------------------------------`(dm.)greyhole_demo`------------------------------ +// Example GUI for `greyhole` with all parameters exposed. +// +// #### Usage +// +// ``` +// _,_ : greyhole_demo : _,_ +// ``` +// +//------------------------------------------------------------ +declare greyhole_demo author "Till Bovermann"; +declare greyhole_demo license "GPL2+"; + +greyhole_demo = re.greyhole(dt, damp, size, early_diff, feedback, mod_depth, mod_freq) +with { + + rev_group(x) = vgroup("[0] Greyhole",x); + + mix_group(x) = rev_group(hgroup("[0] Mix",x)); + dt = mix_group(hslider("[01]delayTime [style:knob]", 0.2, 0.001, 1.45, 0.0001)); + damp = mix_group(hslider("[02]damping [style:knob]", 0, 0, 0.99, 0.001)); + size = mix_group(hslider("[03]size [style:knob]", 1, 0.5, 3, 0.0001)); + early_diff = mix_group(hslider("[04]diffusion [style:knob]", 0.5, 0, 0.99, 0.0001)); + feedback = mix_group(hslider("[05]feedback [style:knob]", 0.9, 0, 1, 0.01)); + + mod_group(x) = rev_group(hgroup("[1] Mod",x)); + mod_depth = mod_group(hslider("[06]modDepth [style:knob]", 0.1, 0, 1, 0.001)); + mod_freq = mod_group(hslider("[07]modFreq [style:knob]", 2, 0, 10, 0.01)); +}; + +//====================================Generators========================================== +//======================================================================================== + +//--------------------------`(dm.)sawtooth_demo`--------------------------- +// An application demonstrating the different sawtooth oscillators of Faust. +// +// #### Usage +// +// ``` +// sawtooth_demo : _ +// ``` +//------------------------------------------------------------ +declare sawtooth_demo author "Julius O. Smith III"; +declare sawtooth_demo licence "MIT"; + +sawtooth_demo = signal +with{ + osc_group(x) = vgroup("[0] SAWTOOTH OSCILLATOR [tooltip: See Faust's oscillators.lib + for documentation and references]",x); + knob_group(x) = osc_group(hgroup("[1]", x)); + ampdb = knob_group(vslider("[1] Amplitude [unit:dB] [style:knob] [tooltip: Sawtooth + waveform amplitude]",-20,-120,10,0.1)); + amp = ampdb : ba.db2linear : si.smoo; + freq = knob_group(vslider("[2] Frequency [unit:PK] [style:knob] [tooltip: Sawtooth + frequency as a Piano Key (PK) number (A440 = key 49)]",49,1,88,0.01) : ba.pianokey2hz); + detune1 = 1 + 0.01 * knob_group( + vslider("[3] Detuning 1 [unit:%%] [style:knob] [tooltip: Percentage frequency-shift + up or down for second oscillator]",-0.1,-10,10,0.01)); + detune2 = 1 + 0.01 * knob_group(vslider("[4] Detuning 2 [unit:%%] [style:knob] [tooltip: + Percentage frequency-shift up or down for third detuned oscillator]",+0.1,-10,10,0.01)); + portamento = knob_group(vslider("[5] Portamento [unit:sec] [style:knob] [scale:log] + [tooltip: Portamento (frequency-glide) time-constant in seconds]",0.1,0.001,10,0.001)); + sfreq = freq : si.smooth(ba.tau2pole(portamento)); + saworder = knob_group(nentry("[6] Saw Order [tooltip: Order of sawtootn aliasing + suppression]",2,1,os.MAX_SAW_ORDER,1)); + sawchoice = _ <: par(i,os.MAX_SAW_ORDER,os.sawN(i+1)) : + ba.selectn(int(os.MAX_SAW_ORDER), int(saworder-1)); // when max is pwr of 2 + tone = (amp/3) * (sawchoice(sfreq) + sawchoice(sfreq*detune1) + sawchoice(sfreq*detune2)); + signal = amp * select2(ei, select2(ss, tone, white_or_pink_noise), _); + white_or_pink_noise = select2(wp,no.noise,no.pink_noise); + checkbox_group(x) = knob_group(vgroup("[7] Alternate Signals",x)); + ss = checkbox_group(checkbox("[0] Noise (White or Pink - uses only Amplitude control on + the left)")); + wp = checkbox_group(checkbox("[1] Pink instead of White Noise (also called 1/f Noise) + [tooltip: Pink Noise (or 1/f noise) is Constant-Q Noise, meaning that it has the + same total power in every octave]")); + ei = checkbox_group(checkbox("[2] External Signal Input (overrides Sawtooth/Noise + selection above)")); +}; + + +//----------------------`(dm.)virtual_analog_oscillator_demo`---------------------- +// Virtual analog oscillator demo application. +// +// #### Usage +// +// ``` +// virtual_analog_oscillator_demo : _ +// ``` +//------------------------------------------------------------ +declare virtual_analog_oscillator_demo author "Julius O. Smith III"; +declare virtual_analog_oscillator_demo licence "MIT"; + +virtual_analog_oscillator_demo = signal +with{ + osc_group(x) = vgroup("[0] VIRTUAL ANALOG OSCILLATORS + [tooltip: See Faust's oscillators.lib for documentation and references]",x); + + // Signals + sawchoice = _ <: + // When MAX_SAW_ORDER is a power of 2: + par(i,os.MAX_SAW_ORDER,os.sawN(i+1)) : ba.selectn(int(os.MAX_SAW_ORDER), int(saworder-1)); + // When MAX_SAW_ORDER is NOT a power of 2: + // (par(i,MAX_SAW_ORDER,sawN(i+1)), par(j,MAX_SAW_ORDER_NEXTPOW2-MAX_SAW_ORDER,_)) + // : selectn(MAX_SAW_ORDER_NEXTPOW2, saworder-1); + saw = (amp/3) * + (sawchoice(sfreq) + sawchoice(sfreq*detune1) + sawchoice(sfreq*detune2)); + sq = (amp/3) * + (os.square(sfreq) + os.square(sfreq*detune1) + os.square(sfreq*detune2)); + tri = (amp/3) * + (os.triangle(sfreq) + os.triangle(sfreq*detune1) + os.triangle(sfreq*detune2)); + pt = (amp/3) * (os.pulsetrain(sfreq,ptd) + + os.pulsetrain(sfreq*detune1,ptd) + + os.pulsetrain(sfreq*detune2,ptd)); + ptN = (amp/3) * (os.pulsetrainN(N,sfreq,ptd) + + os.pulsetrainN(N,sfreq*detune1,ptd) + + os.pulsetrainN(N,sfreq*detune2,ptd)) with { N=3; }; + pn = amp * no.pink_noise; + + signal = ssaw*saw + ssq*sq + stri*tri + + spt*((ssptN*ptN)+(1-ssptN)*pt) + + spn*pn + sei*_; + + // Signal controls: + signal_group(x) = osc_group(hgroup("[0] Signal Levels",x)); + ssaw = signal_group(vslider("[0] Sawtooth [style:vslider]",1,0,1,0.01)); + + pt_group(x) = signal_group(vgroup("[1] Pulse Train",x)); + ssptN = pt_group(checkbox("[0] Order 3 + [tooltip: When checked, use 3rd-order aliasing suppression (up from 2) + See if you can hear a difference with the freq high and swept]")); + spt = pt_group(vslider("[1] [style:vslider]",0,0,1,0.01)); + ptd = pt_group(vslider("[2] Duty Cycle [style:knob]",0.5,0,1,0.01)) + : si.smooth(0.99); + + ssq = signal_group(vslider("[2] Square [style:vslider]",0,0,1,0.01)); + stri = signal_group(vslider("[3] Triangle [style:vslider]",0,0,1,0.01)); + spn = signal_group(vslider( + "[4] Pink Noise [style:vslider][tooltip: Pink Noise (or 1/f noise) is + Constant-Q Noise, meaning that it has the same total power in every octave + (uses only amplitude controls)]",0,0,1,0.01)); + sei = signal_group(vslider("[5] Ext Input [style:vslider]",0,0,1,0.01)); + + // Signal Parameters + knob_group(x) = osc_group(hgroup("[1] Signal Parameters", x)); + af_group(x) = knob_group(vgroup("[0]", x)); + ampdb = af_group(hslider("[1] Mix Amplitude [unit:dB] [style:hslider] + [tooltip: Sawtooth waveform amplitude]",-20,-120,10,0.1)); + amp = ampdb : ba.db2linear : si.smoo; + freq = af_group(hslider("[2] Frequency [unit:PK] [style:hslider] [tooltip: Sawtooth + frequency as a Piano Key (PK) number (A440 = key 49)]",49,1,88,0.01) : ba.pianokey2hz); + + detune1 = 1 - 0.01 * knob_group( + vslider("[3] Detuning 1 [unit:%%] [style:knob] + [tooltip: Percentage frequency-shift up or down for second oscillator]", + -0.1,-10,10,0.01)); + detune2 = 1 + 0.01 * knob_group( + vslider("[4] Detuning 2 [unit:%%] [style:knob] + [tooltip: Percentage frequency-shift up or down for third detuned oscillator]", + +0.1,-10,10,0.01)); + portamento = knob_group( + vslider("[5] Portamento [unit:sec] [style:knob] [scale:log] + [tooltip: Portamento (frequency-glide) time-constant in seconds]", + 0.1,0.001,10,0.001)); + saworder = knob_group(nentry("[6] Saw Order [tooltip: Order of sawtooth aliasing + suppression]",2,1,os.MAX_SAW_ORDER,1)); + sfreq = freq : si.smooth(ba.tau2pole(portamento)); +}; + + +//--------------------------`(dm.)oscrs_demo` --------------------------- +// Simple application demoing filter based oscillators. +// +// #### Usage +// +// ``` +// oscrs_demo : _ +// ``` +//------------------------------------------------------------------- +declare oscrs_demo author "Julius O. Smith III"; +declare oscrs_demo licence "MIT"; + +oscrs_demo = signal +with{ + osc_group(x) = vgroup("[0] SINE WAVE OSCILLATOR oscrs [tooltip: Sine oscillator based + on 2D vector rotation]",x); + ampdb = osc_group(hslider("[1] Amplitude [unit:dB] [tooltip: Sawtooth waveform + amplitude]",-20,-120,10,0.1)); + amp = ampdb : ba.db2linear : si.smoo; + freq = osc_group( + hslider("[2] Frequency [unit:PK] + [tooltip: Sine wave frequency as a Piano Key (PK) number (A440 = 49 PK)]", + 49,1,88,0.01) : ba.pianokey2hz); + portamento = osc_group( + hslider("[3] Portamento [unit:sec] [scale:log] + [tooltip: Portamento (frequency-glide) time-constant in seconds]", + 0.1,0.001,10,0.001)); + sfreq = freq : si.smooth(ba.tau2pole(portamento)); + signal = amp * os.oscrs(sfreq); +}; + +oscr_demo = oscrs_demo; // synonym + + +//--------------------------`(dm.)velvet_noise_demo`--------------------------- +// Listen to velvet_noise! +// +// #### Usage +// +// ``` +// velvet_noise_demo : _ +// ``` +//------------------------------------------------------------------- +declare velvet_noise_demo author "Julius O. Smith III"; +declare velvet_noise_demo licence "MIT"; + +velvet_noise_demo = vn +with{ + amp = hslider("Amp [unit:dB]",-10,-70,10,0.1) : ba.db2linear; + f0 = 10.0, hslider("Freq [unit:log10(Hz)]",3,0,4,0.001) : pow; + vn = no.velvet_noise(amp,f0); +}; + + +//--------------------------`(dm.)latch_demo`--------------------------- +// Illustrate latch operation. +// +// #### Usage +// +// ``` +// echo 'import("stdfaust.lib");' > latch_demo.dsp +// echo 'process = dm.latch_demo;' >> latch_demo.dsp +// faust2octave latch_demo.dsp +// Octave:1> plot(faustout); +// ``` +//------------------------------------------------------------------- +declare latch_demo author "Julius O. Smith III"; +declare latch_demo licence "MIT"; + +latch_demo = x, c, ba.latch(c,x) // plot(faustout) after faust2octave +with{ + f = float(ma.SR)/1000.0; + x = os.oscr(f); + c = 0.5 * os.oscrs(5*f); // sample 5 times per period +}; + + +//--------------------------`(dm.)envelopes_demo`--------------------------- +// Illustrate various envelopes overlaid, including their gate * 1.1. +// +// #### Usage +// +// ``` +// echo 'import("stdfaust.lib");' > envelopes_demo.dsp +// echo 'process = dm.envelopes_demo;' >> envelopes_demo.dsp +// faust2octave envelopes_demo.dsp +// Octave:1> plot(faustout); +// ``` +//------------------------------------------------------------------- +declare envelopes_demo author "Julius O. Smith III"; +declare envelopes_demo licence "MIT"; + +envelopes_demo = gate <: _*1.1,envSE,envAR,envARFE,envARE,envASR,envADSR,envADSRE +with{ + gate = (1-(1@500)) + 0.5*(1@750-(1@1700)); // retrigger at 1/2 amp + envSE = en.smoothEnvelope(attSec/6.91); // uses time-constant not t60 + envAR = en.ar(attSec,relT60); + envARFE = en.arfe(attSec,relT60,0.25); + envARE = en.are(attSec,relT60); + envASR = en.asr(attSec,susLvl,relT60); + envADSR = en.adsr(attSec,decT60,susLvl,relT60); + envADSRE = en.adsre(attSec,decT60,susLvl,relT60); + attSec=0.002; // 2 ms attack time + decT60=0.010; // 10 ms decay-to-sustain time + susLvl=0.80; // Sustain level = 0.8 + relT60=0.010; // 10 ms release (decay-to-zero) time +}; + +//-------------------`(dm.)fft_spectral_level_demo`------------------ +// Make a real-time spectrum analyzer using FFT from analyzers.lib. +// +// #### Usage +// +// ``` +// echo 'import("stdfaust.lib");' > fft_spectral_level_demo.dsp +// echo 'process = dm.fft_spectral_level_demo;' >> fft_spectral_level_demo.dsp +// Mac: +// faust2caqt fft_spectral_level_demo.dsp +// open fft_spectral_level_demo.app +// Linux GTK: +// faust2jack fft_spectral_level_demo.dsp +// ./fft_spectral_level_demo +// Linux QT: +// faust2jaqt fft_spectral_level_demo.dsp +// ./fft_spectral_level_demo +// ``` +//------------------------------------------------------------------- +declare fft_spectral_level_demo author "Julius O. Smith III"; +declare fft_spectral_level_demo licence "MIT"; + +fft_spectral_level_demo(N) = an.rfft_spectral_level(N,tau,dB_offset) +with{ + ctl_group(x) = hgroup("[1] FFT SPECTRUM ANALYZER CONTROLS", x); + tau = ctl_group(hslider("[0] Level Averaging Time [unit:ms] [scale:log] + [tooltip: band-level averaging time in milliseconds]", + 100,1,10000,1)) * 0.001; + dB_offset = ctl_group(hslider("[1] Level dB Offset [unit:dB] + [tooltip: Level offset in decibels]", + 50,-50,100,1)); +}; + +//-----------------`(dm.)reverse_echo_demo(nChans)`---------------- +// Multichannel echo effect with reverse delays. +// +// #### Usage +// +// ``` +// echo 'import("stdfaust.lib");' > reverse_echo_demo.dsp +// echo 'nChans = 3; // Any integer > 1 should work here' >> reverse_echo_demo.dsp +// echo 'process = dm.reverse_echo_demo(nChans);' >> reverse_echo_demo.dsp +// Mac: +// faust2caqt reverse_echo_demo.dsp +// open reverse_echo_demo.app +// Linux GTK: +// faust2jack reverse_echo_demo.dsp +// ./reverse_echo_demo +// Linux QT: +// faust2jaqt reverse_echo_demo.dsp +// ./reverse_echo_demo +// Etc. +// ``` +//------------------------------------------------------------------- +declare reverse_echo_demo author "Julius O. Smith III"; +declare reverse_echo_demo licence "MIT"; + +reverse_echo_demo(nChans) = ef.reverseEchoN(nChans,delMax) : ef.uniformPanToStereo(nChans) +with { + delMax = 2^int(nentry("Log2(Delay)",15,5,16,1)); // delay line length +}; + +//------------------------`(dm.)pospass_demo`------------------------ +// Use Positive-Pass Filter pospass() to frequency-shift a sine tone. +// First, a real sinusoid is converted to its analytic-signal form +// using pospass() to filter out its negative frequency component. +// Next, it is multiplied by a modulating complex sinusoid at the +// shifting frequency to create the frequency-shifted result. +// The real and imaginary parts are output to channels 1 & 2. +// For a more interesting frequency-shifting example, check the +// "Use Mic" checkbox to replace the input sinusoid by mic input. +// Note that frequency shifting is not the same as frequency scaling. +// A frequency-shifted harmonic signal is usually not harmonic. +// Very small frequency shifts give interesting chirp effects when +// there is feedback around the frequency shifter. +// +// #### Usage +// +// ``` +// echo 'import("stdfaust.lib");' > pospass_demo.dsp +// echo 'process = dm.pospass_demo;' >> pospass_demo.dsp +// Mac: +// faust2caqt pospass_demo.dsp +// open pospass_demo.app +// Linux GTK: +// faust2jack pospass_demo.dsp +// ./pospass_demo +// Linux QT: +// faust2jaqt pospass_demo.dsp +// ./pospass_demo +// Etc. +// ``` +//------------------------------------------------------------------- +declare pospass_demo author "Julius O. Smith III"; +declare pospass_demo licence "MIT"; + +pospass_demo(x) = analytic_signal, modulator : si.cmul with { + N = 6; // pospass filter order + fc = ma.SR/(2*N); // guard-band for filter roll-off + octavesShift = hslider("Frequency Shift in octaves away from SR/16", + -2,-7,3,0.001) : si.smooth(0.999); + in_select = checkbox("Use Mic"); + sine_tone = os.oscrs(f0); + f0 = ma.SR/16.0; // original frequency to be shifted + fn = f0 * 2.0^octavesShift; // modulated frequency + df = fn - f0; // frequency-shift as a difference + input = select2(in_select, sine_tone, x); + analytic_signal = input : fi.pospass6e(fc); // filter out neg freqs + //analytic_signal = os.oscrs(f0) : fi.pospass(N,fc); // Butterworth case + modulator = os.oscrq(df) : si.cconj; // complex modulation sinusoid + // modulator(n) = exp(sqrt(-1) * 2 * ma.PI * df * n / ma.SR) // if complex ok +}; + +// end jos section +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +// TODO: Add GRAME functions here + +//######################################################################################## +/************************************************************************ +FAUST library file, further contributions section + +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ + +//-------------------------------`(dm.)exciter`------------------------------- +// Psychoacoustic harmonic exciter, with GUI. +// +// #### Usage +// +// ``` +// _ : exciter : _ +// ``` +// +// #### References +// +// * +// * +//------------------------------------------------------------------------------------- +declare exciter author "PPriyanka Shekar and Julius O. Smith III"; +declare exciter licence "STK-4.3"; + +//------------------------------------------------------------------------------------- +exciter = _ <: (fi.highpass(2, fc) : compressor : pregain : harmonicCreator : + postgain), _ : balance +with{ + // TODO: rewrite to use the standard compressor from compressors.lib + compressor = ba.bypass1(cbp,compressorMono) + with{ + comp_group(x) = vgroup("COMPRESSOR [tooltip: Reference: + http://en.wikipedia.org/wiki/Dynamic_range_compression]", x); + + meter_group(x) = comp_group(hgroup("[0]", x)); + knob_group(x) = comp_group(hgroup("[1]", x)); + + cbp = meter_group(checkbox("[0] Bypass [tooltip: When this is checked, + the compressor has no effect]")); + + gainview = co.compression_gain_mono(ratio,threshold,attack,release) : ba.linear2db + : meter_group(hbargraph("[1] Compressor Gain [unit:dB] [tooltip: Current gain + of the compressor in dB]",-50,+10)); + + displaygain = _ <: _,abs : _,gainview : attach; + + compressorMono = displaygain(co.compressor_mono(ratio,threshold,attack,release)); + + ctl_group(x) = knob_group(hgroup("[3] Compression Control", x)); + + ratio = ctl_group(hslider("[0] Ratio [style:knob] [tooltip: A compression Ratio + of N means that for each N dB increase in input signal level above Threshold, the + output level goes up 1 dB]", 5, 1, 20, 0.1)); + + threshold = ctl_group(hslider("[1] Threshold [unit:dB] [style:knob] [tooltip: + When the signal level exceeds the Threshold (in dB), its level is compressed + according to the Ratio]", -30, -100, 10, 0.1)); + + env_group(x) = knob_group(hgroup("[4] Compression Response", x)); + + attack = env_group(hslider("[1] Attack [unit:ms] [style:knob] [tooltip: + Time constant in ms (1/e smoothing time) for the compression gain to approach + (exponentially) a new lower target level (the compression `kicking in')]", + 50, 0, 500, 0.1)) : *(0.001) : max(1/ma.SR); + + release = env_group(hslider("[2] Release [unit:ms] [style: knob] [tooltip: + Time constant in ms (1/e smoothing time) for the compression gain to approach + (exponentially) a new higher target level (the compression 'releasing')]", + 500, 0, 1000, 0.1)) : *(0.001) : max(1/ma.SR); + }; + + //Exciter GUI controls + ex_group(x) = hgroup("EXCITER [tooltip: Reference: Patent US4150253 A]", x); + + //Highpass - selectable cutoff frequency + fc = ex_group(hslider("[0] Cutoff Frequency [unit:Hz] [style:knob] [scale:log] + [tooltip: Cutoff frequency for highpassed components to be excited]", + 5000, 1000, 10000, 100)); + + //Pre-distortion gain - selectable percentage of harmonics + ph = ex_group(hslider("[1] Harmonics [unit:percent] [style:knob] [tooltip: + Percentage of harmonics generated]", 20, ma.EPSILON, 200, 1)) / 100; + pregain = * (ph); + + // TODO: same thing: why doesn't this use cubicnl? + //Asymmetric cubic soft clipper + harmonicCreator(x) = x <: cubDist1, cubDist2, cubDist3 :> _; + cubDist1(x) = (x < 0) * x; + cubDist2(x) = (x >= 0) * (x <= 1) * (x - x ^ 3 / 3); + cubDist3(x) = (x > 1) * 2/3; + + //Post-distortion gain - undoes effect of pre-gain + postgain = * (1/ph); + + //Balance - selectable dry/wet mix + ml = ex_group(hslider("[2] Mix [style:knob] [tooltip: Dry/Wet mix of original signal + to excited signal]", 0.5, 0, 1, 0.01)); + balance = (_ * ml), (_ * (1.0 - ml)) :> _; +}; + + +//----------------------------`(dm.)vocoder_demo`------------------------- +// Use example of the vocoder function where an impulse train is used +// as excitation. +// +// #### Usage +// +// ``` +// _ : vocoder_demo : _ +// ``` +//------------------------------------------------------------ +declare vocoder_demo author "Romain Michon"; +declare vocoder_demo licence "LGPL"; + +vocoder_demo = hgroup("My Vocoder",_,os.lf_imptrain(freq)*gain : + ve.vocoder(bands,att,rel,BWRatio) <: _,_) +with{ + bands = 32; + vocoderGroup(x) = vgroup("Vocoder",x); + att = vocoderGroup(hslider("[0] Attack [style:knob] [tooltip: Attack time in seconds]", + 5,0.1,100,0.1)*0.001); + rel = vocoderGroup(hslider("[1] Release [style:knob] [tooltip: Release time in seconds]", + 5,0.1,100,0.1)*0.001); + BWRatio = vocoderGroup(hslider("[2] BW [style:knob] [tooltip: Coefficient to adjust the + bandwidth of each band]",0.5,0.1,2,0.001)); + excitGroup(x) = vgroup("Excitation",x); + freq = excitGroup(hslider("[0] Freq [style:knob]",330,50,2000,0.1)); + gain = excitGroup(vslider("[1] Gain",0.5,0,1,0.01) : si.smoo); +}; + +//-----------------`(no.)colored_noise`-------------------- +// A coloured noise signal generator. +// +// #### Usage +// +// ``` +// colored_noise_demo : _ +// ``` +// +//------------------------------------------------- +declare colored_noise author "Constantinos Odysseas Economou"; +declare colored_noise license "MIT"; + +colored_noise_demo = no.colored_noise(N,alpha) : *(ampdb) : *(gate) +with { + N = 12; + + alpha = hslider("[0] Alpha [style:knob] [tooltip: Spectral roll-off factor]", 0.0, -1.0, 1.0, 0.001) : si.smoo; + ampdb = hslider("[1] Amplitude [unit:dB] [style:knob] [tooltip: Noise amplitude]", -20, -120, 10, 0.1) : ba.db2linear : si.smoo; + gate = checkbox("[2] Gate"); +}; + +// end further contributions section diff --git a/dist/examples/LIBRARIES/dx7.lib b/dist/examples/LIBRARIES/dx7.lib new file mode 100644 index 00000000..9f4b6d33 --- /dev/null +++ b/dist/examples/LIBRARIES/dx7.lib @@ -0,0 +1,1034 @@ +//#################################### dx7.lib ######################################### +// Yamaha DX7 emulation library. Its official prefix is `dx`. +// +// #### References +// * +//######################################################################################## +// Yamaha DX7 emulation library. The various functions available in this library +// are used by the libraries generated from `.syx` DX7 preset files. This +// toolkit was greatly inspired by the CSOUND DX7 emulation package: +// . +// +// This library and its related tools are under development. Use it at your +// own risk! +//############################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +/* +TODO: + * LFO not implemented yet + * The whole system needs some tuning +*/ + +ba = library("basics.lib"); +en = library("envelopes.lib"); +ma = library("maths.lib"); +os = library("oscillators.lib"); + +//----------------------`(dx.)dx7_ampf`-------------------------- +// DX7 amplitude conversion function. 3 versions of this function +// are available: +// +// * `dx7_amp_bpf`: BPF version (same as in the CSOUND toolkit) +// * `dx7_amp_func`: estimated mathematical equivalent of `dx7_amp_bpf` +// * `dx7_ampf`: default (sugar for `dx7_amp_func`) +// +// #### Usage: +// +// ``` +// dx7AmpPreset : dx7_ampf_bpf : _ +// ``` +// +// Where: +// +// * `dx7AmpPreset`: DX7 amplitude value (0-99) +//---------------------------------------------------------- +// CSOUND function implemented as a BPF +// Corresponds to F2 in the CSOUND implementation. +dx7_amp_bpf = ba.bpf.start(0,0) : seq(i,14,ba.bpf.point(xPoints(i)+1,yPoints(i))) : ba.bpf.end(127,1) +with{ + xPoints(n) = ba.take(n+1,(9,19,29,39,49,59,64,69,74,79,84,89,94,98)); + yPoints(n) = ba.take(n+1,(0.000227445,0.000985595,0.002350265,0.005989386,0.014253222,0.033813495,0.052312358,0.080970432,0.124260804,0.190447309,0.295223654,0.457088704,0.70227445,1)); +}; +// Function estimated from the CSOUND function (default) +dx7_amp_func = min(98)/98 : pow(_,8); +dx7_ampf = dx7_amp_func; + +//----------------------`(dx.)dx7_egraterisef`-------------------------- +// DX7 envelope generator rise conversion function. 3 versions of this function +// are available: +// +// * `dx7_egraterise_bpf`: BPF version (same as in the CSOUND toolkit) +// * `dx7_egraterise_func`: estimated mathematical equivalent of `dx7_egraterise_bpf` +// * `dx7_egraterisef`: default (sugar for `dx7_egraterise_func`) +// +// #### Usage: +// +// ``` +// dx7envelopeRise : dx7_egraterisef : _ +// ``` +// +// Where: +// +// * `dx7envelopeRise`: DX7 envelope rise value (0-99) +//---------------------------------------------------------- +// CSOUND function implemented as a BPF +// Corresponds to F4 in the CSOUND implementation. +dx7_egraterise_bpf = ba.bpf.start(0,38) : seq(i,24,ba.bpf.point(xPoints(i)+1,yPoints(i))) : ba.bpf.end(127,0.003) +with{ + xPoints(n) = ba.take(n+1,(4,9,14,19,24,29,34,42,45,48,51,54,60,66,68,71,74,77, + 80,83,86,89,92,95)); + yPoints(n) = ba.take(n+1,(22.8,12,7.5,4.8,2.7,1.8,1.3,.737,.615, + .505,.409,.321,.080,.055,.032,.024,.018,.014,.011,.008,.008, + .007,.005,.003)); +}; +// Function estimated from the CSOUND function (default) +dx7_egraterise_func = 38*pow((127-_)/127,12) : max(0.003); +dx7_egraterisef = dx7_egraterise_func; + +//----------------------`(dx.)dx7_egraterisepercf`-------------------------- +// DX7 envelope generator percussive rise conversion function. 3 versions of +// this function are available: +// +// * `dx7_egrateriseperc_bpf`: BPF version (same as in the CSOUND toolkit) +// * `dx7_egrateriseperc_func`: estimated mathematical equivalent of `dx7_egrateriseperc_bpf` +// * `dx7_egraterisepercf`: default (sugar for `dx7_egrateriseperc_func`) +// +// #### Usage: +// +// ``` +// dx7envelopePercRise : dx7_egraterisepercf : _ +// ``` +// +// Where: +// +// * `dx7envelopePercRise`: DX7 envelope percussive rise value (0-99) +//---------------------------------------------------------- +// CSOUND function implemented as a BPF +// Corresponds to F5 in the CSOUND implementation. +dx7_egrateriseperc_bpf = ba.bpf.start(0,0.00001) : seq(i,10,ba.bpf.point(xPoints(i)+1,yPoints(i))) : ba.bpf.end(127,1) +with{ + xPoints(n) = ba.take(n+1,(30,34,39,49,59,69,79,89,94,98)); + yPoints(n) = ba.take(n+1,(0.00001,0.02,0.06,0.14,0.24,0.35,0.5,0.7,0.86,1)); +}; +// Function estimated from the CSOUND function (default) +dx7_egrateriseperc_func = >=(30)*min(_-30,68)/68 : pow(_,1.8); +dx7_egraterisepercf = dx7_egrateriseperc_func; + +//----------------------`(dx.)dx7_egratedecayf`-------------------------- +// DX7 envelope generator decay conversion function. 3 versions of +// this function are available: +// +// * `dx7_egratedecay_bpf`: BPF version (same as in the CSOUND toolkit) +// * `dx7_egratedecay_func`: estimated mathematical equivalent of `dx7_egratedecay_bpf` +// * `dx7_egratedecayf`: default (sugar for `dx7_egratedecay_func`) +// +// #### Usage: +// +// ``` +// dx7envelopeDecay : dx7_egratedecayf : _ +// ``` +// +// Where: +// +// * `dx7envelopeDecay`: DX7 envelope decay value (0-99) +//---------------------------------------------------------- +// CSOUND function implemented as a BPF +// Corresponds to F6 in the CSOUND implementation. +dx7_egratedecay_bpf = ba.bpf.start(0,318) : seq(i,23,ba.bpf.point(xPoints(i)+1,yPoints(i))) : ba.bpf.end(127,.008) +with{ + xPoints(n) = ba.take(n+1,(3,7,12,17,22,27,32,40,43,49,52,55,58,63,66,69,72,75, + 78,81,84,87,90)); + yPoints(n) = ba.take(n+1,(181,115,63,39.7,20,11.2,7,5.66,3.98,1.99, + 1.34,.99,.71,.41,.15,.081,.068,.047,.037,.025,.02,.013,.008)); +}; +// Function estimated from the CSOUND function (default) +dx7_egratedecay_func = 318*pow((127-_)/127,12.6) : max(0.008); +dx7_egratedecayf = dx7_egratedecay_func; + +//----------------------`(dx.)dx7_egratedecaypercf`-------------------------- +// DX7 envelope generator percussive decay conversion function. 3 versions of +// this function are available: +// +// * `dx7_egratedecayperc_bpf`: BPF version (same as in the CSOUND toolkit) +// * `dx7_egratedecayperc_func`: estimated mathematical equivalent of `dx7_egratedecayperc_bpf` +// * `dx7_egratedecaypercf`: default (sugar for `dx7_egratedecayperc_func`) +// +// #### Usage: +// +// ``` +// dx7envelopePercDecay : dx7_egratedecaypercf : _ +// ``` +// +// Where: +// +// * `dx7envelopePercDecay`: DX7 envelope decay value (0-99) +//---------------------------------------------------------- +// CSOUND function implemented as a BPF +// Corresponds to F7 in the CSOUND implementation. +dx7_egratedecayperc_bpf = ba.bpf.start(0,0.00001) : seq(i,10,ba.bpf.point(xPoints(i),yPoints(i))) : ba.bpf.end(127,1) +with{ + xPoints(n) = ba.take(n+1,(10,20,30,40,50,60,70,80,90,99)); + yPoints(n) = ba.take(n+1,(0.25,0.35,0.43,0.52,0.59,0.7,0.77,0.84,0.92,1)); +}; +// Function estimated from the CSOUND function (default) +dx7_egratedecayperc_func = min(99)/99 : pow(_,0.7); +dx7_egratedecaypercf = dx7_egratedecayperc_func; + +//----------------------`(dx.)dx7_eglv2peakf`-------------------------- +// DX7 envelope level to peak conversion function. 3 versions of +// this function are available: +// +// * `dx7_eglv2peak_bpf`: BPF version (same as in the CSOUND toolkit) +// * `dx7_eglv2peak_func`: estimated mathematical equivalent of `dx7_eglv2peak_bpf` +// * `dx7_eglv2peakf`: default (sugar for `dx7_eglv2peak_func`) +// +// #### Usage: +// +// ``` +// dx7Level : dx7_eglv2peakf : _ +// ``` +// +// Where: +// +// * `dx7Level`: DX7 level value (0-99) +//----------------------------------------------------------- +// CSOUND function implemented as a BPF +// Corresponds to F8 in the CSOUND implementation. +dx7_eglv2peak_bpf = ba.bpf.start(0,0) : seq(i,14,ba.bpf.point(xPoints(i)+1,yPoints(i))) : ba.bpf.end(127,2.08795) +with{ + xPoints(n) = ba.take(n+1,(9,19,29,39,49,59,64,59,74,79,84,89,94,98)); + yPoints(n) = ba.take(n+1,(0.000477,0.002,0.00493,0.01257,0.02992,0.07098,0.10981,0.16997,0.260855,0.39979,0.61974,0.95954,1.47425,2.08795)); +}; +// Function estimated from the CSOUND function (default) +dx7_eglv2peak_func = min(98)/98 : pow(_,8) : *(2.08795); +dx7_eglv2peakf = dx7_eglv2peak_func; + +//----------------------`(dx.)dx7_velsensf`-------------------------- +// DX7 velocity sensitivity conversion function. +// +// #### Usage: +// +// ``` +// dx7Velocity : dx7_velsensf : _ +// ``` +// +// Where: +// +// * `dx7Velocity`: DX7 level value (0-8) +//----------------------------------------------------------- +// Corresponds to F10 in the CSOUND implementation +dx7_velsensf = /(8); + +//----------------------`(dx.)dx7_fdbkscalef`-------------------------- +// DX7 feedback scaling conversion function. +// +// #### Usage: +// +// ``` +// dx7Feedback : dx7_fdbkscalef : _ +// ``` +// +// Where: +// +// * `dx7Feedback`: DX7 feedback value +//----------------------------------------------------------- +// Corresponds to F11 in the CSOUND implementation +dx7_fdbkscalef = *(0.875); + +//------------------------------`(dx.)dx7_op`--------------------------- +// DX7 Operator. Implements a phase-modulable sine wave oscillator connected +// to a DX7 envelope generator. +// +// #### Usage: +// +// ``` +// dx7_op(freq,phaseMod,outLev,R1,R2,R3,R4,L1,L2,L3,L4,keyVel,rateScale,type,gain,gate) : _ +// ``` +// +// Where: +// +// * `freq`: frequency of the oscillator +// * `phaseMod`: phase deviation (-1 - 1) +// * `outLev`: preset output level (0-99) +// * `R1`: preset envelope rate 1 (0-99) +// * `R2`: preset envelope rate 2 (0-99) +// * `R3`: preset envelope rate 3 (0-99) +// * `R4`: preset envelope rate 4 (0-99) +// * `L1`: preset envelope level 1 (0-99) +// * `L2`: preset envelope level 2 (0-99) +// * `L3`: preset envelope level 3 (0-99) +// * `L4`: preset envelope level 4 (0-99) +// * `keyVel`: preset key velocity sensitivity (0-99) +// * `rateScale`: preset envelope rate scale +// * `type`: preset operator type +// * `gain`: general gain +// * `gate`: trigger signal +//----------------------------------------------------------------- +dx7_op(freq,phaseMod,outLev,R1,R2,R3,R4,L1,L2,L3,L4,keyVel,rateScale,type,gain,gate) = +(en.dx7envelope(egr1,egr2,egr3,egr4,egl1,egl2,egl3,egl4,gate) : envTable)*sineWave +with{ + tablesize = 1 << 16; + // phase modulation, not freq modulation + sineWave = rdtable(tablesize, os.sinwaveform(tablesize), ma.modulo(int(os.phasor(tablesize,freq) + phaseMod*tablesize),tablesize)); + amp = outLev/99; // the corresponding "CSOUND table" has just been hardcoded here + // computing levels + vFac = keyVel : dx7_velsensf; + egl1 = L1*amp <: *(1-vFac) + *(vFac*gain); + egl2 = L2*amp <: *(1-vFac) + *(vFac*gain); + egl3 = L3*amp <: *(1-vFac) + *(vFac*gain); + egl4 = L4*amp <: *(1-vFac) + *(vFac*gain); + // computing rates + rs = (freq : ba.hz2midikey)-21 : /(105)*6*rateScale; + egr1 = R1+rs : min(99) <: + select2(egl1>egl4,dx7_egratedecayf,dx7_egraterisef) <: + *(egl4 <: select2(egl1>egl4,dx7_egratedecaypercf,dx7_egraterisepercf)), + *(egl1 <: select2(egl1>egl4,dx7_egratedecaypercf,dx7_egraterisepercf)) : + - : abs : max(0.001); + egr2 = R2+rs : min(99) <: + select2(egl2>egl1,dx7_egratedecayf,dx7_egraterisef) <: + *(egl2 <: select2(egl2>egl1,dx7_egratedecaypercf,dx7_egraterisepercf)), + *(egl1 <: select2(egl2>egl1,dx7_egratedecaypercf,dx7_egraterisepercf)) : + - : abs : max(0.001); + egr3 = R3+rs : min(99) <: + select2(egl3>egl2,dx7_egratedecayf,dx7_egraterisef) <: + *(egl2 <: select2(egl3>egl2,dx7_egratedecaypercf,dx7_egraterisepercf)), + *(egl3 <: select2(egl3>egl2,dx7_egratedecaypercf,dx7_egraterisepercf)) : + - : abs : max(0.001); + egr4 = R4+rs : min(99) <: + select2(egl3<=egl4,dx7_egratedecayf,dx7_egraterisef) <: + *(egl3 <: select2(egl3<=egl4,dx7_egratedecaypercf,dx7_egraterisepercf)), + *(egl4 <: select2(egl3<=egl4,dx7_egratedecaypercf,dx7_egraterisepercf)) : + - : abs : max(0.001); + envTable = _ <: select2(type,dx7_eglv2peakf,dx7_ampf); +}; + +//------------------------------`(dx.)dx7_algo`--------------------------- +// DX7 algorithms. Implements the 32 DX7 algorithms (a quick Google search +// should give your more details on this). Each algorithm uses 6 operators. +// +// #### Usage: +// +// ``` +// dx7_algo(algN,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) : _ +// ``` +// +// Where: +// +// * `algN`: algorithm number (0-31, should be an int...) +// * `egR1`: preset envelope rates 1 (a list of 6 values between 0-99) +// * `egR2`: preset envelope rates 2 (a list of 6 values between 0-99) +// * `egR3`: preset envelope rates 3 (a list of 6 values between 0-99) +// * `egR4`: preset envelope rates 4 (a list of 6 values between 0-99) +// * `egL1`: preset envelope levels 1 (a list of 6 values between 0-99) +// * `egL2`: preset envelope levels 2 (a list of 6 values between 0-99) +// * `egL3`: preset envelope levels 3 (a list of 6 values between 0-99) +// * `egL4`: preset envelope levels 4 (a list of 6 values between 0-99) +// * `outLev`: preset output levels (a list of 6 values between 0-99) +// * `keyVel`: preset key velocity sensitivities (a list of 6 values between 0-99) +// * `ampModSens`: preset amplitude sensitivities (a list of 6 values between 0-99) +// * `opMode`: preset operator mode (a list of 6 values between 0-1) +// * `opFreq`: preset operator frequencies (a list of 6 values between 0-99) +// * `opDetune`: preset operator detuning (a list of 6 values between 0-99) +// * `opRateScale`: preset operator rate scale (a list of 6 values between 0-99) +// * `feedback`: preset operator feedback (a list of 6 values between 0-99) +// * `lfoDelay`: preset LFO delay (a list of 6 values between 0-99) +// * `lfoDepth`: preset LFO depth (a list of 6 values between 0-99) +// * `lfoSpeed`: preset LFO speed (a list of 6 values between 0-99) +// * `freq`: fundamental frequency +// * `gain`: general gain +// * `gate`: trigger signal +//----------------------------------------------------------------- + +// Alg 1 +// NOTE: the .2 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(0,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op6~*(feedback*.2) : op5 : op4 : op3) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 2 +// NOTE: the .2 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(1,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2~*(feedback*.2) : op1),(op6 : op5 : op4 : op3) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 3 +// Note: weird rand and delay implemented in the csound orchestra and not +// really sure why... +dx7_algo(2,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op3 : op2 : op1),(op6~*(feedback) : op5 : op4) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 4 +dx7_algo(3,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op3 : op2 : op1),(op6 : op5 : op4)~*(feedback) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 5 +// NOTE: the .1 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(4,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op4 : op3),(op6~*(feedback*.1) : op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 6 +dx7_algo(5,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op4 : op3),(op6 : op5)~*(feedback) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 7 +dx7_algo(6,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op4,(op6~*(feedback) : op5) :> op3) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 8 +// NOTE: the .1 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(7,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op4~*(feedback*.1),(op6 : op5) :> op3) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 9 +// NOTE: the .4 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(8,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2~*(feedback*.4) : op1),(op4,(op6 : op5) :> op3) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 10 +// NOTE: the .2 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(9,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op5,op6 :> op4),(op3~*(feedback*.2) : op2 : op1) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 11 +// NOTE: the .2 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(10,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op5,op6~*(feedback*.2) :> op4),(op3 : op2 : op1) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 12 +// NOTE: the .2 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(11,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op4,op5,op6 :> op3),(op2~*(feedback*.2) : op1) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 13 +dx7_algo(12,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op4,op5,op6~*(feedback) :> op3),(op2 : op1) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 14 +dx7_algo(13,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op5,op6~*(feedback) :> op4 : op3) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 15 +// NOTE: the .4 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(14,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2~*(feedback*.4) : op1),(op5,op6 :> op4 : op3) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 16 +dx7_algo(15,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op2,(op4 : op3),(op6~*(feedback) : op5) :> op1 +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 17 +// NOTE: the .5 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(16,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op2~*(feedback*.5),(op4 : op3),(op6 : op5) :> op1 +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 18 +dx7_algo(17,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op2,op3~*(feedback),(op6 : op5 : op4) :> op1 +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 19 +// NOTE: the .4 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(18,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op3 : op2 : op1),(op6~*(feedback*.4) <: op4,op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 20 +dx7_algo(19,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op3~*(feedback) <: op1,op2),(op5,op6 :> op4) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 21 +dx7_algo(20,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op3~*(feedback) <: op1,op2),(op6 <: op4,op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 22 +// NOTE: the .1 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(21,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op6~*(feedback*.1) <: op3,op4,op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 23 +dx7_algo(22,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,(op3 : op2),(op6~*(feedback) <: op4,op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 24 +// NOTE: the .6 for feedback was hardcoded in the csound orchestra, not sure why +// we need it +dx7_algo(23,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,op2,(op6~*(feedback*.6) <: op3,op4,op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 25 +dx7_algo(24,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,op2,op3,(op6~*(feedback) <: op4,op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 26 +dx7_algo(25,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,(op3 : op2),(op5,op6~*(feedback) :> op4) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 27 +dx7_algo(26,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,(op3~*(feedback) : op2),(op5,op6 :> op4) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),1,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,_,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 28 +dx7_algo(27,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +(op2 : op1),(op5~*(feedback) : op4 : op3),op6 :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),0,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),1,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,_,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 29 +dx7_algo(28,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,op2,(op4 : op3),(op6~*(feedback) : op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 30 +dx7_algo(29,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,op2,(op5~*(feedback) : op4 : op3),op6 :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),0,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),1,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,_,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),1,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,_,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 31 +dx7_algo(30,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,op2,op3,op4,(op6~*(feedback) : op5) :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,_,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),1,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,_,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +// Alg 32 +dx7_algo(31,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) = +op1,op2,op3,op4,op5,op6 :> _ +with{ + op6Freq = select2(opMode(5),opFreq(5)*freq,opFreq(5)) + opDetune(5)/4; + op6 = dx7_op(op6Freq,0,outLevel(5),egR1(5),egR2(5),egR3(5),egR4(5),egL1(5),egL2(5),egL3(5),egL4(5),keyVelSens(5),opRateScale(5),0,gain,gate); + op5Freq = select2(opMode(4),opFreq(4)*freq,opFreq(4)) + opDetune(4)/4; + op5 = dx7_op(op5Freq,0,outLevel(4),egR1(4),egR2(4),egR3(4),egR4(4),egL1(4),egL2(4),egL3(4),egL4(4),keyVelSens(4),opRateScale(4),0,gain,gate); + op4Freq = select2(opMode(3),opFreq(3)*freq,opFreq(3)) + opDetune(3)/4; + op4 = dx7_op(op4Freq,0,outLevel(3),egR1(3),egR2(3),egR3(3),egR4(3),egL1(3),egL2(3),egL3(3),egL4(3),keyVelSens(3),opRateScale(3),0,gain,gate); + op3Freq = select2(opMode(2),opFreq(2)*freq,opFreq(2)) + opDetune(2)/4; + op3 = dx7_op(op3Freq,0,outLevel(2),egR1(2),egR2(2),egR3(2),egR4(2),egL1(2),egL2(2),egL3(2),egL4(2),keyVelSens(2),opRateScale(2),0,gain,gate); + op2Freq = select2(opMode(1),opFreq(1)*freq,opFreq(1)) + opDetune(1)/4; + op2 = dx7_op(op2Freq,0,outLevel(1),egR1(1),egR2(1),egR3(1),egR4(1),egL1(1),egL2(1),egL3(1),egL4(1),keyVelSens(1),opRateScale(1),0,gain,gate); + op1Freq = select2(opMode(0),opFreq(0)*freq,opFreq(0)) + opDetune(0)/4; + op1 = dx7_op(op1Freq,0,outLevel(0),egR1(0),egR2(0),egR3(0),egR4(0),egL1(0),egL2(0),egL3(0),egL4(0),keyVelSens(0),opRateScale(0),0,gain,gate); +}; + +//------------------------------`(dx.)dx7_ui`--------------------------- +// Generic DX7 function where all parameters are controllable using UI elements. +// The `master-with-mute` branch must be used for this function to work... +// This function is MIDI-compatible. +// +// #### Usage +// +// ``` +// dx7_ui : _ +// ``` +//----------------------------------------------------------------- +dx7_ui = +par(i,32,dx7_algo(i,egR1,egR2,egR3,egR4,egL1,egL2,egL3,egL4,outLevel,keyVelSens,ampModSens,opMode,opFreq,opDetune,opRateScale,feedback,lfoDelay,lfoDepth,lfoSpeed,freq,gain,gate) : control(algorithm == i)) :> _ +with{ + algorithm = nentry("h:dx7/v:global/[0]algorithm",0,0,31,1) : int; + feedback = nentry("h:dx7/v:global/[1]feedback",0,0,99,1) : dx7_fdbkscalef/(2*ma.PI); + lfoDelay = nentry("h:dx7/v:global/[2]lfoDelay",0,0,99,1); + lfoDepth = nentry("h:dx7/v:global/[3]lfoDepth",0,0,99,1); + lfoSpeed = nentry("h:dx7/v:global/[4]lfoSpeed",0,0,99,1); + freq = hslider("h:dx7/v:global/[5]freq",400,50,1000,0.01); + gain = hslider("h:dx7/v:global/[6]gain",0.8,0,1,0.01); + gate = button("h:dx7/v:global/[7]gate"); + egR1UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[0]egR1",90,0,99,1)); + egR1(n) = ba.take(n+1,egR1UI); + egR2UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[1]egR2",90,0,99,1)); + egR2(n) = ba.take(n+1,egR2UI); + egR3UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[2]egR3",90,0,99,1)); + egR3(n) = ba.take(n+1,egR3UI); + egR4UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[3]egR4",90,0,99,1)); + egR4(n) = ba.take(n+1,egR4UI); + egL1UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[4]egL1",0,0,99,1)); + egL1(n) = ba.take(n+1,egL1UI); + egL2UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[5]egL2",90,0,99,1)); + egL2(n) = ba.take(n+1,egL2UI); + egL3UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[6]egL3",90,0,99,1)); + egL3(n) = ba.take(n+1,egL3UI); + egL4UI = par(i,6,nentry("h:dx7/v:[%i]op%i/[7]egL4",0,0,99,1)); + egL4(n) = ba.take(n+1,egL4UI); + outLevelUI = par(i,6,nentry("h:dx7/v:[%i]op%i/[8]level",95,0,99,1)); + outLevel(n) = ba.take(n+1,outLevelUI); + keyVelSensUI = par(i,6,nentry("h:dx7/v:[%i]op%i/[9]keyVelSens",1,0,8,1)); + keyVelSens(n) = ba.take(n+1,keyVelSensUI); + ampModSensUI = par(i,6,nentry("h:dx7/v:[%i]op%i/[10]ampModSens",0,0,99,1)); + ampModSens(n) = ba.take(n+1,ampModSensUI); + opModeUI = par(i,6,nentry("h:dx7/v:[%i]op%i/[11]opMode",0,0,1,1)); + opMode(n) = ba.take(n+1,opModeUI); + opFreqUI = par(i,6,nentry("h:dx7/v:[%i]op%i/[12]opFreq",1.0,0.0,2.0,0.01)); + opFreq(n) = ba.take(n+1,opFreqUI); + opDetuneUI = par(i,6,nentry("h:dx7/v:[%i]op%i/[13]opDetune",1,-10,10,1)); + opDetune(n) = ba.take(n+1,opDetuneUI); + opRateScaleUI = par(i,6,nentry("h:dx7/v:[%i]op%i/[14]opRateScale",0,0,10,1)); + opRateScale(n) = ba.take(n+1,opRateScaleUI); +}; diff --git a/dist/examples/LIBRARIES/envelopes.lib b/dist/examples/LIBRARIES/envelopes.lib new file mode 100644 index 00000000..605be1a1 --- /dev/null +++ b/dist/examples/LIBRARIES/envelopes.lib @@ -0,0 +1,413 @@ +//################################ envelopes.lib ########################################## +// This library contains a collection of envelope generators. Its official prefix is `en`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +ba = library("basics.lib"); +si = library("signals.lib"); + +declare name "Faust Envelope Library"; +declare version "0.2"; +declare author "GRAME"; +declare copyright "GRAME"; +declare license "LGPL with exception"; + +//=============================Functions Reference======================================== +//======================================================================================== + +//-----------------------`(en.)ar`-------------------------- +// AR (Attack, Release) envelope generator (useful to create percussion envelopes). +// `ar` is a standard Faust function. +// +// #### Usage +// +// ``` +// ar(at,rt,t) : _ +// ``` +// +// Where: +// +// * `at`: attack (sec) +// * `rt`: release (sec) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare ar author "Yann Orlarey, Stéphane Letz"; +ar(at,rt,gate) = AR : max(0) +with { + + // Durations in samples + an = max(1, at*ma.SR); + rn = max(1, rt*ma.SR); + + // Deltas per samples + adelta = 1/an; + rdelta = 1/rn; + + // Attack time (starts at gate upfront and raises infinitely) + atime = (raise*reset + upfront) ~ _ + with { + upfront = gate > gate'; + reset = gate <= gate'; + raise(x) = (x + (x > 0)); + }; + + // Attack curve + A = atime * adelta; + + // Release curve + D0 = 1 + an * rdelta; + D = D0 - atime * rdelta; + + // AR part + AR = min(A, D); + +}; + + +//------------------------`(en.)asr`---------------------- +// ASR (Attack, Sustain, Release) envelope generator. +// `asr` is a standard Faust function. +// +// #### Usage +// +// ``` +// asr(at,sl,rt,t) : _ +// ``` +// +// Where: +// +// * `at`: attack (sec) +// * `sl`: sustain level (between 0..1) +// * `rt`: release (sec) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare asr author "Yann Orlarey, Stéphane Letz"; +asr(at,sl,rt,gate) = AS - R : max(0) +with { + + // Durations in samples + an = max(1, at*ma.SR); + rn = max(1, rt*ma.SR); + + // Deltas per samples + adelta = sl/an; + rdelta = sl/rn; + + // Attack time (starts when gate changes and raises until gate == 0) + atime = +(gate) ~ *(gate' >= gate); + + // Attack curve + A = atime * adelta; + + // AS part + AS = min(A, sl); + + // Release time starts when gate is 0 + rtime = (+(1) : *(gate == 0)) ~ _; + + // Release curve starts when gate is 0 with the current value of the envelope + R = rtime * rdelta; + +}; + + +//------------------------`(en.)adsr`---------------------- +// ADSR (Attack, Decay, Sustain, Release) envelope generator. +// `adsr` is a standard Faust function. +// +// #### Usage +// +// ``` +// adsr(at,dt,sl,rt,t) : _ +// ``` +// +// Where: +// +// * `at`: attack time (sec) +// * `dt`: decay time (sec) +// * `sl`: sustain level (between 0..1) +// * `rt`: release time (sec) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare adsr author "Yann Orlarey and Andrey Bundin"; +adsr(at,dt,sl,rt,gate) = ADS : *(1-R) : max(0) +with { + + // Durations in samples + an = max(1, at*ma.SR); + dn = max(1, dt*ma.SR); + rn = max(1, rt*ma.SR); + + // Deltas per samples + adelta = 1/an; + ddelta = (1-sl)/dn; + + // Attack time (starts when gate changes and raises until gate == 0) + atime = +(gate) ~ *(gate' >= gate); + + // Attack curve + A = atime * adelta; + + // Decay curve + D0 = 1 + an * ddelta; + D = D0 - atime * ddelta; + + // ADS part + ADS = min(A, max(D, sl)); + + // Release time starts when gate is 0 + rtime = (+(1) : *(gate == 0)) ~ _; + + // Release curve starts when gate is 0 with the current value of the envelope + R = rtime/rn; + +}; + + +//------------------------`(en.)smoothEnvelope`------------------------ +// An envelope with an exponential attack and release. +// `smoothEnvelope` is a standard Faust function. +// +// #### Usage +// +// ``` +// smoothEnvelope(ar,t) : _ +// ``` +// +// * `ar`: attack and release duration (sec) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//---------------------------------------------------------------- +declare smoothEnvelope author "Romain Michon"; +smoothEnvelope(ar,t) = t : si.smooth(ba.tau2pole(ar)); + +// Generic form to be specialized +// Author: JOS, revised by Stephane Letz +asrfe(attT60,susLvl,relT60,finLvl,gate) = envelope +with { + ugate = gate>0; + target = select2(ugate, finLvl, susLvl*float(ugate)); + t60 = select2(ugate, relT60, attT60); + pole = ba.tau2pole(t60/6.91); + envelope = target : si.smooth(pole); +}; + + +//------------------------`(en.)arfe`---------------------- +// ARFE (Attack and Release-to-Final-value Exponentially) envelope generator. +// Approximately equal to `smoothEnvelope(Attack/6.91)` when Attack == Release. +// +// #### Usage +// +// ``` +// arfe(at,rt,fl,t) : _ +// ``` +// +// Where: +// +// * `at`: attack (sec) +// * `rt`: release (sec) +// * `fl`: final level to approach upon release (such as 0) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare arfe author "Julius O. Smith III, revised by Stephane Letz"; +declare arfe licence "STK-4.3"; + +arfe(attT60,relT60,fv,gate) = asrfe(attT60,1.0,relT60,fv,gate); + + +//------------------------`(en.)are`---------------------- +// ARE (Attack, Release) envelope generator with Exponential segments. +// Approximately equal to `smoothEnvelope(Attack/6.91)` when Attack == Release. +// +// #### Usage +// +// ``` +// are(at,rt,t) : _ +// ``` +// +// Where: +// +// * `at`: attack (sec) +// * `rt`: release (sec) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare are author "Julius O. Smith III, revised by Stephane Letz"; +declare are licence "STK-4.3"; + +are(attT60,relT60,gate) = asrfe(attT60,1.0,relT60,0.0,gate); + + +//------------------------`(en.)asre`---------------------- +// ASRE (Attack, Sustain, Release) envelope generator with Exponential segments. +// +// #### Usage +// +// ``` +// asre(at,sl,rt,t) : _ +// ``` +// +// Where: +// +// * `at`: attack (sec) +// * `sl`: sustain level (between 0..1) +// * `rt`: release (sec) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare asre author "Julius O. Smith III, revised by Stephane Letz"; +declare asre licence "STK-4.3"; + +asre(attT60,susLvl,relT60,gate) = asrfe(attT60,susLvl,relT60,0.0,gate); + + +//------------------------`(en.)adsre`---------------------- +// ADSRE (Attack, Decay, Sustain, Release) envelope generator with Exponential +// segments. +// +// #### Usage +// +// ``` +// adsre(at,dt,sl,rt,t) : _ +// ``` +// +// Where: +// +// * `at`: attack (sec) +// * `dt`: decay (sec) +// * `sl`: sustain level (between 0..1) +// * `rt`: release (sec) +// * `t`: trigger signal (attack is triggered when `t>0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare adsre author "Julius O. Smith III"; +declare adsre licence "STK-4.3"; + +adsre(attT60,decT60,susLvl,relT60,gate) = envelope +with { + ugate = gate>0; + samps = ugate : +~(*(ugate)); // ramp time in samples + attSamps = int(attT60 * ma.SR); + // if attSamps==0, go straight into the decay phase + attPhase = (samps0`, release is triggered +// when `t=0`) +//----------------------------------------------------- +declare ahdsre author "Julius O. Smith III, David Braun"; +declare ahdsre licence "STK-4.3"; + +ahdsre(attT60,htT60,decT60,susLvl,relT60,gate) = envelope +with { + ugate = gate>0; + samps = ugate : +~(*(ugate)); // ramp time in samples + attSamps = int(attT60 * ma.SR); + holdSamps = int((attT60+htT60)*ma.SR); + attPhase = (samps0; + off = t==0; + rs1 = R1*ma.SR; + rs2 = R2*ma.SR; + rs3 = R3*ma.SR; + rs4 = R4*ma.SR; + up = ba.countup(rs1+rs2+rs3,off) : ba.bpf.start(0,L4) : ba.bpf.point(rs1,L1) : + ba.bpf.point(rs1+rs2,L2) : ba.bpf.end(rs1+rs2+rs3,L3); + down = _,ba.countup(rs4,on) : ba.bpf.start(0) : ba.bpf.end(rs4,L4); +}; diff --git a/dist/examples/LIBRARIES/fds.lib b/dist/examples/LIBRARIES/fds.lib new file mode 100644 index 00000000..cf0ce3a2 --- /dev/null +++ b/dist/examples/LIBRARIES/fds.lib @@ -0,0 +1,535 @@ +//############################# fds.lib ###################################### + +// This library allows to build linear, explicit finite difference schemes +// physical models in 1 or 2 dimensions using an approach based on the cellular +// automata formalism. Its official prefix is `fd`. +// +// In order to use the library, one needs to discretize the linear partial +// differential equation of the desired system both at boundaries and in-between +// them, thus obtaining a set of explicit recursion relations. Each one +// of these will provide, for each spatial point the scalar coefficients to be +// multiplied by the states of the current and past neighbour points. +// +// Coefficients need to be stacked in parallel in order to form a coefficients +// matrix for each point in the mesh. It is necessary to provide one matrix for +// coefficients matrices are defined, they need to be placed in parallel and +// ordered following the desired mesh structure (i.e., coefficients for the top +// left boundaries will come first, while bottom right boundaries will come +// last), to form a *coefficients scheme*, which can be used with the library +// functions. + +// ## Sources + +// Here are listed some works on finite difference schemes and cellular +// automata thet were the basis for the implementation of this library +// +// * S. Bilbao, Numerical Sound Synthesis.Chichester, UK: John Wiley Sons, +// Ltd, 2009 + +// * P. Narbel, "Qualitative and quantitative cellular automata from +// differential equations," Lecture Notes in Computer Science, vol. 4173, +// pp. 112–121, 10 2006 + +// * X.-S. Yang and Y. Young, Cellular Automata, PDEs, and Pattern Formation. +// Chapman & Hall/CRC, 092005, ch. 18, pp. 271–282. +// +// #### References +// * +//############################################################################# + +ba = library("basics.lib"); +si = library("signals.lib"); +ma = library("maths.lib"); + +declare name "Faust Finite Difference Schemes Library"; +declare version "0.0"; +declare author "Riccardo Russo"; +declare author "Romain Michon"; + +/* +TODO: + - In case of big 2-D meshes the generated c++ code is too long, making the + compiler crash. Consider introducing data structures support. + - Implement a way to set nonzero initial conditions. + - It would be nice to set the length of a mesh directly in meters and not + in points. + - Cubic interpolators. +*/ + +//===============================Model Construction============================= +// Once the coefficients scheme is defined, the user can simply call one of +// these functions to obtain a fully working physical model. They expect to +// receive a force input signal for each mesh point and output the state of each +// point. Interpolation operators can be used to drive external forces to the +// desired points, and to get the signal only from a certain area of the mesh. +//============================================================================== + +//--------------------------------`(fd.)model1D`------------------------------- +// This function can be used to obtain a physical model in 1 dimension. +// Takes a force input signal for each point and outputs the state of each +// point. +// +// #### Usage +// +// ``` +// si.bus(points) : model1D(points,R,T,scheme) : si.bus(points) +// ``` +// +// Where: +// +// * `points`: size of the mesh in points +// * `R`: neighbourhood radius, indicates how many side points are needed (i.e. +// if R=1 the mesh depends on one point on the left and one on the right) +// * `T`: time coefficient, indicates how much steps back in time are needed (i. +// e. if T=1 the maximum delay needed for a neighbour state is 1 sample) +// * `scheme`: coefficients scheme +//------------------------------------------------------------------------------ +model1D(points,R,T,scheme) = + (route1D(points,R,T,scheme) : buildScheme1D(points,R,T)) ~ si.bus(points); + +//--------------------------------`(fd.)model2D`------------------------------- +// This function can be used to obtain a physical model in 2 dimension. +// Takes a force input signal for each point and outputs the state of each +// point. +// IMPORTANT: 2D models with more than 30x20 points might crash the c++ +// compiler. 2D models need to be compiled with the command line compiler, +// the online one presents some issues. +// +// #### Usage +// +// ``` +// si.bus(pointsX*pointsY) : model2D(pointsX,pointsY,R,T,scheme) : +// si.bus(pointsX*pointsY) +// ``` +// +// Where: +// +// * `pointsX`: horizontal size of the mesh in points +// * `pointsY`: vertical size of the mesh in points +// * `R`: neighbourhood radius, indicates how many side points are needed (i.e. +// if R=1 the mesh depends on one point on the left and one on the right) +// * `T`: time coefficient, indicates how much steps back in time are needed (i. +// e. if T=1 the maximum delay needed for a neighbour state is 1 sample) +// * `scheme`: coefficients scheme +//------------------------------------------------------------------------------ +model2D(pointsX,pointsY,R,T,scheme) = + (route2D(pointsX,pointsY,R,T,scheme) : + buildScheme2D(pointsX,pointsY,R,T)) ~ si.bus(pointsX*pointsY); + +//===============================Interpolation================================= +// Interpolation functions can be used to drive the input signals to the +// correct mesh points, or to get the output signal from the +// desired points. All the interpolation functions allow to change the +// input/output points at run time. In general, all these functions get in +// input a number of connections, and output the same number of connections, +// where each signal is multiplied by zero except the ones specified by the +// arguments. +//============================================================================== + +//-----------------------------`(fd.)stairsInterp1D`--------------------------- +// Stairs interpolator in 1 dimension. Takes a number of signals and outputs +// the same number of signals, where each one is multiplied by zero except the +// one specified by the argument. This can vary at run time (i.e. a slider), +// but must be an integer. +// +// #### Usage +// +// ``` +// si.bus(points) : stairsInterp1D(points,point) : si.bus(points) +// ``` +// +// Where: +// +// * `points`: total number of points in the mesh +// * `point`: number of the desired nonzero signal +//------------------------------------------------------------------------------ +stairsInterp1D(points,point) = par(i,points,_*select2(i==point,0,1)); + +//-----------------------------`(fd.)stairsInterp2D`--------------------------- +// Stairs interpolator in 2 dimensions. Similar to the 1-D version. +// +// #### Usage +// +// ``` +// si.bus(pointsX*pointsY) : stairsInterp2D(pointsX,pointsY,pointX,pointY) : +// si.bus(pointsX*pointsY) +// ``` +// +// Where: +// +// * `pointsX`: total number of points in the X direction +// * `pointsY`: total number of points in the Y direction +// * `pointX`: horizontal index of the desired nonzero signal +// * `pointY`: vertical index of the desired nonzero signal +//------------------------------------------------------------------------------ +stairsInterp2D(pointsX,pointsY,pointX,pointY) = + par(i,pointsX, + par(j,pointsY,_*select2((i==pointX) & (j==pointY),0,1))); + +//-----------------------------`(fd.)linInterp1D`--------------------------- +// Linear interpolator in 1 dimension. Takes a number of signals and outputs +// the same number of signals, where each one is multiplied by zero except two +// signals around a floating point index. This is essentially a Faust +// implementation of the $J(x_i)$ operator, not scaled by the spatial step. +// (see Stefan Bilbao's book, Numerical Sound Synthesis). The index can vary +// at run time. +// +// #### Usage +// +// ``` +// si.bus(points) : linInterp1D(points,point) : si.bus(points) +// ``` +// +// Where: +// +// * `points`: total number of points in the mesh +// * `point`: floating point index +//------------------------------------------------------------------------------ +linInterp1D(points,point) = par(i,points,_*select2( + i==int(point), select2(i==int(point+1),0,fraction),(1-fraction))) +with +{ + fraction = ma.frac(point); +}; + +//-----------------------------`(fd.)linInterp2D`--------------------------- +// Linear interpolator in 2 dimensions. Similar to the 1 D version. +// +// #### Usage +// +// ``` +// si.bus(pointsX*pointsY) : linInterp2D(pointsX,pointsY,pointX,pointY) : +// si.bus(pointsX*pointsY) +// ``` +// +// Where: +// +// * `pointsX`: total number of points in the X direction +// * `pointsY`: total number of points in the Y direction +// * `pointX`: horizontal float index +// * `pointY`: vertical float index +//------------------------------------------------------------------------------ +linInterp2D(pointsX,pointsY,pointX,pointY) = +par(i,pointsX, + par(j,pointsY,_* + select2((i==intX) & (j==intY), + select2((i==(intX+1)) & (j==intY), + select2((i==intX) & (j==(intY+1)), + select2((i==(intX+1)) & (j==(intY+1)), + 0, + fractionX*fractionY), + (1-fractionX)*fractionY), + fractionX*(1-fractionY)), + (1-fractionX)*(1-fractionY)))) +with +{ + fractionX = ma.frac(pointX); + fractionY = ma.frac(pointY); + intX = int(pointX); + intY = int(pointY); +}; + +//---------------------------`(fd.)stairsInterp1DOut`-------------------------- +// Stairs interpolator in 1 dimension. Similar to `stairsInterp1D`, except it +// outputs only the desired signal. +// +// #### Usage +// +// ``` +// si.bus(points) : stairsInterp1DOut(points,point) : _ +// ``` +// +// Where: +// +// * `points`: total number of points in the mesh +// * `point`: number of the desired nonzero signal +//------------------------------------------------------------------------------ +stairsInterp1DOut(points,point) = ba.selectn(points,point); + +//---------------------------`(fd.)stairsInterp2DOut`-------------------------- +// Stairs interpolator in 2 dimensions which outputs only one signal. +// +// #### Usage +// +// ``` +// si.bus(pointsX*pointsY) : stairsInterp2DOut(pointsX,pointsY,pointX,pointY) : _ +// ``` +// +// Where: +// +// * `pointsX`: total number of points in the X direction +// * `pointsY`: total number of points in the Y direction +// * `pointX`: horizontal index of the desired nonzero signal +// * `pointY`: vertical index of the desired nonzero signal +//------------------------------------------------------------------------------ +stairsInterp2DOut(pointsX,pointsY,pointX,pointY) = + ba.selectn(pointsX*pointsY,pointY+pointX*Y); + +//---------------------------`(fd.)linInterp1DOut`-------------------------- +// Linear interpolator in 1 dimension. Similar to `stairsInterp1D`, except it +// sums each output signal and provides only one output value. +// +// #### Usage +// +// ``` +// si.bus(points) : linInterp1DOut(points,point) : _ +// ``` +// +// Where: +// +// * `points`: total number of points in the mesh +// * `point`: floating point index +//------------------------------------------------------------------------------ +linInterp1DOut(points,point) = linInterp1D(points,point):>_; + +//---------------------------`(fd.)stairsInterp2DOut`-------------------------- +// Linear interpolator in 2 dimensions which outputs only one signal. +// +// #### Usage +// +// ``` +// si.bus(pointsX*pointsY) : linInterp2DOut(pointsX,pointsY,pointX,pointY) : _ +// ``` +// +// Where: +// +// * `pointsX`: total number of points in the X direction +// * `pointsY`: total number of points in the Y direction +// * `pointX`: horizontal float index +// * `pointY`: vertical float index +//------------------------------------------------------------------------------ +linInterp2DOut(pointsX,pointsY,pointX,pointY) = + linInterp2D(pointsX,pointsY,pointX,pointY):>_; + +//====================================Routing================================== +// The routing functions are used internally by the model building functions, +// but can also be taken separately. These functions route the forces, the +// coefficients scheme and the neighbours’ signals into the correct scheme +// points and take as input, in this order: the coefficients block, the +// feedback signals and the forces. In output they provide, in order, for each +// scheme point: the force signal, the coefficient matrices and the neighbours’ +// signals. These functions are based on the Faust route primitive. +//============================================================================== + +//---------------------------------`(fd.)route1D`------------------------------ +// Routing function for 1 dimensional schemes. +// +// #### Usage +// +// ``` +// si.bus((2*R+1)*(T+1)*points),si.bus(points*2) : route1D(points, R, T) : +// si.bus((1 + ((2*R+1)*(T+1)) + (2*R+1))*points) +// ``` +// +// Where: +// +// * `points`: total number of points in the mesh +// * `R`: neighbourhood radius +// * `T`: time coefficient +//------------------------------------------------------------------------------ +route1D(points, R, T) = route(points*2+points*nCoeffs, points*nInputs, + par(x, points, connections(x))) +with +{ + connections(x) = par(k,nCoeffs,x*nCoeffs+k+1,C(x,k+1)), + P(x) + points, C(x,0), + par(i, nNeighbors, P(x),C(x-R+i,nInputs-1-i)); + + P(x) = x+1 + nCoeffs*points; + C(x,count) = (1 + count + (x*nInputs)) * (x>=0) * (x=0) * (x=0) * (y_ +with +{ + nNeighbors = (2*R+1)^D; + routing = + route(nNeighbors*(T+1)+nNeighbors+1,2*nNeighbors*(T+1)+1, + (1,1), + par(t,T+1, + par(i,nNeighbors,i+t*nNeighbors+2,2*(i+t*nNeighbors)+3, + i+nNeighbors*(T+1)+2,2*(i+t*nNeighbors)+2))); + operations = _,par(t,T+1, + par(i,nNeighbors,(_@t),_:*)); +}; + +//------------------------------`(fd.)buildScheme1D`--------------------------- +// This function is used to stack in parallel several schemePoint functions in +// 1 dimension, according to the number of points. +// +// #### Usage +// +// ``` +// si.bus((1 + ((2*R+1)*(T+1)) + (2*R+1))*points) : buildScheme1D(points,R,T) : +// si.bus(points) +// ``` +// +// Where: +// +// * `points`: total number of points in the mesh +// * `R`: neighbourhood radius +// * `T`: time coefficient +//------------------------------------------------------------------------------ +buildScheme1D(points,R,T) = + par (x, points,schemePoint(R,T,1)); + +//------------------------------`(fd.)buildScheme2D`--------------------------- +// This function is used to stack in parallel several schemePoint functions in +// 2 dimensions, according to the number of points in the X and Y directions. +// +// #### Usage +// +// ``` +// si.bus((1 + ((2*R+1)^2*(T+1)) + (2*R+1)^2)*pointsX*pointsY) : +// buildScheme2D(pointsX,pointsY,R,T) : si.bus(pointsX*pointsY) +// ``` +// +// Where: +// +// * `pointsX`: total number of points in the X direction +// * `pointsY`: total number of points in the Y direction +// * `R`: neighbourhood radius +// * `T`: time coefficient +//------------------------------------------------------------------------------ +buildScheme2D(pointsX,pointsY,R,T) = + par (x, pointsX, + par(y,pointsY, schemePoint(R,T,2))); + +//================================Interaction Models============================ +// Here are defined two physically based interaction algorithms: a hammer and +// a bow. These functions need to be coupled to the mesh pde, in the point +// where the interaction happens: to do so, the mesh output signals can be fed +// back and driven into the force block using the interpolation operators. +// The latters can be also used to drive the single force output signal to the +// correct scheme points. +//============================================================================== + +//---------------------------------`(fd.)hammer`------------------------------- +// Implementation of a nonlinear collision model. The hammer is essentially a +// finite difference scheme of a linear damped oscillator, which is coupled +// with the mesh through the collision model (see Stefan Bilbao's book, +// Numerical Sound Synthesis). +// +// #### Usage +// +// ``` +// _ :hammer(coeff,omega0Sqr,sigma0,kH,alpha,k,offset,fIn) : _ +// ``` +// +// Where: +// +// * `coeff`: output force scaling coefficient +// * `omega0Sqr`: squared angular frequency of the hammer oscillator +// * `sigma0`: damping coefficient of the hammer oscillator +// * `kH`: hammer stiffness coefficient +// * `alpha`: nonlinearity parameter +// * `k`: time sampling step (the same as for the mesh) +// * `offset`: distance between the string and the hammer at rest in meters +// * `fIn`: hammer excitation signal (i.e. a button) +//------------------------------------------------------------------------------ +hammer(coeff,omega0Sqr,sigma0,kH,alpha,k,offset,fIn) = + (hammerForce<:hammerModel(fIn,k,offset,_),_)~_:!,_*coeff +with +{ + hammerModel(in,k,offset) = + (_,_,_*forceCoeff,in :> _) ~ (_ <: A*_,B*_') :_-offset; + hammerForce(uh,u)=select2((uh-u)>0,0,((uh-u)^alpha)*(-kH)); + A = (2-omega0Sqr^2*k^2)/(1+sigma0*k); + B = (-1)*(1-sigma0*k)/(1+sigma0*k); + forceCoeff = k^2/(1+sigma0*k); +}; + +//---------------------------------`(fd.)bow`------------------------------- +// Implementation of a nonlinear friction based interaction model that induces +// Helmholtz motion. (see Stefan Bilbao's book, Numerical Sound Synthesis). +// +// #### Usage +// +// ``` +// _ :bow(coeff,alpha,k,vb) : _ +// ``` +// +// Where: +// +// * `coeff`: output force scaling coefficient +// * `alpha`: nonlinearity parameter +// * `k`: time sampling step (the same as for the mesh) +// * `vb`: bow velocity [m/s] +//------------------------------------------------------------------------------ +bow(coeff,alpha,k,vb) = _:phi*(-coeff) +with +{ + phi(u) = 1.41*alpha*dVel(u)*exp(-alpha*dVel(u)*dVel(u)+0.5); + dVel(x) = select2(vb==0,(x-x')/k - vb,0); +}; diff --git a/dist/examples/LIBRARIES/filters.lib b/dist/examples/LIBRARIES/filters.lib new file mode 100644 index 00000000..4726719f --- /dev/null +++ b/dist/examples/LIBRARIES/filters.lib @@ -0,0 +1,3125 @@ +//##################################### filters.lib ######################################## +// Faust Filters library. Its official prefix is `fi`. +// +// The Filters library is organized into 22 sections: +// +// * [Basic Filters](#basic-filters) +// * [Comb Filters](#comb-filters) +// * [Direct-Form Digital Filter Sections](#direct-form-digital-filter-sections) +// * [Direct-Form Second-Order Biquad Sections](#direct-form-second-order-biquad-sections) +// * [Ladder/Lattice Digital Filters](#ladderlattice-digital-filters) +// * [Useful Special Cases](#useful-special-cases) +// * [Ladder/Lattice Allpass Filters](#ladderlattice-allpass-filters) +// * [Digital Filter Sections Specified as Analog Filter Sections](#digital-filter-sections-specified-as-analog-filter-sections) +// * [Simple Resonator Filters](#simple-resonator-filters) +// * [Butterworth Lowpass/Highpass Filters](#butterworth-lowpasshighpass-filters) +// * [Special Filter-Bank Delay-Equalizing Allpass Filters](#special-filter-bank-delay-equalizing-allpass-filters) +// * [Elliptic (Cauer) Lowpass Filters](#elliptic-cauer-lowpass-filters) +// * [Elliptic Highpass Filters](#elliptic-highpass-filters) +// * [Butterworth Bandpass/Bandstop Filters](#butterworth-bandpassbandstop-filters) +// * [Elliptic Bandpass Filters](#elliptic-bandpass-filters) +// * [Parametric Equalizers (Shelf, Peaking)](#parametric-equalizers-shelf-peaking) +// * [Mth-Octave Filter-Banks](#mth-octave-filter-banks) +// * [Arbitrary-Crossover Filter-Banks and Spectrum Analyzers](#arbitrary-crossover-filter-banks-and-spectrum-analyzers) +// * [State Variable Filters (SVF)](#state-variable-filters) +// * [Linkwitz-Riley 4th-order 2-way, 3-way, and 4-way crossovers](#linkwitz-riley-4th-order-2-way-3-way-and-4-way-crossovers) +// * [Standardized Filters](#standardized-filters) +// * [Averaging Functions](#averaging-functions) +// +// #### References +// * +// +//######################################################################################## + +// NOTE ABOUT LICENSES: +// Each function in this library has its own license. Licenses are declared +// before each function. Corresponding license terms can be found at the +// bottom of this file or in the Faust libraries documentation. + +ma = library("maths.lib"); +ba = library("basics.lib"); +ro = library("routes.lib"); +de = library("delays.lib"); +an = library("analyzers.lib"); +ef = library("misceffects.lib"); +si = library("signals.lib"); +fi = library("filters.lib"); // for compatible copy/paste out of this file + +declare name "Faust Filters Library"; +declare version "0.3"; + +//===============================Basic Filters============================================ +//======================================================================================== + +//----------------------`(fi.)zero`-------------------------- +// One zero filter. Difference equation: \(y(n) = x(n) - zx(n-1)\). +// +// #### Usage +// +// ``` +// _ : zero(z) : _ +// ``` +// +// Where: +// +// * `z`: location of zero along real axis in z-plane +// +// #### Reference +// +//---------------------------------------------------------- +declare zero author "Julius O. Smith III"; +declare zero copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare zero license "MIT-style STK-4.3 license"; +zero(z) = _ <: _,mem : _,*(z) : -; + +//------------------------`(fi.)pole`--------------------------- +// One pole filter. Could also be called a "leaky integrator". +// Difference equation: \(y(n) = x(n) + py(n-1)\). +// +// #### Usage +// +// ``` +// _ : pole(p) : _ +// ``` +// +// Where: +// +// * `p`: pole location = feedback coefficient +// +// #### Reference +// +//------------------------------------------------------------ +declare pole author "Julius O. Smith III"; +declare pole copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare pole license "MIT-style STK-4.3 license"; +pole(p) = + ~ *(p); + +//----------------------`(fi.)integrator`-------------------------- +// Same as `pole(1)` [implemented separately for block-diagram clarity]. +//------------------------------------------------------------ +declare integrator author "Julius O. Smith III"; +declare integrator copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare integrator license "MIT-style STK-4.3 license"; +integrator = + ~ _; + +//-------------------`(fi.)dcblockerat`----------------------- +// DC blocker with configurable break frequency. +// The amplitude response is substantially flat above \(fb\), +// and sloped at about +6 dB/octave below \(fb\). +// Derived from the analog transfer function: +// $$H(s) = \frac{s}{(s + 2 \pi fb)}$$ +// (which can be seen as a 1st-order Butterworth highpass filter) +// by the low-frequency-matching bilinear transform method +// (i.e., the standard frequency-scaling constant 2*SR). +// +// #### Usage +// +// ``` +// _ : dcblockerat(fb) : _ +// ``` +// +// Where: +// +// * `fb`: "break frequency" in Hz, i.e., -3 dB gain frequency. +// +// #### Reference +// +//------------------------------------------------------------ +declare dcblockerat author "Julius O. Smith III"; +declare dcblockerat copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare dcblockerat license "MIT-style STK-4.3 license"; +dcblockerat(fb) = *(b0) : zero(1) : pole(p) +with { + wn = ma.PI*fb/ma.SR; + b0 = 1.0 / (1 + wn); + p = (1 - wn) * b0; +}; + +//----------------------`(fi.)dcblocker`-------------------------- +// DC blocker. Default dc blocker has -3dB point near 35 Hz (at 44.1 kHz) +// and high-frequency gain near 1.0025 (due to no scaling). +// `dcblocker` is as standard Faust function. +// +// #### Usage +// +// ``` +// _ : dcblocker : _ +// ``` +//------------------------------------------------------------ +declare dcblocker author "Julius O. Smith III"; +declare dcblocker copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare dcblocker license "MIT-style STK-4.3 license"; +dcblocker = zero(1) : pole(0.995); + +//----------------------------`(fi.)lptN`-------------------------------------- +// One-pole lowpass filter with arbitrary dis/charging factors set in dB and +// times set in seconds. +// +// #### Usage +// +// ``` +// _ : lptN(N, tN) : _ +// ``` +// +// Where: +// +// * `N`: is the attenuation factor in dB +// * `tN`: is the filter period in seconds, that is, the time for the +// impulse response to decay by `N` dB +// +// #### Reference +// +//---------------------------------------------------------- +declare lptN author "Julius O. Smith III"; +declare lptN copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare lptN license "MIT-style STK-4.3 license"; +lptN(N, tN, x) = x : si.smooth(ba.tau2pole(tN / log(10.0^(float(N)/20.0)))); +// Special cases of lptN +lptau(tN, x) = lptN(8.6858896381, tN, x); // Tau time constant, i.e., 1/e atten. after tN secs +lpt60(tN, x) = lptN(60, tN, x); // T60 constant, i.e., 1/1000 atten. after tN secs +lpt19(tN, x) = lptN(19, tN, x); // T19 constant, i.e., 1/e^2.2 atten. after tN secs + +//=======================================Comb Filters===================================== +//======================================================================================== + +//------`(fi.)ff_comb`-------- +// Feed-Forward Comb Filter. Note that `ff_comb` requires integer delays +// (uses `delay` internally). +// `ff_comb` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : ff_comb(maxdel,intdel,b0,bM) : _ +// ``` +// +// Where: +// +// * `maxdel`: maximum delay (a power of 2) +// * `intdel`: current (integer) comb-filter delay between 0 and maxdel +// * `del`: current (float) comb-filter delay between 0 and maxdel +// * `b0`: gain applied to delay-line input +// * `bM`: gain applied to delay-line output and then summed with input +// +// #### Reference +// +//------------------------------------------------------------ +declare ff_comb author "Julius O. Smith III"; +declare ff_comb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare ff_comb license "MIT-style STK-4.3 license"; +ff_comb(maxdel,M,b0,bM) = _ <: *(b0), bM * de.delay(maxdel,M) : +; + +//------`(fi.)ff_fcomb`-------- +// Feed-Forward Comb Filter. Note that `ff_fcomb` takes floating-point delays +// (uses `fdelay` internally). +// `ff_fcomb` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : ff_fcomb(maxdel,del,b0,bM) : _ +// ``` +// +// Where: +// +// * `maxdel`: maximum delay (a power of 2) +// * `intdel`: current (integer) comb-filter delay between 0 and maxdel +// * `del`: current (float) comb-filter delay between 0 and maxdel +// * `b0`: gain applied to delay-line input +// * `bM`: gain applied to delay-line output and then summed with input +// +// #### Reference +// +//------------------------------------------------------------ +declare ff_fcomb author "Julius O. Smith III"; +declare ff_fcomb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare ff_fcomb license "MIT-style STK-4.3 license"; +ff_fcomb(maxdel,M,b0,bM) = _ <: *(b0), bM * de.fdelay(maxdel,M) : +; + +//-----------`(fi.)ffcombfilter`------------------- +// Typical special case of `ff_comb()` where: `b0 = 1`. +//------------------------------------------------------------ +declare ff_combfilter author "Julius O. Smith III"; +declare ff_combfilter copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare ff_combfilter license "MIT-style STK-4.3 license"; +ffcombfilter(maxdel,del,g) = ff_comb(maxdel,del,1,g); + + +//-----------------------`(fi.)fb_comb`----------------------- +// Feed-Back Comb Filter (integer delay). +// +// #### Usage +// +// ``` +// _ : fb_comb(maxdel,intdel,b0,aN) : _ +// ``` +// +// Where: +// +// * `maxdel`: maximum delay (a power of 2) +// * `intdel`: current (integer) comb-filter delay between 0 and maxdel +// * `del`: current (float) comb-filter delay between 0 and maxdel +// * `b0`: gain applied to delay-line input and forwarded to output +// * `aN`: minus the gain applied to delay-line output before summing with the input +// and feeding to the delay line +// +// #### Reference +// +//------------------------------------------------------------ +declare fb_comb author "Julius O. Smith III"; +declare fb_comb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare fb_comb license "MIT-style STK-4.3 license"; +fb_comb(maxdel,N,b0,aN) = (+ <: de.delay(maxdel,N-1),_) ~ *(-aN) : !,*(b0) : mem; + + +//-----------------------`(fi.)fb_fcomb`----------------------- +// Feed-Back Comb Filter (floating point delay). +// +// #### Usage +// +// ``` +// _ : fb_fcomb(maxdel,del,b0,aN) : _ +// ``` +// +// Where: +// +// * `maxdel`: maximum delay (a power of 2) +// * `intdel`: current (integer) comb-filter delay between 0 and maxdel +// * `del`: current (float) comb-filter delay between 0 and maxdel +// * `b0`: gain applied to delay-line input and forwarded to output +// * `aN`: minus the gain applied to delay-line output before summing with the input +// and feeding to the delay line +// +// #### Reference +// +//------------------------------------------------------------ +declare fb_fcomb author "Julius O. Smith III"; +declare fb_fcomb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare fb_fcomb license "MIT-style STK-4.3 license"; +fb_fcomb(maxdel,N,b0,aN) = (+ <: de.fdelay(maxdel,float(N)-1.0),_) ~ *(-aN) : !,*(b0) : mem; + +//-----------------------`(fi.)rev1`----------------------- +// Special case of `fb_comb` (`rev1(maxdel,N,g)`). +// The "rev1 section" dates back to the 1960s in computer-music reverberation. +// See the `jcrev` and `brassrev` in `reverbs.lib` for usage examples. +//------------------------------------------------------------ +declare rev1 author "Julius O. Smith III"; +declare rev1 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare rev1 license "MIT-style STK-4.3 license"; +rev1(maxdel,N,g) = fb_comb (maxdel,N,1,-g); + +//-----`(fi.)fbcombfilter` and `(fi.)ffbcombfilter`------------ +// Other special cases of Feed-Back Comb Filter. +// +// #### Usage +// +// ``` +// _ : fbcombfilter(maxdel,intdel,g) : _ +// _ : ffbcombfilter(maxdel,del,g) : _ +// ``` +// +// Where: +// +// * `maxdel`: maximum delay (a power of 2) +// * `intdel`: current (integer) comb-filter delay between 0 and maxdel +// * `del`: current (float) comb-filter delay between 0 and maxdel +// * `g`: feedback gain +// +// #### Reference +// +//------------------------------------------------------------ +declare fbcombfilter author "Julius O. Smith III"; +declare fbcombfilter copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare fbcombfilter license "MIT-style STK-4.3 license"; +fbcombfilter(maxdel,intdel,g) = (+ : de.delay(maxdel,intdel)) ~ *(g); + +declare ffbcombfilter author "Julius O. Smith III"; +declare ffbcombfilter copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare ffbcombfilter license "MIT-style STK-4.3 license"; +ffbcombfilter(maxdel,del,g) = (+ : de.fdelay(maxdel,del)) ~ *(g); + + +//-------------------`(fi.)allpass_comb`----------------- +// Schroeder Allpass Comb Filter. Note that: +// +// ``` +// allpass_comb(maxlen,len,aN) = ff_comb(maxlen,len,aN,1) : fb_comb(maxlen,len-1,1,aN); +// ``` +// +// which is a direct-form-1 implementation, requiring two delay lines. +// The implementation here is direct-form-2 requiring only one delay line. +// +// #### Usage +// +// ``` +// _ : allpass_comb(maxdel,intdel,aN) : _ +// ``` +// +// Where: +// +// * `maxdel`: maximum delay (a power of 2) +// * `intdel`: current (integer) comb-filter delay between 0 and maxdel +// * `del`: current (float) comb-filter delay between 0 and maxdel +// * `aN`: minus the feedback gain +// +// #### References +// * +// * +// * +//------------------------------------------------------------ +declare allpass_comb author "Julius O. Smith III"; +declare allpass_comb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpass_comb license "MIT-style STK-4.3 license"; +allpass_comb(maxdel,N,aN) = (+ <: de.delay(maxdel,N-1),*(aN)) ~ *(-aN) : mem,_ : +; + + +//-------------------`(fi.)allpass_fcomb`----------------- +// Schroeder Allpass Comb Filter. Note that: +// +// ``` +// allpass_comb(maxlen,len,aN) = ff_comb(maxlen,len,aN,1) : fb_comb(maxlen,len-1,1,aN); +// ``` +// +// which is a direct-form-1 implementation, requiring two delay lines. +// The implementation here is direct-form-2 requiring only one delay line. +// +// `allpass_fcomb` is a standard Faust library. +// +// #### Usage +// +// ``` +// _ : allpass_comb(maxdel,intdel,aN) : _ +// _ : allpass_fcomb(maxdel,del,aN) : _ +// ``` +// +// Where: +// +// * `maxdel`: maximum delay (a power of 2) +// * `intdel`: current (float) comb-filter delay between 0 and maxdel +// * `del`: current (float) comb-filter delay between 0 and maxdel +// * `aN`: minus the feedback gain +// +// #### References +// * +// * +// * +//------------------------------------------------------------ +declare allpass_fcomb author "Julius O. Smith III"; +declare allpass_fcomb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpass_fcomb license "MIT-style STK-4.3 license"; +allpass_fcomb(maxdel,N,aN) = (+ <: de.fdelay(maxdel,N-1),*(aN)) ~ *(-aN) : mem,_ : +; + + +//-----------------------`(fi.)rev2`----------------------- +// Special case of `allpass_comb` (`rev2(maxlen,len,g)`). +// The "rev2 section" dates back to the 1960s in computer-music reverberation. +// See the `jcrev` and `brassrev` in `reverbs.lib` for usage examples. +//------------------------------------------------------------ +declare rev2 author "Julius O. Smith III"; +declare rev2 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare rev2 license "MIT-style STK-4.3 license"; +rev2(maxlen,len,g) = allpass_comb(maxlen,len,-g); + +//-------------------`(fi.)allpass_fcomb5` and `(fi.)allpass_fcomb1a`----------------- +// Same as `allpass_fcomb` but use `fdelay5` and `fdelay1a` internally +// (Interpolation helps - look at an fft of faust2octave on +// +// ``` +// `1-1' <: allpass_fcomb(1024,10.5,0.95), allpass_fcomb5(1024,10.5,0.95);`). +// ``` +//------------------------------------------------------------ +declare allpass_fcomb5 author "Julius O. Smith III"; +declare allpass_fcomb5 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpass_fcomb5 license "MIT-style STK-4.3 license"; +allpass_fcomb5(maxdel,N,aN) = (+ <: de.fdelay5(maxdel,N-1),*(aN)) ~ *(-aN) : mem,_ : +; + +declare allpass_fcomb1a author "Julius O. Smith III"; +declare allpass_fcomb1a copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpass_fcomb1a license "MIT-style STK-4.3 license"; +allpass_fcomb1a(maxdel,N,aN) = (+ <: de.fdelay1a(maxdel,N-1),*(aN)) ~ *(-aN) : mem,_ : +; + + +//========================Direct-Form Digital Filter Sections============================= +//======================================================================================== + +// Specified by transfer-function polynomials B(z)/A(z) as in matlab + +//----------------------------`(fi.)iir`------------------------------- +// Nth-order Infinite-Impulse-Response (IIR) digital filter, +// implemented in terms of the Transfer-Function (TF) coefficients. +// Such filter structures are termed "direct form". +// +// `iir` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : iir(bcoeffs,acoeffs) : _ +// ``` +// +// Where: +// +// * `bcoeffs`: (b0,b1,...,b_order) = TF numerator coefficients +// * `acoeffs`: (a1,...,a_order) = TF denominator coeffs (a0=1) +// +// #### Reference +// +//------------------------------------------------------------ +declare iir author "Julius O. Smith III"; +declare iir copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare iir license "MIT-style STK-4.3 license"; +iir(bv,av) = ma.sub ~ fir(av) : fir(bv); + +//-----------------------------`(fi.)fir`--------------------------------- +// FIR filter (convolution of FIR filter coefficients with a signal). `fir` is standard Faust function. +// +// #### Usage +// +// ``` +// _ : fir(bv) : _ +// ``` +// +// Where: +// +// * `bv` = b0,b1,...,bn is a parallel bank of coefficient signals. +// +// #### Note +// +// `bv` is processed using pattern-matching at compile time, +// so it must have this normal form (parallel signals). +// +// #### Example test program +// +// Smoothing white noise with a five-point moving average: +// +// ``` +// bv = .2,.2,.2,.2,.2; +// process = noise : fir(bv); +// ``` +// +// Equivalent (note double parens): +// +// ``` +// process = noise : fir((.2,.2,.2,.2,.2)); +// ``` +//------------------------------------------------------------ +//fir(bv) = conv(bv); +declare fir author "Julius O. Smith III"; +declare fir copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare fir license "MIT-style STK-4.3 license"; +fir((b0,bv)) = _ <: *(b0), R(1,bv) :> _ with { + R(n,(bn,bv)) = (@(n):*(bn)), R(n+1,bv); + R(n, bn) = (@(n):*(bn)); }; +fir(b0) = *(b0); + +//---------------`(fi.)conv` and `(fi.)convN`------------------------------- +// Convolution of input signal with given coefficients. +// +// #### Usage +// +// ``` +// _ : conv((k1,k2,k3,...,kN)) : _ // Argument = one signal bank +// _ : convN(N,(k1,k2,k3,...)) : _ // Useful when N < count((k1,...)) +// ``` +//------------------------------------------------------------ +//convN(N,kv,x) = sum(i,N,take(i+1,kv) * x@i); // take() defined in math.lib + +declare convN author "Julius O. Smith III"; +declare convN copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare convN license "MIT-style STK-4.3 license"; +convN(N,kv) = sum(i,N, @(i)*take(i+1,kv)); // take() defined in math.lib +//conv(kv,x) = sum(i,count(kv),take(i+1,kv) * x@i); // count() from math.lib + +declare conv author "Julius O. Smith III"; +declare conv copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare conv license "MIT-style STK-4.3 license"; +conv(kv) = fir(kv); + +//----------------`(fi.)tf1`, `(fi.)tf2` and `(fi.)tf3`---------------------- +// tfN = N'th-order direct-form digital filter. +// +// #### Usage +// +// ``` +// _ : tf1(b0,b1,a1) : _ +// _ : tf2(b0,b1,b2,a1,a2) : _ +// _ : tf3(b0,b1,b2,b3,a1,a2,a3) : _ +// ``` +// +// Where: +// +// * `a`: the poles +// * `b`: the zeros +// +// #### Reference +// +//------------------------------------------------------------ +declare tf1 author "Julius O. Smith III"; +declare tf1 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf1 license "MIT-style STK-4.3 license"; +tf1(b0,b1,a1) = _ <: *(b0), (mem : *(b1)) :> + ~ *(0-a1); + +declare tf2 author "Julius O. Smith III"; +declare tf2 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf2 license "MIT-style STK-4.3 license"; +tf2(b0,b1,b2,a1,a2) = iir((b0,b1,b2),(a1,a2)); +// tf2 is a variant of tf22 below with duplicated mems + +declare tf3 author "Julius O. Smith III"; +declare tf3 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf3 license "MIT-style STK-4.3 license"; +tf3(b0,b1,b2,b3,a1,a2,a3) = iir((b0,b1,b2,b3),(a1,a2,a3)); + +// "Original" version for music.lib. This is here for comparison but people should +// use tf2 instead +TF2(b0,b1,b2,a1,a2) = sub ~ conv2(a1,a2) : conv3(b0,b1,b2) +with { + conv3(k0,k1,k2,x) = k0*x + k1*x' + k2*x''; + conv2(k0,k1,x) = k0*x + k1*x'; + sub(x,y) = y-x; +}; + +//------------`(fi.)notchw`-------------- +// Simple notch filter based on a biquad (`tf2`). +// `notchw` is a standard Faust function. +// +// #### Usage: +// +// ``` +// _ : notchw(width,freq) : _ +// ``` +// +// Where: +// +// * `width`: "notch width" in Hz (approximate) +// * `freq`: "notch frequency" in Hz +// +// #### Reference +// +//------------------------------------------------------------ +declare notchw author "Julius O. Smith III"; +declare notchw copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare notchw license "MIT-style STK-4.3 license"; +notchw(width,freq) = tf2(b0,b1,b2,a1,a2) +with { + fb = 0.5*width; // First design a dcblockerat(width/2) + wn = ma.PI*fb/ma.SR; + b0db = 1.0 / (1 + wn); + p = (1 - wn) * b0db; // This is our pole radius. + // Now place unit-circle zeros at desired angles: + tn = 2*ma.PI*freq/ma.SR; + a2 = p * p; + a2p1 = 1+a2; + a1 = -a2p1*cos(tn); + b1 = a1; + b0 = 0.5*a2p1; + b2 = b0; +}; + +//======================Direct-Form Second-Order Biquad Sections========================== +// Direct-Form Second-Order Biquad Sections +// +// #### Reference +// +//======================================================================================== + +//----------------`(fi.)tf21`, `(fi.)tf22`, `(fi.)tf22t` and `(fi.)tf21t`---------------------- +// tfN = N'th-order direct-form digital filter where: +// +// * `tf21` is tf2, direct-form 1 +// * `tf22` is tf2, direct-form 2 +// * `tf22t` is tf2, direct-form 2 transposed +// * `tf21t` is tf2, direct-form 1 transposed +// +// #### Usage +// +// ``` +// _ : tf21(b0,b1,b2,a1,a2) : _ +// _ : tf22(b0,b1,b2,a1,a2) : _ +// _ : tf22t(b0,b1,b2,a1,a2) : _ +// _ : tf21t(b0,b1,b2,a1,a2) : _ +// ``` +// +// Where: +// +// * `a`: the poles +// * `b`: the zeros +// +// #### Reference +// +//------------------------------------------------------------ +declare tf21 author "Julius O. Smith III"; +declare tf21 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf21 license "MIT-style STK-4.3 license"; +tf21(b0,b1,b2,a1,a2) = // tf2, direct-form 1: + _ <:(mem<:((mem:*(b2)),*(b1))),*(b0) :>_ + : ((_,_,_:>_) ~(_<:*(-a1),(mem:*(-a2)))); + +declare tf22 author "Julius O. Smith III"; +declare tf22 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf22 license "MIT-style STK-4.3 license"; +tf22(b0,b1,b2,a1,a2) = // tf2, direct-form 2: + _ : (((_,_,_:>_)~*(-a1)<:mem,*(b0))~*(-a2)) + : (_<:mem,*(b1)),_ : *(b2),_,_ :> _; + +declare tf22t author "Julius O. Smith III"; +declare tf22t copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf22t license "MIT-style STK-4.3 license"; +tf22t(b0,b1,b2,a1,a2) = // tf2, direct-form 2 transposed: + _ : (_,_,(_ <: *(b2)',*(b1)',*(b0)) + : _,+',_,_ :> _)~*(-a1)~*(-a2) : _; + +declare tf21t author "Julius O. Smith III"; +declare tf21t copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf21t license "MIT-style STK-4.3 license"; +tf21t(b0,b1,b2,a1,a2) = // tf2, direct-form 1 transposed: + tf22t(1,0,0,a1,a2) : tf22t(b0,b1,b2,0,0); // or write it out if you want + +//=========================== Ladder/Lattice Digital Filters ============================= +// Ladder and lattice digital filters generally have superior numerical +// properties relative to direct-form digital filters. They can be derived +// from digital waveguide filters, which gives them a physical interpretation. + +// #### Reference +// * F. Itakura and S. Saito: "Digital Filtering Techniques for Speech Analysis and Synthesis", +// 7th Int. Cong. Acoustics, Budapest, 25 C 1, 1971. +// * J. D. Markel and A. H. Gray: Linear Prediction of Speech, New York: Springer Verlag, 1976. +// * +//======================================================================================== + +//-------------------------------`(fi.)av2sv`----------------------------------- +// Compute reflection coefficients sv from transfer-function denominator av. +// +// #### Usage +// +// ``` +// sv = av2sv(av) +// ``` +// +// Where: +// +// * `av`: parallel signal bank `a1,...,aN` +// * `sv`: parallel signal bank `s1,...,sN` +// +// where `ro = ith` reflection coefficient, and +// `ai` = coefficient of `z^(-i)` in the filter +// transfer-function denominator `A(z)`. +// +// #### Reference +// +// (where reflection coefficients are denoted by k rather than s). +//------------------------------------------------------------ +declare av2sv author "Julius O. Smith III"; +declare av2sv copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare av2sv license "MIT-style STK-4.3 license"; +av2sv(av) = par(i,M,s(i+1)) with { + M = ba.count(av); + s(m) = sr(M-m+1); // m=1..M + sr(m) = Ari(m,M-m+1); // s_{M-1-m} + Ari(m,i) = ba.take(i+1,Ar(m-1)); + //step-down recursion for lattice/ladder digital filters: + Ar(0) = (1,av); // Ar(m) is order M-m (i.e. "reverse-indexed") + Ar(m) = 1,par(i,M-m, (Ari(m,i+1) - sr(m)*Ari(m,M-m-i))/(1-sr(m)*sr(m))); +}; + +//----------------------------`(fi.)bvav2nuv`-------------------------------- +// Compute lattice tap coefficients from transfer-function coefficients. +// +// #### Usage +// +// ``` +// nuv = bvav2nuv(bv,av) +// ``` +// +// Where: +// +// * `av`: parallel signal bank `a1,...,aN` +// * `bv`: parallel signal bank `b0,b1,...,aN` +// * `nuv`: parallel signal bank `nu1,...,nuN` +// +// where `nui` is the i'th tap coefficient, +// `bi` is the coefficient of `z^(-i)` in the filter numerator, +// `ai` is the coefficient of `z^(-i)` in the filter denominator +//------------------------------------------------------------ +declare bvav2nuv author "Julius O. Smith III"; +declare bvav2nuv copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare bvav2nuv license "MIT-style STK-4.3 license"; +bvav2nuv(bv,av) = par(m,M+1,nu(m)) with { + M = ba.count(av); + nu(m) = ba.take(m+1,Pr(M-m)); // m=0..M + // lattice/ladder tap parameters: + Pr(0) = bv; // Pr(m) is order M-m, 'r' means "reversed" + Pr(m) = par(i,M-m+1, (Pri(m,i) - nu(M-m+1)*Ari(m,M-m-i+1))); + Pri(m,i) = ba.take(i+1,Pr(m-1)); + Ari(m,i) = ba.take(i+1,Ar(m-1)); + //step-down recursion for lattice/ladder digital filters: + Ar(0) = (1,av); // Ar(m) is order M-m (recursion index must start at constant) + Ar(m) = 1,par(i,M-m, (Ari(m,i+1) - sr(m)*Ari(m,M-m-i))/(1-sr(m)*sr(m))); + sr(m) = Ari(m,M-m+1); // s_{M-1-m} +}; + +//--------------------`(fi.)iir_lat2`----------------------- +// Two-multiply latice IIR filter of arbitrary order. +// +// #### Usage +// +// ``` +// _ : iir_lat2(bv,av) : _ +// ``` +// +// Where: +// +// * bv: zeros as a bank of parallel signals +// * av: poles as a bank of parallel signals +//------------------------------------------------------------ +declare iir_lat2 author "Julius O. Smith III"; +declare iir_lat2 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare iir_lat2 license "MIT-style STK-4.3 license"; +iir_lat2(bv,av) = allpassnt(M,sv) : sum(i,M+1,*(ba.take(M-i+1,tg))) +with { + M = ba.count(av); + sv = av2sv(av); // sv = vector of sin(theta) reflection coefficients + tg = bvav2nuv(bv,av); // tg = vector of tap gains +}; + +//-----------------------`(fi.)allpassnt`-------------------------- +// Two-multiply lattice allpass (nested order-1 direct-form-ii allpasses). +// +// #### Usage +// +// ``` +// _ : allpassnt(n,sv) : _ +// ``` +// +// Where: +// +// * `n`: the order of the filter +// * `sv`: the reflection coefficients (-1 1) +//------------------------------------------------------------ +declare allpassnt author "Julius O. Smith III"; +declare allpassnt copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpassnt license "MIT-style STK-4.3 license"; +allpassnt(0,sv) = _; +allpassnt(n,sv) = _ : ((+ <: (allpassnt(n-1,sv),*(s)))~*(-s)) : fsec(n) +with { + fsec(1) = ro.crossnn(1) : _, (_<:mem,_) : +,_; + fsec(n) = ro.crossn1(n) : _, (_<:mem,_),par(i,n-1,_) : +, par(i,n,_); + innertaps(n) = par(i,n,_); + s = ba.take(n,sv); // reflection coefficient s = sin(theta) +}; + +//--------------------`(fi.)iir_kl`----------------------- +// Kelly-Lochbaum ladder IIR filter of arbitrary order. +// +// #### Usage +// +// ``` +// _ : iir_kl(bv,av) : _ +// ``` +// +// Where: +// +// * bv: zeros as a bank of parallel signals +// * av: poles as a bank of parallel signals +//------------------------------------------------------------ +declare iir_kl author "Julius O. Smith III"; +declare iir_kl copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare iir_kl license "MIT-style STK-4.3 license"; +iir_kl(bv,av) = allpassnklt(M,sv) : sum(i,M+1,*(tghr(i))) +with { + M = ba.count(av); + sv = av2sv(av); // sv = vector of sin(theta) reflection coefficients + tg = bvav2nuv(bv,av); // tg = vector of tap gains for 2mul case + tgr(i) = ba.take(M+1-i,tg); + tghr(n) = tgr(n)/pi(n); + pi(0) = 1; + pi(n) = pi(n-1)*(1+ba.take(M-n+1,sv)); // all sign parameters '+' +}; + +//-----------------------`(fi.)allpassnklt`-------------------------- +// Kelly-Lochbaum ladder allpass. +// +// #### Usage: +// +// ``` +// _ : allpassnklt(n,sv) : _ +// ``` +// +// Where: +// +// * `n`: the order of the filter +// * `sv`: the reflection coefficients (-1 1) +//------------------------------------------------------------ +declare allpassnklt author "Julius O. Smith III"; +declare allpassnklt copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpassnklt license "MIT-style STK-4.3 license"; +allpassnklt(0,sv) = _; +allpassnklt(n,sv) = _ <: *(s),(*(1+s) : (+ + : allpassnklt(n-1,sv))~(*(-s))) : fsec(n) +with { + fsec(1) = _, (_<:mem*(1-s),_) : sumandtaps(n); + fsec(n) = _, (_<:mem*(1-s),_), par(i,n-1,_) : sumandtaps(n); + s = ba.take(n,sv); + sumandtaps(n) = +,par(i,n,_); +}; + +//--------------------`(fi.)iir_lat1`----------------------- +// One-multiply latice IIR filter of arbitrary order. +// +// #### Usage +// +// ``` +// _ : iir_lat1(bv,av) : _ +// ``` +// +// Where: +// +// * bv: zeros as a bank of parallel signals +// * av: poles as a bank of parallel signals +//------------------------------------------------------------ +declare iir_lat1 author "Julius O. Smith III"; +declare iir_lat1 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare iir_lat1 license "MIT-style STK-4.3 license"; +iir_lat1(bv,av) = allpassn1mt(M,sv) : sum(i,M+1,*(tghr(i+1))) +with { + M = ba.count(av); + sv = av2sv(av); // sv = vector of sin(theta) reflection coefficients + tg = bvav2nuv(bv,av); // tg = vector of tap gains + tgr(i) = ba.take(M+2-i,tg); // i=1..M+1 (for "takability") + tghr(n) = tgr(n)/pi(n); + pi(1) = 1; + pi(n) = pi(n-1)*(1+ba.take(M-n+2,sv)); // all sign parameters '+' +}; + +//-----------------------`(fi.)allpassn1mt`-------------------------- +// One-multiply lattice allpass with tap lines. +// +// #### Usage +// +// ``` +// _ : allpassn1mt(N,sv) : _ +// ``` +// +// Where: +// +// * `N`: the order of the filter (fixed at compile time) +// * `sv`: the reflection coefficients (-1 1) +//------------------------------------------------------------ +declare allpassn1mt author "Julius O. Smith III"; +declare allpassn1mt copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpassn1mt license "MIT-style STK-4.3 license"; +allpassn1mt(0,sv) = _; +allpassn1mt(n,sv) = _ <: _,_ : ((+:*(s) <: _,_),_ : _,+ : ro.crossnn(1) + : allpassn1mt(n-1,sv),_)~(*(-1)) : fsec(n) +with { + fsec(1) = ro.crossnn(1) : _, (_<:mem,_) : +,_; + fsec(n) = ro.crossn1(n) : _, (_<:mem,_),par(i,n-1,_) : +, par(i,n,_); + innertaps(n) = par(i,n,_); + s = ba.take(n,sv); // reflection coefficient s = sin(theta) +}; + +//-------------------------------`(fi.)iir_nl`------------------------- +// Normalized ladder filter of arbitrary order. +// +// #### Usage +// +// ``` +// _ : iir_nl(bv,av) : _ +// ``` +// +// Where: +// +// * bv: zeros as a bank of parallel signals +// * av: poles as a bank of parallel signals +// +// #### References +// * J. D. Markel and A. H. Gray, Linear Prediction of Speech, New York: Springer Verlag, 1976. +// * +//------------------------------------------------------------ +declare iir_nl author "Julius O. Smith III"; +declare iir_nl copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare iir_nl license "MIT-style STK-4.3 license"; +iir_nl(bv,av) = allpassnnlt(M,sv) : sum(i,M+1,*(tghr(i))) +with { + M = ba.count(av); + sv = av2sv(av); // sv = vector of sin(theta) reflection coefficients + tg = bvav2nuv(bv,av); // tg = vector of tap gains for 2mul case + tgr(i) = ba.take(M+1-i,tg); + tghr(n) = tgr(n)/pi(n); + pi(0) = 1; + s(n) = ba.take(M-n+1,sv); // reflection coefficient = sin(theta) + c(n) = sqrt(max(0,1-s(n)*s(n))); // compiler crashes on sqrt(-) + pi(n) = pi(n-1)*c(n); +}; + +//-------------------------------`(fi.)allpassnnlt`------------------------- +// Normalized ladder allpass filter of arbitrary order. +// +// #### Usage: +// +// ``` +// _ : allpassnnlt(N,sv) : _ +// ``` +// +// Where: +// +// * `N`: the order of the filter (fixed at compile time) +// * `sv`: the reflection coefficients (-1,1) +// +// #### References +// * J. D. Markel and A. H. Gray, Linear Prediction of Speech, New York: Springer Verlag, 1976. +// * +//------------------------------------------------------------ +declare allpassnnlt author "Julius O. Smith III"; +declare allpassnnlt copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpassnnlt license "MIT-style STK-4.3 license"; +allpassnnlt(0,sv) = _; +allpassnnlt(n,scl*(sv)) = allpassnnlt(n,par(i,count(sv),scl*(sv(i)))); +allpassnnlt(n,sv) = _ <: *(s),(*(c) : (+ + : allpassnnlt(n-1,sv))~(*(-s))) : fsec(n) +with { + fsec(1) = _, (_<:mem*(c),_) : sumandtaps(n); + fsec(n) = _, (_<:mem*(c),_), par(i,n-1,_) : sumandtaps(n); + s = ba.take(n,sv); + c = sqrt(max(0,1-s*s)); + sumandtaps(n) = +,par(i,n,_); +}; + +//=============================Useful Special Cases======================================= +//======================================================================================== + +//--------------------------------`(fi.)tf2np`------------------------------------ +// Biquad based on a stable second-order Normalized Ladder Filter +// (more robust to modulation than `tf2` and protected against instability). +// +// #### Usage +// +// ``` +// _ : tf2np(b0,b1,b2,a1,a2) : _ +// ``` +// +// Where: +// +// * `a`: the poles +// * `b`: the zeros +//------------------------------------------------------------ +declare tf2np author "Julius O. Smith III"; +declare tf2np copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf2np license "MIT-style STK-4.3 license"; +tf2np(b0,b1,b2,a1,a2) = allpassnnlt(M,sv) : sum(i,M+1,*(tghr(i))) +with { + smax = 1.0-ma.EPSILON; // maximum reflection-coefficient magnitude allowed + s2 = max(-smax, min(smax,a2)); // Project both reflection-coefficients + s1 = max(-smax, min(smax,a1/(1+a2))); // into the defined stability-region. + sv = (s1,s2); // vector of sin(theta) reflection coefficients + M = 2; + nu(2) = b2; + nu(1) = b1 - b2*a1; + nu(0) = (b0-b2*a2) - nu(1)*s1; + tg = (nu(0),nu(1),nu(2)); + tgr(i) = ba.take(M+1-i,tg); // vector of tap gains for 2mul case + tghr(n) = tgr(n)/pi(n); // apply pi parameters for NLF case + pi(0) = 1; + s(n) = ba.take(M-n+1,sv); + c(n) = sqrt(1-s(n)*s(n)); + pi(n) = pi(n-1)*c(n); +}; + +//-----------------------------`(fi.)wgr`--------------------------------- +// Second-order transformer-normalized digital waveguide resonator. +// +// #### Usage +// +// ``` +// _ : wgr(f,r) : _ +// ``` +// +// Where: +// +// * `f`: resonance frequency (Hz) +// * `r`: loss factor for exponential decay (set to 1 to make a numerically stable oscillator) +// +// #### References +// * +// * +//------------------------------------------------------------ +declare wgr author "Julius O. Smith III"; +declare wgr copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare wgr license "MIT-style STK-4.3 license"; +wgr(f,r,x) = (*(G),_<:_,((+:*(C))<:_,_),_:+,_,_:+(x),-) ~ cross : _,*(0-gi) +with { + C = cos(2*ma.PI*f/ma.SR); + gi = sqrt(max(0,(1+C)/(1-C))); // compensate amplitude (only needed when + G = r*(1-1' + gi')/gi; // frequency changes substantially) + cross = _,_ <: !,_,_,!; +}; + +//-----------------------------`(fi.)nlf2`-------------------------------- +// Second order normalized digital waveguide resonator. +// +// #### Usage +// +// ``` +// _ : nlf2(f,r) : _ +// ``` +// +// Where: +// +// * `f`: resonance frequency (Hz) +// * `r`: loss factor for exponential decay (set to 1 to make a sinusoidal oscillator) +// +// #### Reference +// +//------------------------------------------------------------ +declare nlf2 author "Julius O. Smith III"; +declare nlf2 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare nlf2 license "MIT-style STK-4.3 license"; +nlf2(f,r,x) = ((_<:_,_),(_<:_,_) : (*(s),*(c),*(c),*(0-s)) :> + (*(r),+(x))) ~ cross +with { + th = 2*ma.PI*f/ma.SR; + c = cos(th); + s = sin(th); + cross = _,_ <: !,_,_,!; +}; + + +//------------`(fi.)apnl`--------------- +// Passive Nonlinear Allpass based on Pierce switching springs idea. +// Switch between allpass coefficient `a1` and `a2` at signal zero crossings. +// +// #### Usage +// +// ``` +// _ : apnl(a1,a2) : _ +// ``` +// +// Where: +// +// * `a1` and `a2`: allpass coefficients +// +// #### Reference +// * "A Passive Nonlinear Digital Filter Design ..." by John R. Pierce and Scott +// A. Van Duyne, JASA, vol. 101, no. 2, pp. 1120-1126, 1997 +//------------------------------------------------------------ +declare apnl author "Julius O. Smith III"; +declare apnl copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare apnl license "MIT-style STK-4.3 license"; +apnl(a1,a2,x) = nonLinFilter +with { + condition = _>0; + nonLinFilter = (x - _ <: _*(condition*a1 + (1-condition)*a2),_')~_ :> +; +}; + + +//============================Ladder/Lattice Allpass Filters============================== +// An allpass filter has gain 1 at every frequency, but variable phase. +// Ladder/lattice allpass filters are specified by reflection coefficients. +// They are defined here as nested allpass filters, hence the names allpassn*. +// +// #### References +// * +// * +// * Linear Prediction of Speech, Markel and Gray, Springer Verlag, 1976 +//======================================================================================== + +//---------------`(fi.)allpassn`----------------- +// Two-multiply lattice - each section is two multiply-adds. +// +// #### Usage: +// +// ``` +// _ : allpassn(n,sv) : _ +// ``` +// #### Where: +// +// * `n`: the order of the filter +// * `sv`: the reflection coefficients (-1 1) +// +// #### References +// * J. O. Smith and R. Michon, "Nonlinear Allpass Ladder Filters in FAUST", in +// Proceedings of the 14th International Conference on Digital Audio Effects +// (DAFx-11), Paris, France, September 19-23, 2011. +//---------------------------------------------- +declare allpassn author "Julius O. Smith III and Romain Michon"; +declare allpassn copyright "Copyright (C) 2003-2019 by Julius O. Smith III and Romain Michon "; +declare allpassn license "MIT-style STK-4.3 license"; +allpassn(0,sv) = _; +allpassn(n,sv) = _ <: ((+ <: (allpassn(n-1,sv)),*(s))~(*(-s))) : _',_ :+ +with { s = ba.take(n,sv); }; + +//---------------`(fi.)allpassnn`----------------- +// Normalized form - four multiplies and two adds per section, +// but coefficients can be time varying and nonlinear without +// "parametric amplification" (modulation of signal energy). +// +// #### Usage: +// +// ``` +// _ : allpassnn(n,tv) : _ +// ``` +// +// Where: +// +// * `n`: the order of the filter +// * `tv`: the reflection coefficients (-PI PI) +//---------------------------------------------- +// power-normalized (reflection coefficients s = sin(t)): +declare allpassnn author "Julius O. Smith III"; +declare allpassnn copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpassnn license "MIT-style STK-4.3 license"; +allpassnn(0,tv) = _; +allpassnn(n,tv) = _ <: *(s), (*(c) : (+ + : allpassnn(n-1,tv))~(*(-s))) : _, mem*c : + +with { c = cos(ba.take(n,tv)); s = sin(ba.take(n,tv)); }; + +//---------------`(fi.)allpassnkl`----------------- +// Kelly-Lochbaum form - four multiplies and two adds per +// section, but all signals have an immediate physical +// interpretation as traveling pressure waves, etc. +// +// #### Usage: +// +// ``` +// _ : allpassnkl(n,sv) : _ +// ``` +// +// Where: +// +// * `n`: the order of the filter +// * `sv`: the reflection coefficients (-1 1) +//---------------------------------------------- +// Kelly-Lochbaum: +declare allpassnnkl author "Julius O. Smith III"; +declare allpassnnkl copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpassnnkl license "MIT-style STK-4.3 license"; +allpassnkl(0,sv) = _; +allpassnkl(n,sv) = _ <: *(s),(*(1+s) : (+ + : allpassnkl(n-1,sv))~(*(-s))) : _, mem*(1-s) : + +with { s = ba.take(n,sv); }; + +//---------------`(fi.)allpass1m`----------------- +// One-multiply form - one multiply and three adds per section. +// Normally the most efficient in special-purpose hardware. +// +// #### Usage: +// +// ``` +// _ : allpassn1m(n,sv) : _ +// ``` +// +// Where: +// +// * `n`: the order of the filter +// * `sv`: the reflection coefficients (-1 1) +//---------------------------------------------- +// one-multiply: +declare allpassn1m author "Julius O. Smith III"; +declare allpassn1m copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare allpassn1m license "MIT-style STK-4.3 license"; +allpassn1m(0,sv) = _; +allpassn1m(n,sv) = _ <: _,_ : ((+:*(s) <: _,_),_ : _,+ : cross + : allpassn1m(n-1,sv),_)~(*(-1)) : _',_ : + +with { s = ba.take(n,sv); cross = _,_ <: !,_,_,!; }; + +//===========Digital Filter Sections Specified as Analog Filter Sections================== +//======================================================================================== + +//-------------------------`(fi.)tf2s` and `(fi.)tf2snp`-------------------------------- +// Second-order direct-form digital filter, +// specified by ANALOG transfer-function polynomials B(s)/A(s), +// and a frequency-scaling parameter. Digitization via the +// bilinear transform is built in. +// +// #### Usage +// +// ``` +// _ : tf2s(b2,b1,b0,a1,a0,w1) : _ +// ``` +// Where: +// +// ``` +// b2 s^2 + b1 s + b0 +// H(s) = -------------------- +// s^2 + a1 s + a0 +// ``` +// +// and `w1` is the desired digital frequency (in radians/second) +// corresponding to analog frequency 1 rad/sec (i.e., `s = j`). +// +// #### Example test program +// +// A second-order ANALOG Butterworth lowpass filter, +// normalized to have cutoff frequency at 1 rad/sec, +// has transfer function: +// +// ``` +// 1 +// H(s) = ----------------- +// s^2 + a1 s + 1 +// ``` +// +// where `a1 = sqrt(2)`. Therefore, a DIGITAL Butterworth lowpass +// cutting off at `SR/4` is specified as `tf2s(0,0,1,sqrt(2),1,PI*SR/2);` +// +// #### Method +// +// Bilinear transform scaled for exact mapping of w1. +// +// #### Reference +// +//---------------------------------------------- +declare tf2s author "Julius O. Smith III"; +declare tf2s copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf2s license "MIT-style STK-4.3 license"; +tf2s(b2,b1,b0,a1,a0,w1) = tf2(b0d,b1d,b2d,a1d,a2d) +with { + c = 1/tan(w1*0.5/ma.SR); // bilinear-transform scale-factor + csq = c*c; + d = a0 + a1 * c + csq; + b0d = (b0 + b1 * c + b2 * csq)/d; + b1d = 2 * (b0 - b2 * csq)/d; + b2d = (b0 - b1 * c + b2 * csq)/d; + a1d = 2 * (a0 - csq)/d; + a2d = (a0 - a1*c + csq)/d; +}; + +// tf2snp = tf2s but using a protected normalized ladder filter for tf2: +tf2snp(b2,b1,b0,a1,a0,w1) = tf2np(b0d,b1d,b2d,a1d,a2d) +with { + c = 1/tan(w1*0.5/ma.SR); // bilinear-transform scale-factor + csq = c*c; + d = a0 + a1 * c + csq; + b0d = (b0 + b1 * c + b2 * csq)/d; + b1d = 2 * (b0 - b2 * csq)/d; + b2d = (b0 - b1 * c + b2 * csq)/d; + a1d = 2 * (a0 - csq)/d; + a2d = (a0 - a1*c + csq)/d; +}; + +//-----------------------------`(fi.)tf1snp`------------------------------- +// First-order special case of tf2snp above. +// +// #### Usage +// +// ``` +// _ : tf1snp(b1,b0,a0) : _ +// ``` +//---------------------------------------------- +declare tf1snp author "Julius O. Smith III"; +declare tf1snp copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf1snp license "MIT-style STK-4.3 license"; +tf1snp(b1,b0,a0,w1) = fi.tf2snp(b1,b0,0,a0,0,w1); // FIXME: Faust compiler does not fully optimize - does C++? + +//-----------------------------`(fi.)tf3slf`------------------------------- +// Analogous to `tf2s` above, but third order, and using the typical +// low-frequency-matching bilinear-transform constant 2/T ("lf" series) +// instead of the specific-frequency-matching value used in `tf2s` and `tf1s`. +// Note the lack of a "w1" argument. +// +// #### Usage +// +// ``` +// _ : tf3slf(b3,b2,b1,b0,a3,a2,a1,a0) : _ +// ``` +//---------------------------------------------- +declare tf3slf author "Julius O. Smith III"; +declare tf3slf copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf3slf license "MIT-style STK-4.3 license"; +tf3slf(b3,b2,b1,b0,a3,a2,a1,a0) = tf3(b0d,b1d,b2d,b3d,a1d,a2d,a3d) with { + c = 2.0 * ma.SR; // bilinear-transform scale-factor ("lf" case) + csq = c*c; + cc = csq*c; + // Thank you maxima: + b3d = (b3*c^3-b2*c^2+b1*c-b0)/d; + b2d = (-3*b3*c^3+b2*c^2+b1*c-3*b0)/d; + b1d = (3*b3*c^3+b2*c^2-b1*c-3*b0)/d; + b0d = (-b3*c^3-b2*c^2-b1*c-b0)/d; + a3d = (a3*c^3-a2*c^2+a1*c-a0)/d; + a2d = (-3*a3*c^3+a2*c^2+a1*c-3*a0)/d; + a1d = (3*a3*c^3+a2*c^2-a1*c-3*a0)/d; + d = (-a3*c^3-a2*c^2-a1*c-a0); +}; + +//-----------------------------`(fi.)tf1s`-------------------------------- +// First-order direct-form digital filter, +// specified by ANALOG transfer-function polynomials B(s)/A(s), +// and a frequency-scaling parameter. +// +// #### Usage +// +// ``` +// _ : tf1s(b1,b0,a0,w1) : _ +// ``` +// Where: +// +// b1 s + b0 +// H(s) = ---------- +// s + a0 +// +// and `w1` is the desired digital frequency (in radians/second) +// corresponding to analog frequency 1 rad/sec (i.e., `s = j`). +// +// #### Example test program +// +// A first-order ANALOG Butterworth lowpass filter, +// normalized to have cutoff frequency at 1 rad/sec, +// has transfer function: +// +// 1 +// H(s) = ------- +// s + 1 +// +// so `b0 = a0 = 1` and `b1 = 0`. Therefore, a DIGITAL first-order +// Butterworth lowpass with gain -3dB at `SR/4` is specified as +// +// ``` +// tf1s(0,1,1,PI*SR/2); // digital half-band order 1 Butterworth +// ``` +// +// #### Method +// +// Bilinear transform scaled for exact mapping of w1. +// +// #### Reference +// +//---------------------------------------------- +declare tf1s author "Julius O. Smith III"; +declare tf1s copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf1s license "MIT-style STK-4.3 license"; +tf1s(b1,b0,a0,w1) = tf1(b0d,b1d,a1d) +with { + c = 1/tan(w1*0.5/ma.SR); // bilinear-transform scale-factor + d = a0 + c; + b1d = (b0 - b1*c) / d; + b0d = (b0 + b1*c) / d; + a1d = (a0 - c) / d; +}; + +//-----------------------------`(fi.)tf2sb`-------------------------------- +// Bandpass mapping of `tf2s`: In addition to a frequency-scaling parameter +// `w1` (set to HALF the desired passband width in rad/sec), +// there is a desired center-frequency parameter wc (also in rad/s). +// Thus, `tf2sb` implements a fourth-order digital bandpass filter section +// specified by the coefficients of a second-order analog lowpass prototype +// section. Such sections can be combined in series for higher orders. +// The order of mappings is (1) frequency scaling (to set lowpass cutoff w1), +// (2) bandpass mapping to wc, then (3) the bilinear transform, with the +// usual scale parameter `2*SR`. Algebra carried out in maxima and pasted here. +// +// #### Usage +// +// ``` +// _ : tf2sb(b2,b1,b0,a1,a0,w1,wc) : _ +// ``` +//---------------------------------------------- +declare tf2sb author "Julius O. Smith III"; +declare tf2sb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf2sb license "MIT-style STK-4.3 license"; +tf2sb(b2,b1,b0,a1,a0,w1,wc) = + iir((b0d/a0d,b1d/a0d,b2d/a0d,b3d/a0d,b4d/a0d),(a1d/a0d,a2d/a0d,a3d/a0d,a4d/a0d)) with { + T = 1.0/float(ma.SR); + b0d = (4*b0*w1^2+8*b2*wc^2)*T^2+8*b1*w1*T+16*b2; + b1d = 4*b2*wc^4*T^4+4*b1*wc^2*w1*T^3-16*b1*w1*T-64*b2; + b2d = 6*b2*wc^4*T^4+(-8*b0*w1^2-16*b2*wc^2)*T^2+96*b2; + b3d = 4*b2*wc^4*T^4-4*b1*wc^2*w1*T^3+16*b1*w1*T-64*b2; + b4d = (b2*wc^4*T^4-2*b1*wc^2*w1*T^3+(4*b0*w1^2+8*b2*wc^2)*T^2-8*b1*w1*T+16*b2) + + b2*wc^4*T^4+2*b1*wc^2*w1*T^3; + a0d = wc^4*T^4+2*a1*wc^2*w1*T^3+(4*a0*w1^2+8*wc^2)*T^2+8*a1*w1*T+16; + a1d = 4*wc^4*T^4+4*a1*wc^2*w1*T^3-16*a1*w1*T-64; + a2d = 6*wc^4*T^4+(-8*a0*w1^2-16*wc^2)*T^2+96; + a3d = 4*wc^4*T^4-4*a1*wc^2*w1*T^3+16*a1*w1*T-64; + a4d = wc^4*T^4-2*a1*wc^2*w1*T^3+(4*a0*w1^2+8*wc^2)*T^2-8*a1*w1*T+16; +}; + +//-----------------------------`(fi.)tf1sb`-------------------------------- +// First-to-second-order lowpass-to-bandpass section mapping, +// analogous to tf2sb above. +// +// #### Usage +// +// ``` +// _ : tf1sb(b1,b0,a0,w1,wc) : _ +// ``` +//---------------------------------------------- +declare tf1sb author "Julius O. Smith III"; +declare tf1sb copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare tf1sb license "MIT-style STK-4.3 license"; +tf1sb(b1,b0,a0,w1,wc) = tf2(b0d/a0d,b1d/a0d,b2d/a0d,a1d/a0d,a2d/a0d) with { + T = 1.0/float(ma.SR); + a0d = wc^2*T^2+2*a0*w1*T+4; + b0d = b1*wc^2*T^2 +2*b0*w1*T+4*b1; + b1d = 2*b1*wc^2*T^2-8*b1; + b2d = b1*wc^2*T^2-2*b0*w1*T+4*b1; + a1d = 2*wc^2*T^2-8; + a2d = wc^2*T^2-2*a0*w1*T+4; +}; + +//==============================Simple Resonator Filters================================== +//======================================================================================== + +//------------------`(fi.)resonlp`----------------- +// Simple resonant lowpass filter based on `tf2s` (virtual analog). +// `resonlp` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : resonlp(fc,Q,gain) : _ +// _ : resonhp(fc,Q,gain) : _ +// _ : resonbp(fc,Q,gain) : _ +// +// ``` +// +// Where: +// +// * `fc`: center frequency (Hz) +// * `Q`: q +// * `gain`: gain (0-1) +//--------------------------------------------------------------------- +// resonlp = 2nd-order lowpass with corner resonance: +declare resonlp author "Julius O. Smith III"; +declare resonlp copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare resonlp license "MIT-style STK-4.3 license"; +resonlp(fc,Q,gain) = tf2s(b2,b1,b0,a1,a0,wc) +with { + wc = 2*ma.PI*fc; + a1 = 1/Q; + a0 = 1; + b2 = 0; + b1 = 0; + b0 = gain; +}; + + +//------------------`(fi.)resonhp`----------------- +// Simple resonant highpass filters based on `tf2s` (virtual analog). +// `resonhp` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : resonlp(fc,Q,gain) : _ +// _ : resonhp(fc,Q,gain) : _ +// _ : resonbp(fc,Q,gain) : _ +// +// ``` +// +// Where: +// +// * `fc`: center frequency (Hz) +// * `Q`: q +// * `gain`: gain (0-1) +//--------------------------------------------------------------------- +// resonhp = 2nd-order highpass with corner resonance: +declare resonhp author "Julius O. Smith III"; +declare resonhp copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare resonhp license "MIT-style STK-4.3 license"; +resonhp(fc,Q,gain,x) = gain*x-resonlp(fc,Q,gain,x); + + +//------------------`(fi.)resonbp`----------------- +// Simple resonant bandpass filters based on `tf2s` (virtual analog). +// `resonbp` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : resonlp(fc,Q,gain) : _ +// _ : resonhp(fc,Q,gain) : _ +// _ : resonbp(fc,Q,gain) : _ +// +// ``` +// +// Where: +// +// * `fc`: center frequency (Hz) +// * `Q`: q +// * `gain`: gain (0-1) +//--------------------------------------------------------------------- +// resonbp = 2nd-order bandpass +declare resonbp author "Julius O. Smith III"; +declare resonbp copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare resonbp license "MIT-style STK-4.3 license"; +resonbp(fc,Q,gain) = tf2s(b2,b1,b0,a1,a0,wc) +with { + wc = 2*ma.PI*fc; + a1 = 1/Q; + a0 = 1; + b2 = 0; + b1 = gain; + b0 = 0; +}; + + +//======================Butterworth Lowpass/Highpass Filters============================== +//======================================================================================== + +//----------------`(fi.)lowpass`-------------------- +// Nth-order Butterworth lowpass filter. +// `lowpass` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : lowpass(N,fc) : _ +// ``` +// +// Where: +// +// * `N`: filter order (number of poles) [nonnegative constant numerical expression] +// * `fc`: desired cut-off frequency (-3dB frequency) in Hz +// +// #### References +// * +// * `butter` function in Octave `("[z,p,g] = butter(N,1,'s');")` +//------------------------------ +declare lowpass author "Julius O. Smith III"; +declare lowpass copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare lowpass license "MIT-style STK-4.3 license"; +lowpass(N,fc) = lowpass0_highpass1(0,N,fc); + + +//----------------`(fi.)highpass`-------------------- +// Nth-order Butterworth highpass filters. +// `highpass` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : highpass(N,fc) : _ +// ``` +// +// Where: +// +// * `N`: filter order (number of poles) [nonnegative constant numerical expression] +// * `fc`: desired cut-off frequency (-3dB frequency) in Hz +// +// #### References +// * +// * `butter` function in Octave `("[z,p,g] = butter(N,1,'s');")` +//------------------------------ +declare highpass author "Julius O. Smith III"; +declare highpass copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare higpass license "MIT-style STK-4.3 license"; +highpass(N,fc) = lowpass0_highpass1(1,N,fc); + + +//-------------`(fi.)lowpass0_highpass1`-------------- +declare lowpass0_highpass1 author "Julius O. Smith III"; +declare lowpass0_highpass1 "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare lowpass0_highpass1 "MIT-style STK-4.3 license"; +lowpass0_highpass1(s,N,fc) = lphpr(s,N,N,fc) +with { + lphpr(s,0,N,fc) = _; + lphpr(s,1,N,fc) = tf1s(s,1-s,1,2*ma.PI*fc); + lphpr(s,O,N,fc) = lphpr(s,(O-2),N,fc) : tf2s(s,0,1-s,a1s,1,w1) with { + parity = N % 2; + S = (O-parity)/2; // current section number + a1s = -2*cos((ma.PI)*-1 + (1-parity)*ma.PI/(2*N) + (S-1+parity)*ma.PI/N); + w1 = 2*ma.PI*fc; + }; +}; + + +//================Special Filter-Bank Delay-Equalizing Allpass Filters==================== +// These special allpass filters are needed by filterbank et al. below. +// They are equivalent to (`lowpass(N,fc)` +|- `highpass(N,fc))/2`, but with +// canceling pole-zero pairs removed (which occurs for odd N). +//======================================================================================== + +//--------------------`(fi.)lowpass_plus`|`minus_highpass`---------------- +declare highpass_plus_lowpass author "Julius O. Smith III"; +declare highpass_plus_lowpass copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass_plus_lowpass license "MIT-style STK-4.3 license"; +highpass_plus_lowpass(1,fc) = _; +highpass_plus_lowpass(3,fc) = tf2s(1,-1,1,1,1,w1) with { w1 = 2*ma.PI*fc; }; +highpass_plus_lowpass(5,fc) = tf2s(1,-a11,1,a11,1,w1) +with { + a11 = 1.618033988749895; + w1 = 2*ma.PI*fc; +}; + +// Catch-all definitions for generality - even order is done: +highpass_plus_lowpass(N,fc) = _ <: switch_odd_even(N%2,N,fc) with { + switch_odd_even(0,N,fc) = highpass_plus_lowpass_even(N,fc); + switch_odd_even(1,N,fc) = highpass_plus_lowpass_odd(N,fc); +}; + +declare highpass_minus_lowpass author "Julius O. Smith III"; +declare highpass_minus_lowpass copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass_minus_lowpass license "MIT-style STK-4.3 license"; +highpass_minus_lowpass(3,fc) = tf1s(-1,1,1,w1) with { w1 = 2*ma.PI*fc; }; +highpass_minus_lowpass(5,fc) = tf1s(1,-1,1,w1) : tf2s(1,-a12,1,a12,1,w1) +with { + a12 = 0.618033988749895; + w1 = 2*ma.PI*fc; +}; + +// Catch-all definitions for generality - even order is done: +highpass_minus_lowpass(N,fc) = _ <: switch_odd_even(N%2,N,fc) with { + switch_odd_even(0,N,fc) = highpass_minus_lowpass_even(N,fc); + switch_odd_even(1,N,fc) = highpass_minus_lowpass_odd(N,fc); +}; + +declare highpass_plus_lowpass_even author "Julius O. Smith III"; +declare highpass_plus_lowpass_even copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass_plus_lowpass_even license "MIT-style STK-4.3 license"; +highpass_plus_lowpass_even(N,fc) = highpass(N,fc) + lowpass(N,fc); + +declare highpass_minus_lowpass_even author "Julius O. Smith III"; +declare highpass_minus_lowpass_even copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass_plus_lowpass_even license "MIT-style STK-4.3 license"; +highpass_minus_lowpass_even(N,fc) = highpass(N,fc) - lowpass(N,fc); + +declare highpass_plus_lowpass_odd author "Julius O. Smith III"; +declare highpass_plus_lowpass_odd copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass_plus_lowpass_odd license "MIT-style STK-4.3 license"; +// FIXME: Rewrite the following, as for orders 3 and 5 above, +// to eliminate pole-zero cancellations: +highpass_plus_lowpass_odd(N,fc) = highpass(N,fc) + lowpass(N,fc); + +declare highpass_minus_lowpass_odd author "Julius O. Smith III"; +declare highpass_minus_lowpass_odd copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass_plus_lowpass_odd license "MIT-style STK-4.3 license"; +// FIXME: Rewrite the following, as for orders 3 and 5 above, +// to eliminate pole-zero cancellations: +highpass_minus_lowpass_odd(N,fc) = highpass(N,fc) - lowpass(N,fc); + + +//==========================Elliptic (Cauer) Lowpass Filters============================== +// Elliptic (Cauer) Lowpass Filters +// +// #### References +// * +// * functions `ncauer` and `ellip` in Octave. +//======================================================================================== + +//-----------------------------`(fi.)lowpass3e`----------------------------- +// Third-order Elliptic (Cauer) lowpass filter. +// +// #### Usage +// +// ``` +// _ : lowpass3e(fc) : _ +// ``` +// +// Where: +// +// * `fc`: -3dB frequency in Hz +// +// #### Design +// +// For spectral band-slice level display (see `octave_analyzer3e`): +// +// ``` +// [z,p,g] = ncauer(Rp,Rs,3); % analog zeros, poles, and gain, where +// Rp = 60 % dB ripple in stopband +// Rs = 0.2 % dB ripple in passband +// ``` +//--------------------------------------------------------------------- +declare lowpass3e author "Julius O. Smith III"; +declare lowpass3e copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare lowpass3e license "MIT-style STK-4.3 license"; +lowpass3e(fc) = tf2s(b21,b11,b01,a11,a01,w1) : tf1s(0,1,a02,w1) +with { + a11 = 0.802636764161030; // format long; poly(p(1:2)) % in octave + a01 = 1.412270893774204; + a02 = 0.822445908998816; // poly(p(3)) % in octave + b21 = 0.019809144837789; // poly(z) + b11 = 0; + b01 = 1.161516418982696; + w1 = 2*ma.PI*fc; +}; + +//-----------------------------`(fi.)lowpass6e`----------------------------- +// Sixth-order Elliptic/Cauer lowpass filter. +// +// #### Usage +// +// ``` +// _ : lowpass6e(fc) : _ +// ``` +// +// Where: +// +// * `fc`: -3dB frequency in Hz +// +// #### Design +// +// For spectral band-slice level display (see octave_analyzer6e): +// +// ``` +// [z,p,g] = ncauer(Rp,Rs,6); % analog zeros, poles, and gain, where +// Rp = 80 % dB ripple in stopband +// Rs = 0.2 % dB ripple in passband +// ``` +//---------------------------------------------------------------------- +declare lowpass6e author "Julius O. Smith III"; +declare lowpass6e copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare lowpass6e license "MIT-style STK-4.3 license"; +lowpass6e(fc) = + tf2s(b21,b11,b01,a11,a01,w1) : + tf2s(b22,b12,b02,a12,a02,w1) : + tf2s(b23,b13,b03,a13,a03,w1) +with { + b21 = 0.000099999997055; + a21 = 1; + b11 = 0; + a11 = 0.782413046821645; + b01 = 0.000433227200555; + a01 = 0.245291508706160; + b22 = 1; + a22 = 1; + b12 = 0; + a12 = 0.512478641889141; + b02 = 7.621731298870603; + a02 = 0.689621364484675; + b23 = 1; + a23 = 1; + b13 = 0; + a13 = 0.168404871113589; + b03 = 53.536152954556727; + a03 = 1.069358407707312; + w1 = 2*ma.PI*fc; +}; + + +//=========================Elliptic Highpass Filters====================================== +//======================================================================================== + +//-----------------------------`(fi.)highpass3e`----------------------------- +// Third-order Elliptic (Cauer) highpass filter. Inversion of `lowpass3e` wrt unit +// circle in s plane (s <- 1/s). +// +// #### Usage +// +// ``` +// _ : highpass3e(fc) : _ +// ``` +// +// Where: +// +// * `fc`: -3dB frequency in Hz +//------------------------------------------------------------------------- +declare highpass3e author "Julius O. Smith III"; +declare highpass3e copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass3e license "MIT-style STK-4.3 license"; +highpass3e(fc) = tf2s(b01/a01,b11/a01,b21/a01,a11/a01,1/a01,w1) : + tf1s(1/a02,0,1/a02,w1) +with { + a11 = 0.802636764161030; + a01 = 1.412270893774204; + a02 = 0.822445908998816; + b21 = 0.019809144837789; + b11 = 0; + b01 = 1.161516418982696; + w1 = 2*ma.PI*fc; +}; + +//-----------------------------`(fi.)highpass6e`----------------------------- +// Sixth-order Elliptic/Cauer highpass filter. Inversion of `lowpass3e` wrt unit +// circle in s plane (s <- 1/s). +// +// #### Usage +// +// ``` +// _ : highpass6e(fc) : _ +// ``` +// +// Where: +// +// * `fc`: -3dB frequency in Hz +//------------------------------------------------------------------------- +declare highpass6e author "Julius O. Smith III"; +declare highpass6e copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highpass6e license "MIT-style STK-4.3 license"; +highpass6e(fc) = + tf2s(b01/a01,b11/a01,b21/a01,a11/a01,1/a01,w1) : + tf2s(b02/a02,b12/a02,b22/a02,a12/a02,1/a02,w1) : + tf2s(b03/a03,b13/a03,b23/a03,a13/a03,1/a03,w1) +with { + b21 = 0.000099999997055; + a21 = 1; + b11 = 0; + a11 = 0.782413046821645; + b01 = 0.000433227200555; + a01 = 0.245291508706160; + b22 = 1; + a22 = 1; + b12 = 0; + a12 = 0.512478641889141; + b02 = 7.621731298870603; + a02 = 0.689621364484675; + b23 = 1; + a23 = 1; + b13 = 0; + a13 = 0.168404871113589; + b03 = 53.536152954556727; + a03 = 1.069358407707312; + w1 = 2*ma.PI*fc; +}; + + +//========================Butterworth Bandpass/Bandstop Filters=========================== +//======================================================================================== + +//--------------------`(fi.)bandpass`---------------- +// Order 2*Nh Butterworth bandpass filter made using the transformation +// `s <- s + wc^2/s` on `lowpass(Nh)`, where `wc` is the desired bandpass center +// frequency. The `lowpass(Nh)` cutoff `w1` is half the desired bandpass width. +// `bandpass` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : bandpass(Nh,fl,fu) : _ +// ``` +// +// Where: +// +// * `Nh`: HALF the desired bandpass order (which is therefore even) +// * `fl`: lower -3dB frequency in Hz +// * `fu`: upper -3dB frequency in Hz +// Thus, the passband width is `fu-fl`, +// and its center frequency is `(fl+fu)/2`. +// +// #### Reference +// +//------------------------------------------------------------------------- +declare bandpass author "Julius O. Smith III"; +declare bandpass copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare bandpass license "MIT-style STK-4.3 license"; +bandpass(Nh,fl,fu) = bandpass0_bandstop1(0,Nh,fl,fu); + + +//--------------------`(fi.)bandstop`---------------- +// Order 2*Nh Butterworth bandstop filter made using the transformation +// `s <- s + wc^2/s` on `highpass(Nh)`, where `wc` is the desired bandpass center +// frequency. The `highpass(Nh)` cutoff `w1` is half the desired bandpass width. +// `bandstop` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : bandstop(Nh,fl,fu) : _ +// ``` +// Where: +// +// * `Nh`: HALF the desired bandstop order (which is therefore even) +// * `fl`: lower -3dB frequency in Hz +// * `fu`: upper -3dB frequency in Hz +// Thus, the passband (stopband) width is `fu-fl`, +// and its center frequency is `(fl+fu)/2`. +// +// #### Reference +// +//------------------------------------------------------------------------- +declare bandstop author "Julius O. Smith III"; +declare bandstop copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare bandstop license "MIT-style STK-4.3 license"; +bandstop(Nh,fl,fu) = bandpass0_bandstop1(1,Nh,fl,fu); + +declare bandpass0_bandstop1 author "Julius O. Smith III"; +declare bandpass0_bandstop1 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare bandpass0_bandstop1 license "MIT-style STK-4.3 license"; +bandpass0_bandstop1(s,Nh,fl,fu) = bpbsr(s,Nh,Nh,fl,fu) +with { + wl = 2*ma.PI*fl; // digital (z-plane) lower passband edge + wu = 2*ma.PI*fu; // digital (z-plane) upper passband edge + + c = 2.0*ma.SR; // bilinear transform scaling used in tf2sb, tf1sb + wla = c*tan(wl/c); // analog (s-plane) lower cutoff + wua = c*tan(wu/c); // analog (s-plane) upper cutoff + + wc = sqrt(wla*wua); // s-plane center frequency + w1 = wua - wc^2/wua; // s-plane lowpass prototype cutoff + + bpbsr(s,0,Nh,fl,fu) = _; + bpbsr(s,1,Nh,fl,fu) = tf1sb(s,1-s,1,w1,wc); + bpbsr(s,O,Nh,fl,fu) = bpbsr(s,O-2,Nh,fl,fu) : tf2sb(s,0,(1-s),a1s,1,w1,wc) + with { + parity = Nh % 2; + S = (O-parity)/2; // current section number + a1s = -2*cos(-1*ma.PI + (1-parity)*ma.PI/(2*Nh) + (S-1+parity)*ma.PI/Nh); + }; +}; + + +//===========================Elliptic Bandpass Filters==================================== +//======================================================================================== + +//---------------------`(fi.)bandpass6e`----------------------------- +// Order 12 elliptic bandpass filter analogous to `bandpass(6)`. +//-------------------------------------------------------------- +declare bandpass6e author "Julius O. Smith III"; +declare bandpass6e copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare bandpass6e license "MIT-style STK-4.3 license"; +bandpass6e(fl,fu) = tf2sb(b21,b11,b01,a11,a01,w1,wc) : tf1sb(0,1,a02,w1,wc) +with { + a11 = 0.802636764161030; // In octave: format long; poly(p(1:2)) + a01 = 1.412270893774204; + a02 = 0.822445908998816; // poly(p(3)) + b21 = 0.019809144837789; // poly(z) + b11 = 0; + b01 = 1.161516418982696; + + wl = 2*ma.PI*fl; // digital (z-plane) lower passband edge + wu = 2*ma.PI*fu; // digital (z-plane) upper passband edge + + c = 2.0*ma.SR; // bilinear transform scaling used in tf2sb, tf1sb + wla = c*tan(wl/c); // analog (s-plane) lower cutoff + wua = c*tan(wu/c); // analog (s-plane) upper cutoff + + wc = sqrt(wla*wua); // s-plane center frequency + w1 = wua - wc^2/wua; // s-plane lowpass cutoff +}; + +//----------------------`(fi.)bandpass12e`--------------------------- +// Order 24 elliptic bandpass filter analogous to `bandpass(6)`. +//-------------------------------------------------------------- +declare bandpass12e author "Julius O. Smith III"; +declare bandpass12e copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare bandpass12e license "MIT-style STK-4.3 license"; +bandpass12e(fl,fu) = + tf2sb(b21,b11,b01,a11,a01,w1,wc) : + tf2sb(b22,b12,b02,a12,a02,w1,wc) : + tf2sb(b23,b13,b03,a13,a03,w1,wc) +with { // octave script output: + b21 = 0.000099999997055; + a21 = 1; + b11 = 0; + a11 = 0.782413046821645; + b01 = 0.000433227200555; + a01 = 0.245291508706160; + b22 = 1; + a22 = 1; + b12 = 0; + a12 = 0.512478641889141; + b02 = 7.621731298870603; + a02 = 0.689621364484675; + b23 = 1; + a23 = 1; + b13 = 0; + a13 = 0.168404871113589; + b03 = 53.536152954556727; + a03 = 1.069358407707312; + + wl = 2*ma.PI*fl; // digital (z-plane) lower passband edge + wu = 2*ma.PI*fu; // digital (z-plane) upper passband edge + + c = 2.0*ma.SR; // bilinear transform scaling used in tf2sb, tf1sb + wla = c*tan(wl/c); // analog (s-plane) lower cutoff + wua = c*tan(wu/c); // analog (s-plane) upper cutoff + + wc = sqrt(wla*wua); // s-plane center frequency + w1 = wua - wc^2/wua; // s-plane lowpass cutoff +}; + +//------------------------`(fi.)pospass`--------------------------- +// Positive-Pass Filter (single-side-band filter). +// +// #### Usage +// +// ``` +// _ : pospass(N,fc) : _,_ +// ``` +// +// where +// +// * `N`: filter order (Butterworth bandpass for positive frequencies). +// * `fc`: lower bandpass cutoff frequency in Hz. +// - Highpass cutoff frequency at ma.SR/2 - fc Hz. +// +// #### Example test program +// +// * See `dm.pospass_demo` +// * Look at frequency response +// +// #### Method +// +// A filter passing only positive frequencies can be made from a +// half-band lowpass by modulating it up to the positive-frequency range. +// Equivalently, down-modulate the input signal using a complex sinusoid at -SR/4 Hz, +// lowpass it with a half-band filter, and modulate back up by SR/4 Hz. +// In Faust/math notation: +// $$pospass(N) = \ast(e^{-j\frac{\pi}{2}n}) : \mbox{lowpass(N,SR/4)} : \ast(e^{j\frac{\pi}{2}n})$$ +// +// An approximation to the Hilbert transform is given by the +// imaginary output signal: +// +// ``` +// hilbert(N) = pospass(N) : !,*(2); +// ``` +// +// #### References +// * +// * +// * +//------------------------------------------------------------ +declare pospass author "Julius O. Smith III"; +declare pospass copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare pospass license "MIT-style STK-4.3 license"; +pospass(N,fc) = fi.pospass0(lpf) with { + fcs = ma.SR/4 - fc; // Upper lowpass cutoff = (SR/2 - fc) - SR/4 + lpf = fi.lowpass(N,fcs); // Butterworth lowpass +}; + +declare pospass6e author "Julius O. Smith III"; +declare pospass6e copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare pospass6e license "MIT-style STK-4.3 license"; +pospass6e(fc) = fi.pospass0(lpf) with { + lpf = fi.lowpass6e(ma.SR/4 - fc); // Elliptic lowpass, order 6 +}; + +declare pospass0 author "Julius O. Smith III"; +declare pospass0 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare pospass0 license "MIT-style STK-4.3 license"; +pospass0(lpf) = unmodulate : lpf, lpf : modulate with { + c = 1-1' : +~(*(-1):mem); // complex sinusoid rotating at SR/4 + s = c'; // ||: 0, 1, 0, -1 :|| + unmodulate = _ <: *(c),*(-s); // subtract SR/4 from all input frequencies + modulate(x,y) = c*x-s*y, c*y + s*x; // add SR/4 to all frequencies +}; + + +//=================Parametric Equalizers (Shelf, Peaking)================================= +// Parametric Equalizers (Shelf, Peaking). +// +// #### References +// * +// * +// * Digital Audio Signal Processing, Udo Zolzer, Wiley, 1999, p. 124 +// * +// * +// * maxmsp.lib in the Faust distribution +// * bandfilter.dsp in the faust2pd distribution +//======================================================================================== + +//----------------------`(fi.)low_shelf`---------------------- +// First-order "low shelf" filter (gain boost|cut between dc and some frequency) +// `low_shelf` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : lowshelf(N,L0,fx) : _ +// _ : low_shelf(L0,fx) : _ // default case (order 3) +// _ : lowshelf_other_freq(N,L0,fx) : _ +// ``` +// +// Where: +// * `N`: filter order 1, 3, 5, ... (odd only, default should be 3, a constant numerical expression) +// * `L0`: desired level (dB) between dc and fx (boost `L0>0` or cut `L0<0`) +// * `fx`: -3dB frequency of lowpass band (`L0>0`) or upper band (`L0<0`) +// (see "SHELF SHAPE" below). +// +// The gain at SR/2 is constrained to be 1. +// The generalization to arbitrary odd orders is based on the well known +// fact that odd-order Butterworth band-splits are allpass-complementary +// (see filterbank documentation below for references). +// +// #### Shelf Shape +// The magnitude frequency response is approximately piecewise-linear +// on a log-log plot ("BODE PLOT"). The Bode "stick diagram" approximation +// L(lf) is easy to state in dB versus dB-frequency lf = dB(f): +// +// * L0 > 0: +// * L(lf) = L0, f between 0 and fx = 1st corner frequency; +// * L(lf) = L0 - N * (lf - lfx), f between fx and f2 = 2nd corner frequency; +// * L(lf) = 0, lf > lf2. +// * lf2 = lfx + L0/N = dB-frequency at which level gets back to 0 dB. +// * L0 < 0: +// * L(lf) = L0, f between 0 and f1 = 1st corner frequency; +// * L(lf) = - N * (lfx - lf), f between f1 and lfx = 2nd corner frequency; +// * L(lf) = 0, lf > lfx. +// * lf1 = lfx + L0/N = dB-frequency at which level goes up from L0. +// +// See `lowshelf_other_freq`. +// +// #### References +// See "Parametric Equalizers" above for references regarding +// `low_shelf`, `high_shelf`, and `peak_eq`. +// +//-------------------------------------------------------------- +declare lowshelf author "Julius O. Smith III"; +declare lowshelf copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare lowshelf license "MIT-style STK-4.3 license"; +lowshelf(N,L0,fx) = filterbank(N,(fx)) : _, *(ba.db2linear(L0)) :> _; + +// Special cases and optimization: +declare low_shelf author "Julius O. Smith III"; +declare low_shelf copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare low_shelf license "MIT-style STK-4.3 license"; +low_shelf = lowshelf(3); // default = 3rd order Butterworth + +declare low_shelf1 author "Julius O. Smith III"; +declare low_shelf1 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare low_shelf1 license "MIT-style STK-4.3 license"; +low_shelf1(L0,fx,x) = x + (ba.db2linear(L0)-1)*lowpass(1,fx,x); // optimized + +declare low_shelf1_l author "Julius O. Smith III"; +declare low_shelf1_l copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare low_shelf1_l license "MIT-style STK-4.3 license"; +low_shelf1_l(G0,fx,x) = x + (G0-1)*lowpass(1,fx,x); // optimized + +declare lowshelf_other_freq author "Julius O. Smith III"; +declare lowshelf_other_freq copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare lowshelf_other_freq license "MIT-style STK-4.3 license"; +lowshelf_other_freq(N, L0, fx) = ba.db2linear(ba.linear2db(fx) + L0/N); // convenience + +//-------------`(fi.)high_shelf`-------------- +// First-order "high shelf" filter (gain boost|cut above some frequency). +// `high_shelf` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : highshelf(N,Lpi,fx) : _ +// _ : high_shelf(L0,fx) : _ // default case (order 3) +// _ : highshelf_other_freq(N,Lpi,fx) : _ +// ``` +// +// Where: +// +// * `N`: filter order 1, 3, 5, ... (odd only, a constant numerical expression). +// * `Lpi`: desired level (dB) between fx and SR/2 (boost Lpi>0 or cut Lpi<0) +// * `fx`: -3dB frequency of highpass band (L0>0) or lower band (L0<0) +// (Use highshelf_other_freq() below to find the other one.) +// +// The gain at dc is constrained to be 1. +// See `lowshelf` documentation above for more details on shelf shape. +// +// #### References +// See "Parametric Equalizers" above for references regarding +// `low_shelf`, `high_shelf`, and `peak_eq`. +// +//-------------------------------------------------------------- +declare highshelf author "Julius O. Smith III"; +declare highshelf copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highshelf license "MIT-style STK-4.3 license"; +highshelf(N,Lpi,fx) = filterbank(N,(fx)) : *(ba.db2linear(Lpi)), _ :> _; +// Special cases and optimization: +high_shelf = highshelf(3); // default = 3rd order Butterworth + +declare high_shelf1 author "Julius O. Smith III"; +declare high_shelf1 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare high_shelf1 license "MIT-style STK-4.3 license"; +high_shelf1(Lpi,fx,x) = x + (ba.db2linear(Lpi)-1)*highpass(1,fx,x); // optimized + +declare high_shelf1_l author "Julius O. Smith III"; +declare high_shelf1_l copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare high_shelf1_l license "MIT-style STK-4.3 license"; +high_shelf1_l(Gpi,fx,x) = x + (Gpi-1)*highpass(1,fx,x); //optimized + +// shelf transitions between frequency fx and this one: +declare highshelf_other_freq author "Julius O. Smith III"; +declare highshelf_other_freq copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare highshelf_other_freq license "MIT-style STK-4.3 license"; +highshelf_other_freq(N, Lpi, fx) = ba.db2linear(ba.linear2db(fx) - Lpi/N); + + +//-------------------`(fi.)peak_eq`------------------------------ +// Second order "peaking equalizer" section (gain boost or cut near some frequency) +// Also called a "parametric equalizer" section. +// `peak_eq` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : peak_eq(Lfx,fx,B) : _ +// ``` +// +// Where: +// +// * `Lfx`: level (dB) at fx (boost Lfx>0 or cut Lfx<0) +// * `fx`: peak frequency (Hz) +// * `B`: bandwidth (B) of peak in Hz +// +// #### References +// See "Parametric Equalizers" above for references regarding +// `low_shelf`, `high_shelf`, and `peak_eq`. +// +//-------------------------------------------------------------- +declare peak_eq author "Julius O. Smith III"; +declare peak_eq copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare peak_eq license "MIT-style STK-4.3 license"; +peak_eq(Lfx,fx,B) = tf2s(1,b1s,1,a1s,1,wx) with { + T = float(1.0/ma.SR); + Bw = B*T/sin(wx*T); // prewarp s-bandwidth for more accuracy in z-plane + a1 = ma.PI*Bw; + b1 = g*a1; + g = ba.db2linear(abs(Lfx)); + b1s = select2(Lfx>0,a1,b1); // When Lfx>0, pole dominates bandwidth + a1s = select2(Lfx>0,b1,a1); // When Lfx<0, zero dominates + wx = 2*ma.PI*fx; +}; + +//--------------------`(fi.)peak_eq_cq`---------------------------- +// Constant-Q second order peaking equalizer section. +// +// #### Usage +// +// ``` +// _ : peak_eq_cq(Lfx,fx,Q) : _ +// ``` +// +// Where: +// +// * `Lfx`: level (dB) at fx +// * `fx`: boost or cut frequency (Hz) +// * `Q`: "Quality factor" = fx/B where B = bandwidth of peak in Hz +// +// #### References +// See "Parametric Equalizers" above for references regarding +// `low_shelf`, `high_shelf`, and `peak_eq`. +// +//------------------------------------------------------------ +declare peak_eq_cq author "Julius O. Smith III"; +declare peak_eq_cq copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare peak_eq_cq license "MIT-style STK-4.3 license"; +peak_eq_cq(Lfx,fx,Q) = peak_eq(Lfx,fx,fx/Q); + +//-------------------`(fi.)peak_eq_rm`-------------------------- +// Regalia-Mitra second order peaking equalizer section. +// +// #### Usage +// +// ``` +// _ : peak_eq_rm(Lfx,fx,tanPiBT) : _ +// ``` +// +// Where: +// +// * `Lfx`: level (dB) at fx +// * `fx`: boost or cut frequency (Hz) +// * `tanPiBT`: `tan(PI*B/SR)`, where B = -3dB bandwidth (Hz) when 10^(Lfx/20) = 0 +// ~ PI*B/SR for narrow bandwidths B +// +// #### Reference +// P.A. Regalia, S.K. Mitra, and P.P. Vaidyanathan, +// "The Digital All-Pass Filter: A Versatile Signal Processing Building Block" +// Proceedings of the IEEE, 76(1):19-37, Jan. 1988. (See pp. 29-30.) +// See also "Parametric Equalizers" above for references on shelf +// and peaking equalizers in general. +// +//------------------------------------------------------------ +declare peak_eq_rm author "Julius O. Smith III"; +declare peak_eq_rm copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare peak_eq_rm license "MIT-style STK-4.3 license"; +peak_eq_rm(Lfx,fx,tanPiBT) = _ <: _,A,_ : +,- : *(0.5),*(K/2.0) : + with { + A = tf2(k2, k1*(1+k2), 1, k1*(1+k2), k2) <: _,_; // allpass + k1 = 0.0 - cos(2.0*ma.PI*fx/ma.SR); + k2 = (1.0 - tanPiBT)/(1.0 + tanPiBT); + K = ba.db2linear(Lfx); +}; + + +//---------------------`(fi.)spectral_tilt`------------------------- +// Spectral tilt filter, providing an arbitrary spectral rolloff factor +// alpha in (-1,1), where +// -1 corresponds to one pole (-6 dB per octave), and +// +1 corresponds to one zero (+6 dB per octave). +// In other words, alpha is the slope of the ln magnitude versus ln frequency. +// For a "pinking filter" (e.g., to generate 1/f noise from white noise), +// set alpha to -1/2. +// +// #### Usage +// +// ``` +// _ : spectral_tilt(N,f0,bw,alpha) : _ +// ``` +// Where: +// +// * `N`: desired integer filter order (fixed at compile time) +// * `f0`: lower frequency limit for desired roll-off band > 0 +// * `bw`: bandwidth of desired roll-off band +// * `alpha`: slope of roll-off desired in nepers per neper, +// between -1 and 1 (ln mag / ln radian freq) +// +// #### Example test program +// +// See `dm.spectral_tilt_demo` and the documentation for `no.pink_noise`. +// +// #### Reference +// J.O. Smith and H.F. Smith, +// "Closed Form Fractional Integration and Differentiation via Real Exponentially Spaced Pole-Zero Pairs", +// arXiv.org publication arXiv:1606.06154 [cs.CE], June 7, 2016, +// +// +//------------------------------------------------------------ +declare spectral_tilt author "Julius O. Smith III"; +declare spectral_tilt copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare spectral_tilt license "MIT-style STK-4.3 license"; +spectral_tilt(N,f0,bw,alpha) = seq(i,N,sec(i)) with { + sec(i) = g * tf1s(b1,b0,a0,1) with { + g = a0/b0; // unity dc-gain scaling + b1 = 1.0; + b0 = mzh(i); + a0 = mph(i); + mzh(i) = prewarp(mz(i),ma.SR,w0); // prewarping for bilinear transform + mph(i) = prewarp(mp(i),ma.SR,w0); + prewarp(w,SR,wp) = wp * tan(w*T/2) / tan(wp*T/2) with { T = 1/ma.SR; }; + mz(i) = w0 * r ^ (-alpha+i); // minus zero i in s plane + mp(i) = w0 * r ^ i; // minus pole i in s plane + f0p = max(f0,ma.EPSILON); // cannot go to zero + w0 = 2 * ma.PI * f0p; // radian frequency of first pole + f1 = f0p + bw; // upper band limit + r = (f1/f0p)^(1.0/float(N-1)); // pole ratio (2 => octave spacing) + }; +}; + + +//----------------------`(fi.)levelfilter`---------------------- +// Dynamic level lowpass filter. +// `levelfilter` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : levelfilter(L,freq) : _ +// ``` +// +// Where: +// +// * `L`: desired level (in dB) at Nyquist limit (SR/2), e.g., -60 +// * `freq`: corner frequency (-3dB point) usually set to fundamental freq +// * `N`: Number of filters in series where L = L/N +// +// #### Reference +// +//------------------------------------------------------------ +declare levelfilter author "Julius O. Smith III"; +declare levelfilter copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare levelfilter license "MIT-style STK-4.3 license"; +levelfilter(L,freq,x) = (L * L0 * x) + ((1.0-L) * lp2out(x)) +with { + L0 = pow(L,1/3); + Lw = ma.PI*freq/ma.SR; // = w1 T / 2 + Lgain = Lw / (1.0 + Lw); + Lpole2 = (1.0 - Lw) / (1.0 + Lw); + lp2out = *(Lgain) : + ~ *(Lpole2); +}; + + +//----------------------`(fi.)levelfilterN`---------------------- +// Dynamic level lowpass filter. +// +// #### Usage +// +// ``` +// _ : levelfilterN(N,freq,L) : _ +// ``` +// +// Where: +// +// * `N`: Number of filters in series where L = L/N, a constant numerical expression +// * `freq`: corner frequency (-3dB point) usually set to fundamental freq +// * `L`: desired level (in dB) at Nyquist limit (SR/2), e.g., -60 +// +// #### Reference +// +//------------------------------------------------------------ +declare levelfilterN author "Julius O. Smith III"; +declare levelfilterN copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare levelfilterN license "MIT-style STK-4.3 license"; +levelfilterN(N,freq,L) = seq(i,N,levelfilter((L/N),freq)); + + +//=================================Mth-Octave Filter-Banks================================ +// Mth-octave filter-banks split the input signal into a bank of parallel signals, one +// for each spectral band. They are related to the Mth-Octave Spectrum-Analyzers in +// `analysis.lib`. +// The documentation of this library contains more details about the implementation. +// The parameters are: +// +// * `M`: number of band-slices per octave (>1), a constant numerical expression +// * `N`: total number of bands (>2), a constant numerical expression +// * `ftop`: upper bandlimit of the Mth-octave bands ( +//======================================================================================== + +//------------------------`(fi.)mth_octave_filterbank[n]`------------------------- +// Allpass-complementary filter banks based on Butterworth band-splitting. +// For Butterworth band-splits, the needed delay equalizer is easily found. +// +// #### Usage +// +// ``` +// _ : mth_octave_filterbank(O,M,ftop,N) : par(i,N,_) // Oth-order +// _ : mth_octave_filterbank_alt(O,M,ftop,N) : par(i,N,_) // dc-inverted version +// ``` +// +// Also for convenience: +// +// ``` +// _ : mth_octave_filterbank3(M,ftop,N) : par(i,N,_) // 3rd-order Butterworth +// _ : mth_octave_filterbank5(M,ftop,N) : par(i,N,_) // 5th-order Butterworth +// mth_octave_filterbank_default = mth_octave_filterbank5; +// ``` +// +// Where: +// +// * `O`: order of filter used to split each frequency band into two, a constant numerical expression +// * `M`: number of band-slices per octave, a constant numerical expression +// * `ftop`: highest band-split crossover frequency (e.g., 20 kHz) +// * `N`: total number of bands (including dc and Nyquist), a constant numerical expression +//------------------------------------------------------------ +declare mth_octave_filterbank author "Julius O. Smith III"; +declare mth_octave_filterbank copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare mth_octave_filterbank license "MIT-style STK-4.3 license"; +mth_octave_filterbank(O,M,ftop,N) = an.mth_octave_analyzer(O,M,ftop,N) : delayeq(N) +with { + fc(n) = ftop * 2^(float(n-N+1)/float(M)); // -3dB crossover frequencies + ap(n) = highpass_plus_lowpass(O,fc(n)); // delay-equalizing allpass + delayeq(N) = par(i,N-2,apchain(i+1)), _, _; + apchain(i) = seq(j,N-1-i,ap(j+1)); +}; + +// dc-inverted version. This reduces the delay-equalizer order for odd O. +// Negating the input signal makes the dc band noninverting +// and all higher bands sign-inverted (if preferred). +declare mth_octave_filterbank_alt author "Julius O. Smith III"; +declare mth_octave_filterbank_alt copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare mth_octave_filterbank_alt license "MIT-style STK-4.3 license"; +mth_octave_filterbank_alt(O,M,ftop,N) = an.mth_octave_analyzer(O,M,ftop,N) : delayeqi(O,N) +with { + fc(n) = ftop * 2^(float(n-N+1)/float(M)); // -3dB crossover frequencies + ap(n) = highpass_minus_lowpass(O,fc(n)); // half the order of 'plus' case + delayeqi(N) = par(i,N-2,apchain(i+1)), _, *(-1.0); + apchain(i) = seq(j,N-1-i,ap(j+1)); +}; + +// Note that even-order cases require complex coefficients. +// See Vaidyanathan 1993 and papers cited there for more info. +declare mth_octave_filterbank3 author "Julius O. Smith III"; +declare mth_octave_filterbank3 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare mth_octave_filterbank3 license "MIT-style STK-4.3 license"; +mth_octave_filterbank3(M,ftop,N) = mth_octave_filterbank_alt(3,M,ftop,N); + +declare mth_octave_filterbank5 author "Julius O. Smith III"; +declare mth_octave_filterbank5 copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare mth_octave_filterbank5 license "MIT-style STK-4.3 license"; +mth_octave_filterbank5(M,ftop,N) = mth_octave_filterbank(5,M,ftop,N); + +declare mth_octave_filterbank_default author "Julius O. Smith III"; +declare mth_octave_filterbank_default copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare mth_octave_filterbank_default license "MIT-style STK-4.3 license"; +mth_octave_filterbank_default = mth_octave_filterbank5; + + +//===============Arbitrary-Crossover Filter-Banks and Spectrum Analyzers================== +// These are similar to the Mth-octave analyzers above, except that the +// band-split frequencies are passed explicitly as arguments. +//======================================================================================== + +// ACKNOWLEDGMENT +// Technique for processing a variable number of signal arguments due +// to Yann Orlarey (as is the entire Faust framework!) + +//---------------`(fi.)filterbank`-------------------------- +// Filter bank. +// `filterbank` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : filterbank (O,freqs) : par(i,N,_) // Butterworth band-splits +// ``` +// Where: +// +// * `O`: band-split filter order (odd integer required for filterbank[i], a constant numerical expression) +// * `freqs`: (fc1,fc2,...,fcNs) [in numerically ascending order], where +// Ns=N-1 is the number of octave band-splits +// (total number of bands N=Ns+1). +// +// If frequencies are listed explicitly as arguments, enclose them in parens: +// +// ``` +// _ : filterbank(3,(fc1,fc2)) : _,_,_ +// ``` +//--------------------------------------------------- +declare filterbank author "Julius O. Smith III"; +declare filterbank copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare filterbank license "MIT-style STK-4.3 license"; +filterbank(O,lfreqs) = an.analyzer(O,lfreqs) : delayeq(nb) +with { + nb = ba.count(lfreqs); + fc(n) = ba.take(n, lfreqs); + ap(n) = highpass_plus_lowpass(O,fc(n)); + delayeq(1) = _,_; // par(i,0,...) does not fly + delayeq(nb) = par(i,nb-1,apchain(nb-1-i)),_,_; + apchain(0) = _; + apchain(i) = ap(i) : apchain(i-1); +}; + +//-----------------`(fi.)filterbanki`---------------------- +// Inverted-dc filter bank. +// +// #### Usage +// +// ``` +// _ : filterbanki(O,freqs) : par(i,N,_) // Inverted-dc version +// ``` +// +// Where: +// +// * `O`: band-split filter order (odd integer required for `filterbank[i]`, a constant numerical expression) +// * `freqs`: (fc1,fc2,...,fcNs) [in numerically ascending order], where +// Ns=N-1 is the number of octave band-splits +// (total number of bands N=Ns+1). +// +// If frequencies are listed explicitly as arguments, enclose them in parens: +// +// ``` +// _ : filterbanki(3,(fc1,fc2)) : _,_,_ +// ``` +//--------------------------------------------------- +declare filterbanki author "Julius O. Smith III"; +declare filterbanki copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare filterbanki license "MIT-style STK-4.3 license"; +filterbanki(O,lfreqs) = _ <: bsplit(nb) +with { + nb = ba.count(lfreqs); + fc(n) = ba.take(n, lfreqs); + lp(n) = lowpass(O,fc(n)); + hp(n) = highpass(O,fc(n)); + ap(n) = highpass_minus_lowpass(O,fc(n)); + bsplit(0) = *(-1.0); + bsplit(i) = (hp(i) : delayeq(i-1)), (lp(i) <: bsplit(i-1)); + delayeq(0) = _; // moving the *(-1) here inverts all outputs BUT dc + delayeq(i) = ap(i) : delayeq(i-1); +}; + + +//===============State Variable Filters========================================================= +// #### References +// Solving the continuous SVF equations using trapezoidal integration +// +// +//======================================================================================== + +//-----------------`(fi.)svf`---------------------- +// An environment with `lp`, `bp`, `hp`, `notch`, `peak`, `ap`, `bell`, `ls`, `hs` SVF based filters. +// All filters have `freq` and `Q` parameters, the `bell`, `ls`, `hs` ones also have a `gain` third parameter. +// +// #### Usage +// +// ``` +// _ : svf.xx(freq, Q, [gain]) : _ +// ``` +// +// Where: +// +// * `freq`: cut frequency +// * `Q`: quality factor +// * `[gain]`: gain in dB +// +/// ``` +//--------------------------------------------------- +declare svf author "Oleg Nesterov"; +declare svf copyright "Copyright (C) 2020 Oleg Nesterov "; +declare svf license "MIT-style STK-4.3 license"; + +svf = environment { + + // Internal implementation + svf(T,F,Q,G) = tick ~ (_,_) : !,!,si.dot(3, mix) + with { + tick(ic1eq, ic2eq, v0) = + 2*v1 - ic1eq, + 2*v2 - ic2eq, + v0, v1, v2 + with { + v1 = ic1eq + g *(v0-ic2eq) : /(1 + g*(g+k)); + v2 = ic2eq + g * v1; + }; + + A = pow(10.0, G/40.0); + + g = tan(F * ma.PI/ma.SR) : case { + (7) => /(sqrt(A)); + (8) => *(sqrt(A)); + (t) => _; + } (T); + + k = case { + (6) => 1/(Q*A); + (t) => 1/Q; + } (T); + + mix = case { + (0) => 0, 0, 1; + (1) => 0, 1, 0; + (2) => 1, -k, -1; + (3) => 1, -k, 0; + (4) => 1, -k, -2; + (5) => 1, -2*k, 0; + (6) => 1, k*(A*A-1), 0; + (7) => 1, k*(A-1), A*A-1; + (8) => A*A, k*(1-A)*A, 1-A*A; + } (T); + }; + + // External API + lp(f,q) = svf(0, f, q, 0); + bp(f,q) = svf(1, f, q, 0); + hp(f,q) = svf(2, f, q, 0); + notch(f,q) = svf(3, f, q, 0); + peak(f,q) = svf(4, f, q, 0); + ap(f,q) = svf(5, f, q, 0); + bell(f,q,g) = svf(6, f, q, g); + ls(f,q,g) = svf(7, f, q, g); + hs(f,q,g) = svf(8, f, q, g); +}; + + +//===========Linkwitz-Riley 4th-order 2-way, 3-way, and 4-way crossovers===== +// +// The Linkwitz-Riley (LR) crossovers are designed to produce a fully-flat +// magnitude response when their outputs are combined. The 4th-order +// LR filters (LR4) have a 24dB/octave slope and they are rather popular audio +// crossovers used in multi-band processing. +// +// The LR4 can be constructed by cascading two second-order Butterworth +// filters. For the second-order Butterworth filters, we will use the SVF +// filter implemented above by setting the Q-factor to 1.0 / sqrt(2.0). +// These will be cascaded in pairs to build the LR4 highpass and lowpass. +// For the phase correction, we will use the 2nd-order Butterworth allpass. +// +// #### Reference +// Zavalishin, Vadim. "The art of VA filter design." Native Instruments, Berlin, Germany (2012). +//============================================================================= + + +//----------`(fi.)lowpassLR4`--------------------------------------------------- +// 4th-order Linkwitz-Riley lowpass. +// +// #### Usage +// +// ``` +// _ : lowpassLR4(cf) : _ +// ``` +// +// Where: +// +// * `cf` is the lowpass cutoff in Hz +//------------------------------------------------------------------------------ +declare lowpassLR4 author "Dario Sanfilippo"; +declare lowpassLR4 copyright + "Copyright (C) 2022 Dario Sanfilippo "; +declare lowpassLR4 license "MIT-style STK-4.3 license"; +lowpassLR4(cf, x) = x : seq(i, 2, svf.lp(cf, 1.0 / sqrt(2.0))); + + +//----------`(fi.)highpassLR4`-------------------------------------------------- +// 4th-order Linkwitz-Riley highpass. +// +// #### Usage +// +// ``` +// _ : highpassLR4(cf) : _ +// ``` +// +// Where: +// +// * `cf` is the highpass cutoff in Hz +//------------------------------------------------------------------------------ +declare highpassLR4 author "Dario Sanfilippo"; +declare highpassLR4 copyright + "Copyright (C) 2022 Dario Sanfilippo "; +declare highpassLR4 license "MIT-style STK-4.3 license"; +highpassLR4(cf, x) = x : seq(i, 2, svf.hp(cf, 1.0 / sqrt(2.0))); + + +//----------`(fi.)crossover2LR4`------------------------------------------------ +// Two-way 4th-order Linkwitz-Riley crossover. +// +// #### Usage +// +// ``` +// _ : crossover2LR4(cf) : si.bus(2) +// ``` +// +// Where: +// +// * `cf` is the crossover split cutoff in Hz +//------------------------------------------------------------------------------ +declare crossover2LR4 author "Dario Sanfilippo"; +declare crossover2LR4 copyright + "Copyright (C) 2022 Dario Sanfilippo "; +declare crossover2LR4 license "MIT-style STK-4.3 license"; +crossover2LR4(cf, x) = lowpassLR4(cf, x) , highpassLR4(cf, x); + + +//----------`(fi.)crossover3LR4`------------------------------------------------ +// Three-way 4th-order Linkwitz-Riley crossover. +// +// #### Usage +// +// ``` +// _ : crossover3LR4(cf1, cf2) : si.bus(3) +// ``` +// +// Where: +// +// * `cf1` is the crossover lower split cutoff in Hz +// * `cf2` is the crossover upper split cutoff in Hz +//------------------------------------------------------------------------------ +declare crossover3LR4 author "Dario Sanfilippo"; +declare crossover3LR4 copyright + "Copyright (C) 2022 Dario Sanfilippo "; +declare crossover3LR4 license "MIT-style STK-4.3 license"; +crossover3LR4(cf1, cf2, x) = + crossover2LR4(cf1, x) : svf.ap(cf2, 1.0 / sqrt(2.0)) , crossover2LR4(cf2); + + +//----------`(fi.)crossover4LR4`------------------------------------------------ +// Four-way 4th-order Linkwitz-Riley crossover. +// +// #### Usage +// +// ``` +// _ : crossover4LR4(cf1, cf2, cf3) : si.bus(4) +// ``` +// +// Where: +// +// * `cf1` is the crossover lower split cutoff in Hz +// * `cf2` is the crossover mid split cutoff in Hz +// * `cf3` is the crossover upper split cutoff in Hz +//------------------------------------------------------------------------------ +declare crossover4LR4 author "Dario Sanfilippo"; +declare crossover4LR4 copyright + "Copyright (C) 2022 Dario Sanfilippo "; +declare crossover4LR4 license "MIT-style STK-4.3 license"; +crossover4LR4(cf1, cf2, cf3, x) = + crossover2LR4(cf2, x) : + svf.ap(cf3, 1.0 / sqrt(2.0)) , + svf.ap(cf1, 1.0 / sqrt(2.0)) : + crossover2LR4(cf1) , + crossover2LR4(cf3); + + +//----------`(fi.)crossover8LR4`------------------------------------------------ +// Eight-way 4th-order Linkwitz-Riley crossover. +// +// #### Usage +// +// ``` +// _ : crossover8LR4(cf1, cf2, cf3, cf4, cf5, cf6, cf7) : si.bus(8) +// ``` +// +// Where: +// +// * `cf1-cf7` are the crossover cutoff frequencies in Hz +//------------------------------------------------------------------------------ +declare crossover8LR4 author "Dario Sanfilippo"; +declare crossover8LR4 copyright + "Copyright (C) 2022 Dario Sanfilippo "; +declare crossover8LR4 license "MIT-style STK-4.3 license"; +crossover8LR4(cf1, cf2, cf3, cf4, cf5, cf6, cf7, x) = + crossover2LR4(cf4, x) : + (ap(cf6) : ap(cf5) : ap(cf7)) , + (ap(cf2) : ap(cf1) : ap(cf3)) : + crossover2LR4(cf2) , + crossover2LR4(cf6) : + ap(cf3) , + ap(cf1) , + ap(cf7) , + ap(cf5) : + crossover2LR4(cf1) , + crossover2LR4(cf3) , + crossover2LR4(cf5) , + crossover2LR4(cf7) + with { + ap(cf) = svf.ap(cf, 1.0 / sqrt(2.0)); + }; + + +//=========================== Standardized Filters ============================ +//============================================================================= +// +// This section provides filters that are defined by national or +// international standards, e.g. for measurement applications. + +//----------------------`(fi.)itu_r_bs_1770_4_kfilter`------------------------- +// The prefilter from Recommendation ITU-R BS.1770-4 for loudness +// measurement. Also known as "K-filter". The recommendation defines +// biquad filter coefficients for a fixed sample rate of 48kHz (page +// 4-5). Here, we construct biquads for arbitrary samplerates. The +// resulting filter is normalized, such that the magnitude at 997Hz is +// unity gain 1.0. +// +// Please note, the ITU-recommendation handles the normalization in +// equation (2) by subtracting 0.691dB, which is not needed with +// `itu_r_bs_1770_4_kfilter`. +// +// One option for future improvement might be, to round those filter +// coefficients, that are almost equal to one. Second, the maximum +// magnitude difference at 48kHz between the ITU-defined filter and +// `itu_r_bs_1770_4_kfilter` is 0.001dB, which obviously could be +// less. +// +// #### Usage +// +// ``` +// _ : itu_r_bs_1770_4_kfilter : _ +// ``` +// +// #### Reference +// +// +//----------------------------------------------------------------------------- +declare itu_r_bs_1770_4_kfilter author "Jakob Dübel"; +declare itu_r_bs_1770_4_kfilter copyright "Copyright (C) 2022 Jakob Dübel"; +declare itu_r_bs_1770_4_kfilter license "ISC license"; + +itu_r_bs_1770_4_kfilter = stage1 : stage2 : normalize997Hz +with { + freq2k(f_c) = tan((ma.PI * f_c)/ma.SR); + + stage1 = tf22t(b0,b1,b2,a1,a2) + with { + f_c = 1681.7632251028442; // Hertz + gain = 3.9997778685513232; // Decibel + K = freq2k(f_c); + V_0 = pow(10, (gain/20.0)); + + denominator = 1.0 + sqrt(2.0)*K + K^2; + b0 = (V_0 + sqrt((2.0*V_0))*K + K^2) / denominator; + b1 = 2.0*(K^2 - V_0) / denominator; + b2 = (V_0 - sqrt(2.0*V_0)*K + K^2) / denominator; + + a1 = 2*(K^2 - 1) / denominator; + a2 = (1 - sqrt(2.0)*K + K^2) / denominator; + }; + + stage2 = tf22t(b0,b1,b2,a1,a2) + with { + f_c = 38.135470876002174; // Hertz + Q = 0.5003270373223665; + K = freq2k(f_c); + + denominator = (K^2) * Q + K + Q; + b0 = Q / denominator; + b1 = -2*Q / denominator; + b2 = b0; + + a1 = (2*Q * (K^2 - 1)) / denominator; + a2 = ((K^2) * Q - K + Q) / denominator; + }; + + normalize997Hz = *(0.9273671710547968); +}; + + +//============================Averaging Functions============================== +//============================================================================= +// +// These are a set of samplerate independent averaging functions based on +// moving-average and one-pole filters with specific response characteristics. + +//----------------------------`(fi.)avg_rect`---------------------------------- +// Moving average. +// +// #### Usage +// +// ``` +// _ : avg_rect(period) : _ +// ``` +// +// Where: +// +// * `period` is the averaging frame in seconds +//----------------------------------------------------------------------------- +declare avg_rect author "Dario Sanfilippo and Julius O. Smith III"; +declare avg_rect copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare avg_rect license "MIT-style STK-4.3 license"; +avg_rect(period, x) = x : ba.slidingMean(rint(period * ma.SR)); + + +//----------------------------`(fi.)avg_tau`------------------------------------- +// Averaging function based on a one-pole filter and the tau response time. +// Tau represents the effective length of the one-pole impulse response, +// that is, tau is the integral of the filter's impulse response. This +// response is slower to reach the final value but has less ripples in +// non-steady signals. +// +// #### Usage +// +// ``` +// _ : avg_tau(period) : _ +// ``` +// +// Where: +// +// * `period` is the time, in seconds, for the system to decay by 1/e, +// or to reach 1-1/e of its final value. +// +// #### Reference +// +// +//----------------------------------------------------------------------------- +declare avg_tau author "Dario Sanfilippo and Julius O. Smith III"; +declare avg_tau copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare avg_tau license "MIT-style STK-4.3 license"; +avg_tau(period, x) = fi.lptau(period, x); + + +//----------------------------`(fi.)avg_t60`------------------------------------- +// Averaging function based on a one-pole filter and the t60 response time. +// This response is particularly useful when the system is required to +// reach the final value after about `period` seconds. +// +// #### Usage +// +// ``` +// _ : avg_t60(period) : _ +// ``` +// +// Where: +// +// * `period` is the time, in seconds, for the system to decay by 1/1000, +// or to reach 1-1/1000 of its final value. +// +// #### Reference +// +// +//----------------------------------------------------------------------------- +declare avg_t60 author "Dario Sanfilippo and Julius O. Smith III"; +declare avg_t60 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare avg_t60 license "MIT-style STK-4.3 license"; +avg_t60(period, x) = fi.lpt60(period, x); + + +//----------------------------`(fi.)avg_t19`------------------------------------- +// Averaging function based on a one-pole filter and the t19 response time. +// This response is close to the moving-average algorithm as it roughly reaches +// the final value after `period` seconds and shows about the same +// oscillations for non-steady signals. +// +// #### Usage +// +// ``` +// _ : avg_t19(period) : _ +// ``` +// +// Where: +// +// * `period` is the time, in seconds, for the system to decay by 1/e^2.2, +// or to reach 1-1/e^2.2 of its final value. +// +// #### Reference +// Zölzer, U. (2008). Digital audio signal processing (Vol. 9). New York: Wiley. +//----------------------------------------------------------------------------- +declare avg_t19 author "Dario Sanfilippo and Julius O. Smith III"; +declare avg_t19 copyright "Copyright (C) 2020 Dario Sanfilippo + and + 2003-2020 by Julius O. Smith III "; +declare avg_t19 license "MIT-style STK-4.3 license"; +avg_t19(period, x) = fi.lpt19(period, x); + + +/******************************************************************************* +# Licenses + +## STK 4.3 License + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +Any person wishing to distribute modifications to the Software is asked to send +the modifications to the original developer so that they can be incorporated +into the canonical version. For software copyrighted by Julius O. Smith III, +email your modifications to . This is, however, not a +binding provision of this license. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +## LGPL License + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU Lesser General Public License as published by the Free +Software Foundation; either version 2.1 of the License, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with the GNU C Library; if not, write to the Free Software Foundation, Inc., +59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. + +-------------------------------------------------------------------------------- + +## ISC License + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + +*******************************************************************************/ diff --git a/dist/examples/LIBRARIES/hoa.lib b/dist/examples/LIBRARIES/hoa.lib new file mode 100644 index 00000000..86231fef --- /dev/null +++ b/dist/examples/LIBRARIES/hoa.lib @@ -0,0 +1,1081 @@ +//################################### hoa.lib ############################################ +// Faust library for high order ambisonic. Its official prefix is `ho`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ + ************************************************************************ +FAUST library file +Copyright (C) 2003-2012 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. + + ************************************************************************ + ************************************************************************/ + +ma = library("maths.lib"); +si = library("signals.lib"); +ba = library("basics.lib"); +os = library("oscillators.lib"); +ho = library("hoa.lib"); +ro = library("routes.lib"); +de = library("delays.lib"); + +declare name "High Order Ambisonics library"; +declare version "0.4"; +declare author "Pierre Guillot"; +declare author "Eliott Paris"; +declare author "Julien Colafrancesco"; +declare author "Wargreen"; +declare author "Alain Bonardi"; +declare author "Paul Goutmann"; +declare copyright "2012-2013 Guillot, Paris, Colafrancesco, CICM labex art H2H, U. Paris 8, 2019 Wargreen, 2022 Bonardi, Goutmann"; + +//============================Encoding/decoding Functions================================= +//======================================================================================== + +//----------------------`(ho.)encoder`--------------------------------- +// Ambisonic encoder. Encodes a signal in the circular harmonics domain +// depending on an order of decomposition and an angle. +// +// #### Usage +// +// ``` +// encoder(N, x, a) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `x`: the signal +// * `a`: the angle +//---------------------------------------------------------------- +encoder(0, x, a) = x; +encoder(N, x, a) = encoder(N-1, x, a), x*sin(N*a), x*cos(N*a); + + +//-------`(ho.)rEncoder`---------- +// Ambisonic encoder in 2D including source rotation. A mono signal is encoded at a certain ambisonic order +// with two possible modes: either rotation with an angular speed, or static with a fixed angle (when speed is zero). +// +// #### Usage +// +// ``` +// _ : rEncoder(N, sp, a, it) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `sp`: the azimuth speed expressed as angular speed (2PI/sec), positive or negative +// * `a`: the fixed azimuth when the rotation stops (sp = 0) in radians +// * `it` : interpolation time (in milliseconds) between the rotation and the fixed modes +//----------------------------- +rEncoder(N, sp, a, it) = thisEncoder +with { + basicEncoder(sig, angle) = ho.encoder(N, sig, angle); + thisEncoder = (_, rotationOrStaticAngle) : basicEncoder + with { + //converting the static angle from radians to [0; 1] + an = (a / (2 * ma.PI), 1) : fmod; + rotationOrStaticAngle = ((1-vn) * x + vn * an) * 2 * ma.PI; + //to manage the case where frequency is zero, smoothly switches from one mode to another// + vn = (sp == 0) : si.smooth(ba.tau2pole(it)); + x = (os.phasor(1, sp), an, 1) : (+, _) : fmod; + }; +}; + + +//-------`(ho.)stereoEncoder`---------- +// Encoding of a stereo pair of channels with symetric angles (a/2, -a/2). +// +// #### Usage +// +// ``` +// _,_ : stereoEncoder(N, a) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `a` : opening angle in radians, left channel at a/2 angle, right channel at -a/2 angle +//----------------------------- +stereoEncoder(N, a) = (leftEncoder, rightEncoder) :> si.bus(2*N+1) +with { + basicEncoder(sig, angle) = ho.encoder(N, sig, angle); + leftEncoder = (_, a / 2) : basicEncoder; + rightEncoder = (_, -a /2) : basicEncoder; +}; + + +//-------`(ho.)multiEncoder`---------- +// Encoding of a set of P signals distributed on the unit circle according to a list of P speeds and P angles. +// +// #### Usage +// +// ``` +// _,_, ... : multiEncoder(N, lspeed, langle, it) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `lspeed` : a list of P speeds in turns by second (one speed per input signal, positive or negative) +// * `langle` : a list of P angles in radians on the unit circle to localize the sources (one angle per input signal) +// * `it` : interpolation time (in milliseconds) between the rotation and the fixed modes. +//----------------------------- +multiEncoder(N, lspeed, langle, it) = par(i, P, thisEncoder(ba.take(i+1, lspeed), ba.take(i+1, langle), it)) :> si.bus(2*N+1) +with { + P = outputs(langle); //supposed to be the same as outputs(lspeed) + basicEncoder(sig, angle) = ho.encoder(N, sig, angle); + thisEncoder(sp, a, it) = (_, rotationOrStaticAngle) : basicEncoder + with { + //converting the static angle from radians to [0; 1] + an = (a / (2 * ma.PI), 1) : fmod; + rotationOrStaticAngle = ((1-vn) * x + vn * an) * 2 * ma.PI; + //to manage the case where frequency is zero, smoothly switches from one mode to another// + vn = (sp == 0) : si.smooth(ba.tau2pole(it)); + x = (os.phasor(1, sp), an, 1) : (+, _) : fmod; + }; +}; + + +//--------------------------`(ho.)decoder`-------------------------------- +// Decodes an ambisonics sound field for a circular array of loudspeakers. +// +// #### Usage +// +// ``` +// _ : decoder(N, P) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `P`: the number of speakers (constant numerical expression) +// +// #### Note +// +// The number of loudspeakers must be greater or equal to 2n+1. +// It's preferable to use 2n+2 loudspeakers. +//------------------------------------------------------------------- +decoder(N, P) = par(i, 2*N+1, _) <: par(i, P, speaker(N, 2 * ma.PI*i/P)) +with { + speaker(N,a) = /(2), par(i, 2*N, _), encoder(N, 2/P, a) : si.dot(2*N+1); +}; + + +//-----------------------`(ho.)decoderStereo`------------------------ +// Decodes an ambisonic sound field for stereophonic configuration. +// An "home made" ambisonic decoder for stereophonic restitution +// (30° - 330°): Sound field lose energy around 180°. You should +// use `inPhase` optimization with ponctual sources. +// #### Usage +// +// ``` +// _ : decoderStereo(N) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +//-------------------------------------------------------------- +decoderStereo(N) = decoder(N, P) <: (par(i, 2*N+2, gainLeft(360 * i / P)) :> _), + (par(i, 2*N+2, gainRight(360 * i / P)) :> _) +with { + P = 2*N+2; + + gainLeft(a) = _ * sin(ratio_minus + ratio_cortex) + with { + ratio_minus = ma.PI*.5 * abs((30 + a) / 60 * ((a <= 30)) + (a - 330) / 60 * (a >= 330)); + ratio_cortex= ma.PI*.5 * abs((120 + a) / 150 * (a > 30) * (a <= 180)); + }; + + gainRight(a) = _ * sin(ratio_minus + ratio_cortex) + with { + ratio_minus = ma.PI*.5 * abs((390 - a) / 60 * (a >= 330) + (30 - a) / 60 * (a <= 30)); + ratio_cortex= ma.PI*.5 * abs((180 - a) / 150 * (a < 330) * (a >= 180)); + }; +}; + + +//-------`(ho.)iBasicDecoder`---------- +// The irregular basic decoder is a simple decoder that projects the incoming ambisonic situation +// to the loudspeaker situation (P loudspeakers) whatever it is, without compensation. +// When there is a strong irregularity, there can be some discontinuity in the sound field. +// +// #### Usage +// +// ``` +// _,_, ... : iBasicDecoder(N,la, direct, shift) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (there are 2*N+1 inputs to this function) +// * `la` : the list of P angles in degrees, for instance (0, 85, 182, 263) for four loudspeakers +// * `direct`: 1 for direct mode, -1 for the indirect mode (changes the rotation direction) +// * `shift` : angular shift in degrees to easily adjust angles +//----------------------------- +iBasicDecoder(N, la, direct, shift) = (par(i, 2*N+1, _) <: par(i, P, speaker(N, ang(i)))) +with { + P = outputs(la); + ang(i) = (ba.take(i+1, la) - direct * shift) * direct * ma.PI / 180.; + speaker(N,alpha) = /(2), par(i, 2*N, _), ho.encoder(N,2/P,alpha) : si.dot(2*N+1); +}; + + +//-------`(ho.)circularScaledVBAP`---------- +// The function provides a circular scaled VBAP with all loudspeakers and the virtual source on the unit-circle. +// +// #### Usage +// +// ``` +// _ : circularScaledVBAP(l, t) : _,_, ... +// ``` +// +// Where: +// +// * `l` : the list of angles of the loudspeakers in degrees, for instance (0, 85, 182, 263) for four loudspeakers +// * `t` : the current angle of the virtual source in degrees +//----------------------------- +circularScaledVBAP(l, t) = thisCircularVbap +with { + //modulo indexes between 1 and the number of elements of the list + modIndex(i, l) = ma.modulo(i, outputs(l)) + 1; + // + //pick up the ith angle with a 360 degree modulo + getElt(i, l) = ma.modulo(ba.take(modIndex(i, l), l), 360); + // + //function to compute the sinus of the difference between angles expressed in degrees + diffSin(u, v) = sin((v - u) * ma.PI / 180.); + // + //permutations to be used to compute scaledVBAPGain + p1(a, b, c, d) = (b, c, d, a); + p2(a, b, c, d) = (a, c, b, d); + // + //computation of the scaled VBAP gain of a pair + scaledVBAPGain(t1, t2, t) = ((diffSin(t2, t) <:(_, _, _)), (ma.signum(diffSin(t2, t1)) <: (_, _)), (diffSin(t, t1) <:(_, _, _))) : (*, *, *, *) : p1 : (_, _, (+ : sqrt <: (_, _))) : p2 : (/, /); + sVBAPGain(i, l, t) = scaledVBAPGain(getElt(i, l), getElt(i+1, l), t); + // + //computes the left and the right gains using the matrix inversion (VBAP) + leftGain(i, l, t) = sVBAPGain(i, l, t) : (_, !); + rightGain(i, l, t) = sVBAPGain(i, l, t) : (!, _); + //computation of boolean activePair that determines whether the pair of LS is active or not + //we have to distinguish leftGain >0 and rightGain >= 0 + //if we put >=0 for both, two pairs will be simultaneously active when theta is one of the loudspeaker angles in the list + //if we put > 0 for both, all the pairs will be inactive when theta is one of the loudspeaker angles in the list + activePair(i, l, t) = (leftGain(i, l, t) > 0) * (rightGain(i, l, t) >= 0); + // + //computes the total gain for each loudspeaker + cumulatedGain(i, l, t) = rightGain(outputs(l)+i-1, l, t) * activePair(outputs(l)+i-1, l, t) + leftGain(i, l, t) * activePair(i, l, t); + // + thisCircularVbap = _ <: par(i, outputs(l), *(cumulatedGain(i, l, t))); +}; + + +//-------`(ho.)imlsDecoder`---------- +// Irregular decoder in 2D for an irregular configuration of P loudspeakers +// using 2D VBAP for compensation. +// +// #### Usage +// +// ``` +// _,_, ... : imlsDecoder(N,la, direct, shift) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `la` : the list of P angles in degrees, for instance (0, 85, 182, 263) for four loudspeakers +// * `direct`: 1 for direct mode, -1 for the indirect mode (changes the rotation direction) +// * `shift` : angular shift in degrees to easily adjust angles +//----------------------------- +imlsDecoder(N, la, direct, shift) = si.bus(2*N+1) : iVBAPDecoder +with { + P = outputs(la); + //The VBAP decoder uses VBAP compensation: it balances the regular decoder output enabling to use irregular angular setup. + Q = max(2*N+2, P); + iVBAPDecoder = ho.decoder(N, Q) : par(i, Q, circularScaledVBAP(la, (i * 360 / Q - direct * shift) * direct)) :> si.bus(P); +}; + + +//-------`(ho.)iDecoder`---------- +// General decoder in 2D enabling an irregular multi-loudspeaker configuration +// and to switch between multi-channel and stereo. +// +// #### Usage +// +// ``` +// _,_, ... : iDecoder(N, la, direct, st, g) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `la`: the list of angles in degrees +// * `direct`: 1 for direct mode, -1 for the indirect mode (changes the rotation direction) +// * `shift` : angular shift in degrees to easily adjust angles +// * `st`: 1 for stereo, 0 for multi-loudspeaker configuration. When 1, stereo sounds goes through the first two channels +// * `g` : gain between 0 and 1 +//----------------------------- +iDecoder(N, la, direct, shift, st, g) = thisDecoder +with { + //p is the number of outputs + P = outputs(la); + ambi = 1 - st; + // + //for stereo decoding + paddedStereoDecoder(N, P) = (gDecoderStereo, (0 <: si.bus(P-2))) + with { + leftDispatcher = _<:(*(1-direct), *(direct)); + rightDispatcher = _<:(*(direct), *(1-direct)); + gDecoderStereo = ho.decoderStereo(N) : (*(g), *(g)) : (leftDispatcher, rightDispatcher) :> (_,_); + }; + // + thisDecoder = si.bus(2*N+1) <: (si.bus(2*N+1), si.bus(2*N+1)) : (imlsDecoder(N, la, direct, shift), paddedStereoDecoder(N, P)) : (par(i, P, *(ambi)), *(st), *(st), si.bus(P-2)) :> si.bus(P) : par(i, P, *(g)); +}; + + +//============================Optimization Functions====================================== +// Functions to weight the circular harmonics signals depending to the +// ambisonics optimization. +// It can be `basic` for no optimization, `maxRe` or `inPhase`. +//======================================================================================== + + +//----------------`(ho.)optimBasic`------------------------- +// The basic optimization has no effect and should be used for a perfect +// circle of loudspeakers with one listener at the perfect center loudspeakers +// array. +// +// #### Usage +// +// ``` +// _ : optimBasic(N) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +//----------------------------------------------------- +optimBasic(N) = par(i, 2*N+1, _); + + +//----------------`(ho.)optimMaxRe`------------------------- +// The maxRe optimization optimizes energy vector. It should be used for an +// auditory confined in the center of the loudspeakers array. +// +// #### Usage +// +// ``` +// _ : optimMaxRe(N) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +//----------------------------------------------------- +optimMaxRe(N) = par(i, 2*N+1, optim(i, N, _)) +with { + optim(i, N, _)= _ * cos(indexabs / (2*N+1) * ma.PI) + with { + numberOfharmonics = 2 * N + 1; + indexabs = (int)((i - 1) / 2 + 1); + }; +}; + + +//----------------`(ho.)optimInPhase`------------------------- +// The inPhase optimization optimizes energy vector and put all loudspeakers signals +// in phase. It should be used for an auditory. +// +// #### Usage +// +// ``` +// _ : optimInPhase(N) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +//----------------------------------------------------- +optimInPhase(N) = par(i, 2*N+1, optim(i, N, _)) +with { + optim(i, N, _)= _ * (fact(N)^2.) / (fact(N+indexabs) * fact(N-indexabs)) + with { + indexabs = (int)((i - 1) / 2 + 1); + fact(0) = 1; + fact(n) = n * fact(n-1); + }; +}; + + +//-------`(ho.)optim`---------- +// Ambisonic optimizer including the three elementary optimizers: +// `(ho).optimBasic`, `(ho).optimMaxRe` and `(ho.)optimInPhase`. +// +// #### Usage +// +// ``` +// _,_, ... : optim(N, ot) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `ot` : optimization type (0 for `optimBasic`, 1 for `optimMaxRe`, 2 for `optimInPhase`) +//----------------------------- +optim(N, ot) = thisOptimizer +with { + optb = (ot == 0) : si.smoo; + optm = (ot == 1) : si.smoo; + opti = (ot == 2) : si.smoo; + thisOptimizer = ((si.bus(2*N+1) <: ((si.bus(2*N+1):ho.optimBasic(N)), (si.bus(2*N+1):ho.optimMaxRe(N)), (si.bus(2*N+1):ho.optimInPhase(N)))), ((optb <: si.bus(2*N+1)), (optm <: si.bus(2*N+1)), (opti <: si.bus(2*N+1)))) : ro.interleave(6*N+3, 2) : par(i, 6*N+3, *) :> si.bus(2*N+1); +}; + + +//----------------`(ho.)wider`------------------------- +// Can be used to wide the diffusion of a localized sound. The order +// depending signals are weighted and appear in a logarithmic way to +// have linear changes. +// +// #### Usage +// +// ``` +// _ : wider(N,w) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `w`: the width value between 0 - 1 +//----------------------------------------------------- +wider(N, w) = par(i, 2*N+1, perform(N, w, i, _)) +with { + perform(N, w, i, _) = _ * (log(N+1) * (1 - w) + 1) * clipweight + with { + clipweight = weighter(N, w, i) * (weighter(N, w, i) > 0) * (weighter(N, w, i) <= 1) + (weighter(N, w, i) > 1) + with { + weighter(N, w, 0) = 1.; + weighter(N, w, i) = (((w * log(N+1)) - log(indexabs)) / (log(indexabs+1) - log(indexabs))) + with { + indexabs = (int)((i - 1) / 2 + 1); + }; + }; + }; +}; + + +//-------`(ho.)mirror`---------- +// Mirroring effect on the sound field. +// +// #### Usage +// +// ``` +// _,_, ... : mirror(N, fa) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `fa` : mirroring type (1 = original sound field, 0 = original+mirrored sound field, -1 = mirrored sound field) +//----------------------------- +mirror(N, fa) = (*(1), par(i, N, (*(fa), *(1)))); + + +//----------------`(ho.)map`------------------------- +// It simulates the distance of the source by applying a gain +// on the signal and a wider processing on the soundfield. +// +// #### Usage +// +// ``` +// map(N, x, r, a) +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `x`: the signal +// * `r`: the radius +// * `a`: the angle in radian +//----------------------------------------------------- +map(N, x, r, a) = encoder(N, x * volume(r), a) : wider(N, ouverture(r)) +with { + volume(r) = 1. / (r * r * (r > 1) + (r <= 1)); + ouverture(r) = r * (r < 1) + (r >= 1); +}; + + +//----------------`(ho.)rotate`------------------------- +// Rotates the sound field. +// +// #### Usage +// +// ``` +// _ : rotate(N, a) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `a`: the angle in radian +//----------------------------------------------------- +rotate(N, a) = par(i, 2*N+1, _) <: par(i, 2*N+1, rotation(i, a)) +with { + rotation(i, a) = (par(j, 2*N+1, gain1(i, j, a)), par(j, 2*N+1, gain2(i, j, a)), par(j, 2*N+1, gain3(i, j, a)) :> _) + with { + indexabs = (int)((i - 1) / 2 + 1); + gain1(i, j, a) = _ * cos(a * indexabs) * (j == i); + gain2(i, j, a) = _ * sin(a * indexabs) * (j-1 == i) * (j != 0) * (i%2 == 1); + gain3(i, j, a) = (_ * sin(a * indexabs)) * (j+1 == i) * (j != 0) * (i%2 == 0) * (-1); + }; +}; + + +//-------`(ho.)scope`---------- +// Produces an XY pair of signals representing the ambisonic sound field. +// +// #### Usage +// +// ``` +// _,_, ... : scope(N, rt) : _,_ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `rt` : refreshment time in milliseconds +//----------------------------- +scope(N, rt) = thisScope +with { + //Angle sweeping at a speed corresponding to refresh period between 0 and 2*PI + theta = os.phasor(1, 1/rt) * 2 * ma.PI; + //we get the vector of harmonic functions thanks to the encoding function// + harmonicsVector = ho.encoder(N, 1, theta); + // + normalizedVector(N) = si.bus(N) <: (si.bus(N), norm) : ro.interleave(N, 2) : par(i, N, /) + with { + norm = par(i, N, _ <:(_,_) : *) :> _ : sqrt <: ((_ == 0), (_ > 0), _) : (_,*) : + <: si.bus(N); + }; + //building (2N+1) normalized vectors + inputVector = (*(0.5), par(i, (2*N), _)) : normalizedVector(2*N+1); + normalizedHarmonics = harmonicsVector : normalizedVector(2*N+1); + // + rho = (inputVector, normalizedHarmonics) : si.dot(2*N+1) ; + thisScope = (rho <: (ma.fabs, (_ >= 0))) : ((_ <: (_,_)), _) : (*(sin(theta)), *(cos(theta)), _) : (*(-1), _,_); +}; + + +//============================Spatial Sound Processes ==================================== +// We propose implementations of processes intricated to the ambisonic model. +// The process is implemented using as many instances as the number of harmonics at at certain order. +// The key control parameters of these instances are computed thanks to distribution functions +// (th functions below) and to a global driving factor. +//======================================================================================== + +//-------`(ho.).fxDecorrelation`---------- +// Spatial ambisonic decorrelation in fx mode. +// +// `fxDecorrelation` applies decorrelations to spatial components already created. +// The decorrelation is defined for each #i spatial component among P=2\*N+1 at the ambisonic order `N` +// as a delay of 0 if factor `fa` is under a certain value 1-(i+1)/P and d\*F((i+1)/p) in the contrary case, +// where `d` is the maximum delay applied (in samples) and F is a distribution function for durations. +// The user can choose this delay time distribution among 22 different ones. +// The delay increases according to the index of ambisonic components. +// But it increases at each step and it is modulated by a threshold. +// Therefore, delays are progressively revealed when the factor increases: +// +// * when the factor is close to 0, only upper components are delayed; +// * when the factor increases, more and more components are delayed. +// +//H THRESHOLD DELAY +//0 1-1/P 0 OR DELAY*F(1/P) +//-1 1-2/P 0 OR DELAY*F(2/P) +//1 1-3/P 0 OR DELAY*F(3/P) +//-2 1-4/P 0 OR DELAY*F(4/P) +//2 1-5/P 0 OR DELAY*F(5/P) +//... +//-(N-1) 1-(P-3)/P 0 OR DELAY*F((P-3)/P) +//(N-1) 1-(P-2)/P 0 OR DELAY*F((P-2)/P) +//-N 1-(P-1)/P 0 OR DELAY*F((P-1)/P) +//N 1-P/P 0 OR DELAY*F(P/P) +// +// +// #### Usage +// +// ``` +// _,_, ... : fxDecorrelation(N, d, wf, fa, fd, tf) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `d`: the maximum delay applied (in samples) +// * `wf`: window frequency (in Hz) for the overlapped delay +// * `fa`: decorrelation factor (between 0 and 1) +// * `fd`: feedback / level of reinjection (between 0 and 1) +// * `tf`: type of function of delay distribution (integer, between 0 and 21) +//----------------------------- +fxDecorrelation(N, d, wf, fa, fd, tf) = par(i, 2*N+1, gate(d, i, 2*N+1, fa, tf, wf, fd)) +with { + gate(d, i, N, fa, tf, wf, fd) = _ <: fdOverlappedDelay(dur(d, i, N, fa, tf), 262144, wf, fd) * env1(fa, i, N), _ * env1c(fa, i, N) : +; + // + fdOverlappedDelay(nsamp, nmax, freq, fdbk) = (+ : de.sdelay(nmax, int(ma.SR / freq), nsamp)) ~ (*(fdbk)); + // + env1(fa, i, N) = (fa > ((N-i-1)/N)) : si.smooth(ba.tau2pole(0.005)); + env1c(fa, i, N) = 1 - env1(fa, i, N); + // + //computes the ith duration of the ith delay in samples with twenty two possibilities of distribution + elemdur(d, i, p, fa, tf, ind) = (tf == ind) * (fa > (1 - x)) * d * x * fa + with { + x = th(ind, i, p); + }; + //duration in samples computed as a sum of the 22 cases// + dur(d, i, p, fa, tf) = sum(ind, 22, elemdur(d, i, p, fa, tf, ind)) : int; +}; + +//-------`(ho.).synDecorrelation`---------- +// Spatial ambisonic decorrelation in syn mode. +// +// `synDecorrelation` generates spatial decorrelated components in ambisonics from one mono signal. +// The decorrelation is defined for each #i spatial component among P=2\*N+1 at the ambisonic order `N` +// as a delay of 0 if factor `fa` is under a certain value 1-(i+1)/P and d\*F((i+1)/p) in the contrary case, +// where `d` is the maximum delay applied (in samples) and F is a distribution function for durations. +// The user can choose this delay time distribution among 22 different ones. +// The delay increases according to the index of ambisonic components. +// But it increases at each step and it is modulated by a threshold. +// Therefore, delays are progressively revealed when the factor increases: +// +// * when the factor is close to 0, only upper components are delayed; +// * when the factor increases, more and more components are delayed. +// +// When the factor is between [0; 1/P], upper harmonics are progressively faded and the level of the H0 component is compensated +// to avoid source localization and to produce a large mono. +// +//H THRESHOLD DELAY +//0 1-1/P 0 OR DELAY*F(1/P) +//-1 1-2/P 0 OR DELAY*F(2/P) +//1 1-3/P 0 OR DELAY*F(3/P) +//-2 1-4/P 0 OR DELAY*F(4/P) +//2 1-5/P 0 OR DELAY*F(5/P) +//... +//-(N-1) 1-(P-3)/P 0 OR DELAY*F((P-3)/P) +//(N-1) 1-(P-2)/P 0 OR DELAY*F((P-2)/P) +//-N 1-(P-1)/P 0 OR DELAY*F((P-1)/P) +//N 1-P/P 0 OR DELAY*F(P/P) +// +// +// #### Usage +// +// ``` +// _,_, ... : synDecorrelation(N, d, wf, fa, fd, tf) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `d`: the maximum delay applied (in samples) +// * `wf`: window frequency (in Hz) for the overlapped delay +// * `fa`: decorrelation factor (between 0 and 1) +// * `fd`: feedback / level of reinjection (between 0 and 1) +// * `tf`: type of function of delay distribution (integer, between 0 and 21) +//----------------------------- +synDecorrelation(N, d, wf, fa, fd, tf) = _ <: par(i, 2*N+1, crossFade(d, i, 2*N+1, fa, tf, wf, fd)) +with { + crossFade(d, i, N, fa, tf, wf, fd) = _ <: fdOverlappedDelay(dur(d, i, N, fa, tf), 262144, wf, fd) * env1(fa, i, N), _ * env1c(fa, i, N) :> _ * env2(fa, i, N); + // + fdOverlappedDelay(nsamp, nmax, freq, fdbk) = (+ : de.sdelay(nmax, int(ma.SR / freq), nsamp)) ~ (*(fdbk)); + // + env1(fa, i, N) = (fa > ((N-i-1)/N)) : si.smooth(ba.tau2pole(0.005)); + env1c(fa, i, N) = 1 - env1(fa, i, N) ; + env2(fa, i, N) = ((i > 0) * N * min(fa, 1/N)) + ((i == 0) * (sqrt(N) * (1 - (N - sqrt(N)) * min(fa, 1/N)))) : si.smooth(ba.tau2pole(0.005)); + // + //computes the ith duration of the ith delay in samples with twenty two possibilities of distribution + elemdur(d, i, p, fa, tf, ind) = (tf == ind) * fa * d * x + with { + x = th(ind, i, p); + }; + //duration in samples computed as a sum of the 22 cases// + dur(d, i, p, fa, tf) = sum(ind, 22, elemdur(d, i, p, fa, tf, ind)) : int; +}; + +//-------`(ho.).fxRingMod`---------- +// Spatial ring modulation in syn mode. +// +// `fxRingMod` applies ring modulation to spatial components already created. +// The ring modulation is defined for each spatial component among P=2\*n+1 at the ambisonic order `N`. +// For each spatial component #i, the result is either the original signal or a ring modulated signal +// according to a threshold that is i/P. +// +// The general process is drive by a factor `fa` between 0 and 1 and a modulation frequency `f0`. +// If `fa` is greater than theshold (P-i-1)/P, the ith ring modulator is on with carrier frequency of f0\*(i+1)/P. +// On the contrary, it provides the original signal. +// +// Therefore ring modulators are progressively revealed when `fa` increases. +// +//H THRESHOLD OUTPUT +//0 (P-1)/P ORIGINAL OR RING MODULATION BY F0*1/P +//-1 (P-2)/P ORIGINAL OR RING MODULATION BY F0*2/P +//1 (P-3)/P ORIGINAL OR RING MODULATION BY F0*3/P +//-2 (P-4)/P ORIGINAL OR RING MODULATION BY F0*4/P +//2 (P-5)/P ORIGINAL OR RING MODULATION BY F0*5/P +//... +//-(N-1) 3/P ORIGINAL OR RING MODULATION BY F0*(P-3)/P +//(N-1) 2/P ORIGINAL OR RING MODULATION BY F0*(P-2)/P +//-N 1/P ORIGINAL OR RING MODULATION BY F0*(P-1)/P +//N 0 ORIGINAL OR RING MODULATION BY F0*P/P=F0 +// +// +// #### Usage +// +// ``` +// _,_, ... : fxRingMod(N, f0, fa, tf) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `f0`: the maximum delay applied (in samples) +// * `fa`: decorrelation factor (between 0 and 1) +// * `tf`: type of function of delay distribution (integer, between 0 and 21) +//----------------------------- +fxRingMod(N, f0, fa, tf) = par(i, 2*N+1, gate_ringmod(f0, i, 2*N+1, fa, tf)) +with { + // + env1(fa, i, N) = (fa > ((N-i-1)/N)) : si.smooth(ba.tau2pole(0.005)); + env1c(fa, i, N) = 1 - env1(fa, i, N); + // + gate_ringmod(f, i, N, fa, tf) = _ <: _ * os.osccos(freq(f, i, N, tf)) * env1(fa, i, N), _ * env1c(fa, i, N) : +; + // + ringmodfreq(f, i, N, tf, ind) = (tf == ind) * f * x * coef + with { + x = th(ind, i, N); + coef = min(1, max(N * (fa - (N - i - 1) / N), 0)); + }; + // + freq(f, i, N, tf) = sum(ind, 22, ringmodfreq(f, i, N, tf, ind)) : int; +}; + +//-------`(ho.).synRingMod`---------- +// Spatial ring modulation in syn mode. +// +// `synRingMod` generates spatial components in ambisonics from one mono signal thanks to ring modulation. +// The ring modulation is defined for each spatial component among P=2\*n+1 at the ambisonic order `N`. +// For each spatial component #i, the result is either the original signal or a ring modulated signal +// according to a threshold that is i/P. +// +// The general process is drive by a factor `fa` between 0 and 1 and a modulation frequency `f0`. +// If `fa` is greater than theshold (P-i-1)/P, the ith ring modulator is on with carrier frequency of f0\*(i+1)/P. +// On the contrary, it provides the original signal. +// +// Therefore ring modulators are progressively revealed when `fa` increases. +// When the factor is between [0; 1/P], upper harmonics are progressively faded and the level of the H0 component is compensated +// to avoid source localization and to produce a large mono. +// +//H THRESHOLD OUTPUT +//0 (P-1)/P ORIGINAL OR RING MODULATION BY F0*1/P +//-1 (P-2)/P ORIGINAL OR RING MODULATION BY F0*2/P +//1 (P-3)/P ORIGINAL OR RING MODULATION BY F0*3/P +//-2 (P-4)/P ORIGINAL OR RING MODULATION BY F0*4/P +//2 (P-5)/P ORIGINAL OR RING MODULATION BY F0*5/P +//... +//-(N-1) 3/P ORIGINAL OR RING MODULATION BY F0*(P-3)/P +//(N-1) 2/P ORIGINAL OR RING MODULATION BY F0*(P-2)/P +//-N 1/P ORIGINAL OR RING MODULATION BY F0*(P-1)/P +//N 0 ORIGINAL OR RING MODULATION BY F0*P/P=F0 +// +// +// #### Usage +// +// ``` +// _,_, ... : synRingMod(N, f0, fa, tf) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `f0`: the maximum delay applied (in samples) +// * `fa`: decorrelation factor (between 0 and 1) +// * `tf`: type of function of delay distribution (integer, between 0 and 21) +//----------------------------- +synRingMod(N, f0, fa, tf) = _ <: par(i, 2*N+1, crossfade_ringmod(f0, i, 2*N+1, fa, tf)) +with { + // + env1(fa, i, N) = (fa > ((N-i-1)/N)) : si.smooth(ba.tau2pole(0.005)); + env1c(fa, i, N) = 1 - env1(fa, i, N); + env2(fa, i, N) = ((i > 0) * N * min(fa, 1/N)) + ((i == 0) * (sqrt(N) * (1 - (N - sqrt(N)) * min(fa, 1/N)))) : si.smooth(ba.tau2pole(0.005)); + // + crossfade_ringmod(f, i, N, fa, tf) = _ <: _ * os.osccos(freq(f, i, N, tf)) * env1(fa, i, N), _ * env1c(fa, i, N) :> _ * env2(fa, i, N); + // + ringmodfreq(f, i, N, tf, ind) = (tf == ind) * f * x * coef + with { + x = th(ind, i, N); + coef = min(1, max(N * (fa - (N - i - 1) / N), 0)); + }; + // + freq(f, i, N, tf) = sum(ind, 22, ringmodfreq(f, i, N, tf, ind)) : int; +}; + + +//TYPES OF DISTRIBUTIONS: 22 EASING FUNCTIONS FROM [0, 1] to [0,1] +//(i+1)/p belongs to [0, 1] and its image by any function in the list also belongs to the interval + +th(0, i, p) = (i+1) / p; +th(1, i, p) = ((i+1) / p)^2; +th(2, i, p) = sin(ma.PI * 0.5 * (i+1) / p); +th(3, i, p) = log10(1 + (i+1) / p) / log10(2); +th(4, i, p) = sqrt((i+1) / p); +th(5, i, p) = 1 - cos(ma.PI * 0.5 * (i+1) / p); +th(6, i, p) = (1 - cos(ma.PI * (i+1) / p)) * 0.5; +th(7, i, p) = 1 - (1 - (i+1) / p )^2; +th(8, i, p) = ((i+1) / p < 0.5) * 2 * ((i+1) / p)^2 + ((i+1) / p >= 0.5) * (1 - (-2 * (i+1) / p + 2)^2 * 0.5); +th(9, i, p) = ((i+1) / p)^3; +th(10, i, p) = 1 - (1 - (i+1) / p)^3; +th(11, i, p) = ((i+1) / p < 0.5) * 4 * ((i+1) / p)^3 + ((i+1) / p >= 0.5) * (1 - (-2 * (i+1) / p + 2)^3 * 0.5); +th(12, i, p) = ((i+1) / p)^4; +th(13, i, p) = 1 - (1 - (i+1) / p)^4; +th(14, i, p) = ((i+1) / p < 0.5) * 8 * ((i+1) / p)^4 + ((i+1) / p >= 0.5) * (1 - (-2 * (i+1) / p + 2)^4 * 0.5); +th(15, i, p) = ((i+1) / p)^5; +th(16, i, p) = 1 - (1 - (i+1) / p)^5; +th(17, i, p) = ((i+1) / p < 0.5) * 16 * ((i+1) / p)^5 + ((i+1) / p >= 0.5) * (1 - (-2 * (i+1) / p + 2)^5 * 0.5); +th(18, i, p) = 2^(10 * (i+1) / p - 10); +th(19, i, p) = ((i+1) / p < 1) * (1 - 2^(-10 * (i+1) / p)) + ((i+1) / p == 1); +th(20, i, p) = 1 - sqrt(1 - ((i+1) / p)^2); +th(21, i, p) = sqrt(1 - ((i+1) / p - 1)^2); + + +//======================================================================================== +//============================3D Functions================================================ +//======================================================================================== +//======================================================================================== + +//----------------------`(ho.)encoder3D`--------------------------------- +// Ambisonic encoder. Encodes a signal in the circular harmonics domain +// depending on an order of decomposition, an angle and an elevation. +// +// #### Usage +// +// ``` +// encoder3D(N, x, a, e) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `x`: the signal +// * `a`: the angle +// * `e`: the elevation +//---------------------------------------------------------------- +encoder3D(N, x, theta, phi) = par(i, (N+1) * (N+1), x * y(degree(i), order(i), theta, phi)) +with { + // The degree l of the harmonic[l, m] + degree(index) = int(sqrt(index)); + // The order m of the harmonic[l, m] + order(index) = int(index - int(degree(index) * int(degree(index) + 1))); + + // The spherical harmonics + y(l, m, theta, phi) = e(m, theta2) * k(l, m) * p(l, m, cos(phi + ma.PI * 0.5)) + with { + //theta2 enables a continuous movement of elevation (when phi becomes greater than Pi/2) + theta2 = theta + (1 - int(fmod(fmod(phi / ma.PI - 0.5, 2) + 2, 2))) * ma.PI; + // + // The associated Legendre polynomial + // If l = 0 => p = 1 + // If l = m => p = -1 * (2 * (l-1) + 1) * sqrt(1 - cphi*cphi) * p(l-1, l-1, cphi) + // If l = m+1 => p = phi * (2 * (l-1) + 1) * p(l-1, l-1, cphi) + // Else => p = (cphi * (2 * (l-1) + 1) * p(l-1, abs(m), cphi) - ((l-1) + abs(m)) * p(l-2, abs(m), cphi)) / ((l-1) - abs(m) + 1) + p(l, m, cphi) = pcalcul(((l != 0) & (l == abs(m))) + ((l != 0) & (l == abs(m)+1)) * 2 + ((l != 0) & (l != abs(m)) & (l != abs(m)+1)) * 3, l, m, cphi) + with { + pcalcul(0, l, m, cphi) = 1; + pcalcul(1, l, m, cphi) = -1 * (2 * (l-1) + 1) * sqrt(1 - cphi*cphi) * p(l-1, l-1, cphi); + pcalcul(2, l, m, cphi) = cphi * (2 * (l-1) + 1) * p(l-1, l-1, cphi); + pcalcul(s, l, m, cphi) = (cphi * (2 * (l-1) + 1) * p(l-1, abs(m), cphi) - ((l-1) + abs(m)) * p(l-2, abs(m), cphi)) / ((l-1) - abs(m) + 1); + }; + + // The exponential imaginary + // If m > 0 => e^i*m*theta = cos(m * theta) + // If m < 0 => e^i*m*theta = sin(-m * theta) + // If m = 0 => e^i*m*theta = 1 + e(m, theta) = ecalcul((m > 0) * 2 + (m < 0), m, theta) + with { + ecalcul(2, m, theta) = cos(m * theta); + ecalcul(1, m, theta) = sin(abs(m) * theta); + ecalcul(s, m, theta) = 1; + }; + + // The normalization + // If m = 0 => k(l, m) = 1 + // If m != 0 => k(l, m) = sqrt((l - abs(m))! / l + abs(m))!) * sqrt(2) + k(l, m) = kcalcul((m != 0), l, m) + with { + kcalcul(0, l, m) = 1; + kcalcul(1, l, m) = sqrt(2) / sqrtFactQuotient(l+abs(m), l-abs(m)) + with { + //factorial quotient fq(n, p)=n! / p! = n(n-1)...(p+1) when n > p + //enables factor simplification + //and considering the square root of a product as a product of square roots + sqrtFactQuotient(n, p) = sqrtProd(n-p, p) + with { + //sqrtProd(n, p) computes the product sqrt(p+1) x sqrt(p+2) x ... x sqrt(n) + //to enable factorial quotient simplification + sqrtProd(1, p) = sqrt(p+1); + sqrtProd(n, p) = sqrt(p+n) * sqrtProd(n-1, p); + }; + }; + }; + }; +}; + + +//-------`(ho.)rEncoder3D`---------- +// Ambisonic encoder in 3D including source rotation. A mono signal is encoded at at certain ambisonic order +// with two possible modes: either rotation with 2 angular speeds (azimuth and elevation), or static with a fixed pair of angles. +// +// `rEncoder3D` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : rEncoder3D(N, azsp, elsp, az, el, it) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `azsp`: the azimuth speed expressed as angular speed (2PI/sec), positive or negative +// * `elsp`: the elevation speed expressed as angular speed (2PI/sec), positive or negative +// * `az`: the fixed azimuth when the azimuth rotation stops (azsp = 0) in radians +// * `el`: the fixed elevation when the elevation rotation stops (elsp = 0) in radians +// * `it` : interpolation time (in milliseconds) between the rotation and the fixed modes +//----------------------------- +rEncoder3D(N, azsp, elsp, az, el, it) = this3DEncoder +with { + basic3DEncoder(sig, ang1, ang2) = encoder3D(N, sig, ang1, ang2); + this3DEncoder = (_, rotationOrStaticAzim, rotationOrStaticElev) : basic3DEncoder + with { + x1 = (os.phasor(1, azsp), az, 1) : (+, _) : fmod : *(2 * ma.PI); + vn1 = (azsp == 0) : si.smooth(ba.tau2pole(it)); + rotationOrStaticAzim = (1-vn1) * x1 + vn1 * az; + x2 = (os.phasor(1, elsp), el, 1) : (+, _) : fmod : *(2 * ma.PI); + vn2 = (elsp == 0) : si.smooth(ba.tau2pole(it)); + rotationOrStaticElev = (1-vn2) * x2 + vn2 * el; + }; +}; + + +//----------------`(ho.)optimBasic3D`------------------------- +// The basic optimization has no effect and should be used for a perfect +// sphere of loudspeakers with one listener at the perfect center loudspeakers +// array. +// +// #### Usage +// +// ``` +// _ : optimBasic3D(N) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +//----------------------------------------------------- +optimBasic3D(N) = par(i, (N+1) * (N+1), _); + + +//----------------`(ho.)optimMaxRe3D`------------------------- +// The maxRe optimization optimize energy vector. It should be used for an +// auditory confined in the center of the loudspeakers array. +// +// #### Usage +// +// ``` +// _ : optimMaxRe3D(N) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +//----------------------------------------------------- +optimMaxRe3D(N) = par(i, (N+1) * (N+1), MaxRe(N, degree(i), _)) +with { + // The degree l of the harmonic[l, m] + degree(index) = int(sqrt(index)); + MaxRe(N, l, _)= _ * cos(l / (2*N+2) * ma.PI); +}; + + +//----------------`(ho.)optimInPhase3D`------------------------- +// The inPhase Optimization optimizes energy vector and put all loudspeakers signals +// in phase. It should be used for an auditory. +// +// #### Usage +// +// ``` +// _ : optimInPhase3D(N) : _ +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +//----------------------------------------------------- +optimInPhase3D(N) = par(i, (N+1) * (N+1), InPhase(N, degree(i), _)) +with { + // The degree l of the harmonic[l, m] + degree(index) = int(sqrt(index)); + InPhase(N, l, _)= _ * (fact(N) * fact(N)) / (fact(N - l) * fact(N + l)) + with { + fact(0) = 1; + fact(n) = n * fact(n-1); + }; +}; + + +//-------`(ho.)optim3D`---------- +// Ambisonic optimizer including the three elementary optimizers: +// `(ho).optimBasic3D`, `(ho).optimMaxRe3D` and `(ho.)optimInPhase3D`. +// +// #### Usage +// +// ``` +// _,_, ... : optim3D(N, ot) : _,_, ... +// ``` +// +// Where: +// +// * `N`: the ambisonic order (constant numerical expression) +// * `ot` : optimization type (0 for optimBasic, 1 for optimMaxRe, 2 for optimInPhase) +//----------------------------- +optim3D(N, ot) = thisOptimizer +with { + optb = (ot == 0) : si.smoo; + optm = (ot == 1) : si.smoo; + opti = (ot == 2) : si.smoo; + bus3D = si.bus((N+1)*(N+1)); + thisOptimizer = ((bus3D <: ((bus3D:ho.optimBasic3D(N)), (bus3D:ho.optimMaxRe3D(N)), (bus3D:ho.optimInPhase3D(N)))), ((optb <: bus3D), (optm <: bus3D), (opti <: bus3D))) : ro.interleave(3*(N+1)*(N+1), 2) : par(i, 3*(N+1)*(N+1), *) :> bus3D; +}; diff --git a/dist/examples/LIBRARIES/instruments.lib b/dist/examples/LIBRARIES/instruments.lib new file mode 100644 index 00000000..76676b4c --- /dev/null +++ b/dist/examples/LIBRARIES/instruments.lib @@ -0,0 +1,263 @@ +//instruments.lib - Faust function of various types useful for building physical model instruments + +no = library("noises.lib"); +en = library("envelopes.lib"); +ma = library("maths.lib"); +ba = library("basics.lib"); +de = library("delays.lib"); +si = library("signals.lib"); +fi = library("filters.lib"); +os = library("oscillators.lib"); +re = library("reverbs.lib"); + +declare name "Faust-STK Tools Library"; +declare author "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare copyright "Romain Michon"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); + + +//========================= ENVELOPE GENERATORS =============================== + +//----------------------- VIBRATO ENVELOPE ---------------------------- +// 4 phases envelope to control vibrato gain +// +// USAGE: +// _ : *(envVibrato(b,a,s,r,t)) : _ +// where +// b = beginning duration (silence) in seconds +// a = attack duration in seconds +// s = sustain as a percentage of the amplitude to be modified +// r = release duration in seconds +// t = trigger signal + +envVibrato(b,a,s,r,t) = env ~ (_,_,_) : (!,!,_) // the 3 'state' signals are fed back + with { + env(p2,cnt,y) = + (t>0) & (p2|(y>=1)), + (cnt + 1)*(t>0), // counter for the first step "b" + (y + p1*p3*u*(s/100) - p4*w*y)*((p4==0)|(y>=eps)) // y = envelop signal + //*(y>=eps) // cut off tails to prevent denormals + with { + p1 = (p2==0) & (t>0) & (y<1) & (cnt>(b*ma.SR)); // p1 = attack phase + p3 = 1-(cnt<(nb)); // p3 = beginning phase + p4 = (t<=0) & (y>0); // p4 = release phase + // #samples in attack, release, must be >0 + nb = ma.SR*b+(b==0.0) ; na = ma.SR*a+(a==0.0); nr = ma.SR*r+(r==0.0); + // attack and (-60dB) release rates + z = s+(s==0.0)*ba.db2linear(-60); + u = 1/na; w = 1-1/pow(z*ba.db2linear(60), 1/nr); + // values below this threshold are considered zero in the release phase + eps = ba.db2linear(-120); + }; + }; + +//----------------------- ASYMPT60 ---------------------------- +// Envelope generator which asymptotically approaches a target value. +// +// USAGE: +// asympT60(value,trgt,T60,trig) : _ +// where +// value = starting value +// trgt = target value +// T60 = ramping time +// trig = trigger signal + +asympT60(value,trgt,T60,trig) = (_*factor + constant)~_ + with { + cntSample = *(trig) + 1~_ : -(1); + attDur = float(2); + cndFirst = ((cntSample < attDur) & (trig > 0)); + target = value*cndFirst + trgt*(cndFirst < 1); + factorAtt = exp(-7/attDur); + factorT60 = exp(-7/(T60*float(ma.SR))); + factor = factorAtt*((cntSample < attDur) & (trig > 0)) + + ((cntSample >= attDur) | (trig < 1))*factorT60; + constant = (1 - factor)*target; + }; + +//========================= TABLES =============================== + +//----------------------- CLIPPING FUNCTION ---------------------------- +// Positive and negative clipping functions. +// +// USAGE: +// _ : saturationPos : _ +// _ : saturationNeg : _ +// _ : saturationPos : saturationNeg : _ + +saturationPos(x) = x <: (_>1),(_<=1 : *(x)) :> +; +saturationNeg(x) = x <: (_<-1),(_>=-1 : *(x)) :> *(-1) + _; + +//----------------------- BOW TABLE ---------------------------- +// Simple bow table. +// +// USAGE: +// index : bow(offset,slope) : _ +// where +// 0 <= index <= 1 + +bow(offset,slope) = pow(abs(sample) + 0.75, -4) : saturationPos + with { + sample(y) = (y + offset)*slope; + }; + +//----------------------- REED TABLE ---------------------------- +// Simple reed table to be used with waveguide models of clarinet, saxophone, etc. +// +// USAGE: +// _ : reed(offset,slope) : _ +// where +// offset = offset between 0 and 1 +// slope = slope between 0 and 1 +// REFERENCE: +// + +reed(offset,slope) = reedTable : saturationPos : saturationNeg + with { + reedTable = offset + (slope*_); + }; + +//========================= FILTERS =============================== + +//----------------------- ONE POLE ---------------------------- + +onePole(b0,a1,x) = (b0*x - a1*_)~_; + +//----------------------- ONE POLE SWEPT ---------------------------- + +onePoleSwep(a1,x) = (1 + a1)*x - a1*x'; + +//----------------------- POLE ZERO ---------------------------- + +poleZero(b0,b1,a1,x) = (b0*x + b1*x' - a1*_)~_; + +//----------------------- ONE ZEROS ---------------------------- +// Simple One zero and One zero recursive filters +// +// USAGE: +// _ : oneZero0(b0,b1) : _ +// _ : oneZero1(b0,b1) : _ +// REFERENCE: +// + +oneZero0(b0,b1,x) = (*(b1) + x*b0)~_; +oneZero1(b0,b1,x) = (x'*b1 + x*b0); + +//----------------------- BANDPASS FILTER WITH CONSTANT UNITY PEAK GAIN BASED ON A BIQUAD ---------------------------- + +bandPass(resonance,radius) = fi.TF2(b0,b1,b2,a1,a2) + with { + a2 = radius*radius; + a1 = -2*radius*cos(ma.PI*2*resonance/ma.SR); + b0 = 0.5-0.5*a2; + b1 = 0; + b2 = -b0; + }; + +//----------------------- BANDPASS FILTER BASED ON A BIQUAD ---------------------------- +// Band pass filter using a biquad (TF2 is declared in filter.lib) +// +// USAGE: +// _ : bandPassH(resonance,radius) : _ +// where +// resonance = center frequency +// radius = radius + +bandPassH(resonance,radius) = fi.TF2(b0,b1,b2,a1,a2) + with { + a2 = radius*radius; + a1 = -2*radius*cos(ma.PI*2*resonance/ma.SR); + b0 = 1; + b1 = 0; + b2 = 0; + }; + +//----------------------- FLUE JET NON-LINEAR FUNCTION ---------------------------- +// Jet Table: flue jet non-linear function, computed by a polynomial calculation + +jetTable(x) = x <: _*(_*_-1) : saturationPos : saturationNeg; + +//----------------------- NON LINEAR MODULATOR ---------------------------- +// nonLinearModulator adapts the function allpassnn from filter.lib for using it with waveguide instruments (see the corresponding DAFx paper: (Faust-STK: a Set of Linear and Nonlinear Physical Models for the Faust Programming Language) for more details). +// +// USAGE: +// _ : nonLinearModulator(nonlinearity,env,freq,typeMod,freqMod,order) : _ +// where +// nonlinearity = nonlinearity coefficient between 0 and 1 +// env = input to connect any kind of envelope +// freq = current tone frequency +// typeMod = if 0: theta is modulated by the incoming signal; +// if 1: theta is modulated by the averaged incoming signal; +// if 2: theta is modulated by the squared incoming signal; +// if 3: theta is modulated by a sine wave of frequency freqMod; +// if 4: theta is modulated by a sine wave of frequency freq; +// freqMod = frequency of the sine wave modulation +// order = order of the filter + +nonLinearModulator(nonlinearity,env,freq,typeMod,freqMod,order) = + //theta is modulated by a sine wave + _ <: nonLinearFilterOsc*(typeMod >= 3), + //theta is modulated by the incoming signal + (_ <: nonLinearFilterSig*nonlinearity,_*(1 - nonlinearity) :> +)*(typeMod < 3) + :> + + with { + //which frequency to use for the sine wave oscillator? + freqOscMod = (typeMod == 4)*freq + (typeMod != 4)*freqMod; + + //the incoming signal is scaled and the envelope is applied + tsignorm(x) = nonlinearity*ma.PI*x*env; + tsigsquared(x) = nonlinearity*ma.PI*x*x*env; //incoming signal is squared + tsigav(x) = nonlinearity*ma.PI*((x + x')/2)*env; //incoming signal is averaged with its previous sample + + //select which version of the incoming signal of theta to use + tsig(x) = tsignorm(x)*(typeMod == 0) + tsigav(x)*(typeMod == 1) + + tsigsquared(x)*(typeMod == 2); + + //theta is modulated by a sine wave generator + tosc = nonlinearity*ma.PI*os.osc(freqOscMod)*env; + + //incoming signal is sent to the nonlinear passive allpass ladder filter + nonLinearFilterSig(x) = x <: fi.allpassnn(order,(par(i,order,tsig(x)))); + nonLinearFilterOsc = _ <: fi.allpassnn(order,(par(i,order,tosc))); + }; + +//========================= TOOLS =============================== + +//----------------------- STEREOIZER ---------------------------- +// This function takes a mono input signal and spacialize it in stereo +// in function of the period duration of the tone being played. +// +// USAGE: +// _ : stereo(periodDuration) : _,_ +// where +// periodDuration = period duration of the tone being played in number of samples +// REFERENCE: +// + +stereoizer(periodDuration) = _ <: _,widthdelay : stereopanner + with { + W = hslider("v:Spat/spatial width", 0.5, 0, 1, 0.01); + A = hslider("v:Spat/pan angle", 0.6, 0, 1, 0.01); + widthdelay = de.delay(4096,W*periodDuration/2); + stereopanner = _,_ : *(1.0-A), *(A); + }; + +//----------------------- INSTRREVERB ---------------------------- +// GUI for zita_rev1_stereo from reverbs.lib +// +// USAGE: +// _,_ : instrRerveb + +instrReverb = _,_ <: *(reverbGain),*(reverbGain),*(1 - reverbGain),*(1 - reverbGain) : +re.zita_rev1_stereo(rdel,f1,f2,t60dc,t60m,fsmax),_,_ <: _,!,_,!,!,_,!,_ : +,+ + with { + reverbGain = hslider("v:Reverb/reverbGain",0.137,0,1,0.01) : si.smoo; + roomSize = hslider("v:Reverb/roomSize",0.72,0.01,2,0.01); + rdel = 20; + f1 = 200; + f2 = 6000; + t60dc = roomSize*3; + t60m = roomSize*2; + fsmax = 48000; + }; diff --git a/dist/examples/LIBRARIES/interpolators.lib b/dist/examples/LIBRARIES/interpolators.lib new file mode 100644 index 00000000..cb7768b7 --- /dev/null +++ b/dist/examples/LIBRARIES/interpolators.lib @@ -0,0 +1,643 @@ +//#################################### interpolators.lib ######################################## +// A library to handle interpolation. Its official prefix is `it`. +// +// This library provides several basic interpolation functions, as well as interpolators +// taking a `gen` circuit of N outputs producing values to be interpolated, triggered +// by a `idv` read index signal. Two points and four points interpolations are implemented. +// +// The `idv` parameter is to be used as a read index. In `-single` (= singleprecision) mode, +// a technique based on 2 signals with the pure integer index and a fractional part in the [0,1] +// range is used to avoid accumulating errors. In `-double` (= doubleprecision) or `-quad` (= quadprecision) modes, +// a standard implementation with a single fractional index signal is used. Three functions `int_part`, `frac_part` and `mak_idv` are available to manipulate the read index signal. +// +// Here is a use-case with `waveform`. Here the signal given to `interpolator_XXX` uses the `idv` model. +// +// ``` +// waveform_interpolator(wf, step, interp) = interp(gen, idv) +// with { +// gen(idx) = wf, (idx:max(0):min(size-1)) : rdtable with { size = wf:(_,!); }; /* waveform size */ +// index = (+(step)~_)-step; /* starting from 0 */ +// idv = it.make_idv(index); /* build the signal for interpolation in a generic way */ +// }; +// +// waveform_linear(wf, step) = waveform_interpolator(wf, step, it.interpolator_linear); +// waveform_cosine(wf, step) = waveform_interpolator(wf, step, it.interpolator_cosine); +// waveform_cubic(wf, step) = waveform_interpolator(wf, step, it.interpolator_cubic); +// +// waveform_interp(wf, step, selector) = waveform_interpolator(wf, step, interp_select(selector)) +// with { +// /* adapts the argument order */ +// interp_select(sel, gen, idv) = it.interpolator_select(gen, idv, sel); +// }; +// +// waveform and index +// waveform_interpolator1(wf, idv, interp) = interp(gen, idv) +// with { +// gen(idx) = wf, (idx:max(0):min(size-1)) : rdtable with { size = wf:(_,!); }; /* waveform size */ +// }; +// +// waveform_linear1(wf, idv) = waveform_interpolator1(wf, idv, it.interpolator_linear); +// waveform_cosine1(wf, idv) = waveform_interpolator1(wf, idv, it.interpolator_cosine); +// waveform_cubic1(wf, idv) = waveform_interpolator1(wf, idv, it.interpolator_cubic); +// +// waveform_interp1(wf, idv, selector) = waveform_interpolator1(wf, idv, interp_select(selector)) +// with { +// /* adapts the argument order */ +// interp_select(sel, gen, idv) = it.interpolator_select(gen, idv, sel); +// }; +// ``` +// +// Some tests here: +// +// ``` +// wf = waveform {0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 50.0, 40.0, 30.0, 20.0, 10.0, 0.0}; +// +// process = waveform_linear(wf, step), waveform_cosine(wf, step), waveform_cubic(wf, step) with { step = 0.25; }; +// +// process = waveform_interp(wf, 0.25, nentry("algo", 0, 0, 3, 1)); +// +// process = waveform_interp1(wf, idv, nentry("algo", 0, 0, 3, 1)) +// with { +// step = 0.1; +// idv_aux = (+(step)~_)-step; /* starting from 0 */ +// idv = it.make_idv(idv_aux); /* build the signal for interpolation in a generic way */ +// }; +// +// /* Test linear interpolation between 2 samples with a `(idx,dv)` signal built using a waveform */ +// linear_test = (idx,dv), it.interpolator_linear(gen, (idx,dv)) +// with { +// /* signal to interpolate (only 2 points here) */ +// gen(id) = waveform {3.0, -1.0}, (id:max(0)) : rdtable; +// dv = waveform {0.0, 0.25, 0.50, 0.75, 1.0}, index : rdtable; +// idx = 0; +// /* test index signal */ +// index = (+(1)~_)-1; /* starting from 0 */ +// }; +// +// /* Test cosine interpolation between 2 samples with a `(idx,dv)` signal built using a waveform */ +// cosine_test = (idx,dv), it.interpolator_cosine(gen, (idx,dv)) +// with { +// /* signal to interpolate (only 2 points here) */ +// gen(id) = waveform {3.0, -1.0}, (id:max(0)) : rdtable; +// dv = waveform {0.0, 0.25, 0.50, 0.75, 1.0}, index : rdtable; +// idx = 0; +// /* test index signal */ +// index = (+(1)~_)-1; /* starting from 0 */ +// }; +// +// /* Test cubic interpolation between 4 samples with a `(idx,dv)` signal built using a waveform */ +// cubic_test = (idx,dv), it.interpolator_cubic(gen, (idx,dv)) +// with { +// /* signal to interpolate (only 4 points here) */ +// gen(id) = waveform {-1.0, 2.0, 1.0, 4.0}, (id:max(0)) : rdtable; +// dv = waveform {0.0, 0.25, 0.50, 0.75, 1.0}, index : rdtable; +// idx = 0; +// /* test index signal */ +// index = (+(1)~_)-1; /* starting from 0 */ +// }; +// ``` +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2019-2020 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ba = library("basics.lib"); +ro = library("routes.lib"); +ma = library("maths.lib"); +si = library("signals.lib"); + +declare name "Faust Interpolator Library"; +declare version "0.3"; + +reset(trig) = (trig-trig') <= 0; + +// The following 3 functions allow to adapt a 'single signal' fractional idv in this [idx, dv] model. + +singleprecision int_part(idv) = idv : _,!; +singleprecision frac_part(idv) = idv : !,_; +singleprecision make_idv(id) = int(id), ma.frac(id); + +// Infinite raising index +singleprecision raise(trig, step, length) = id, dv +letrec { + 'id = (id + int(step) + int(dv + ma.frac(step))) * reset(trig); + 'dv = ma.frac(dv + ma.frac(step)) * reset(trig); +}; + +// Modulo based raising index +singleprecision raise_modulo(trig, step, length) = id, dv +letrec { + 'id = fmod(id + int(step) + int(dv + ma.frac(step)), length) * reset(trig); + 'dv = ma.frac(dv + ma.frac(step)) * reset(trig); +}; + +// Decreasing index starting at 'length' +singleprecision decrease(trig, step, length) = raise(trig, -step, length) : (+(length), _); + +// Modulo decreasing index starting at 'length' +singleprecision decrease_modulo(trig, step, length) = raise_modulo(trig, -step, length) : (+(length), _); + +// The following 3 functions allow to adapt a 'single signal' fractional idv in this [idx, dv] model. + +doubleprecision quadprecision int_part(idv) = int(idv); +doubleprecision quadprecision frac_part(idv) = ma.frac(idv); +doubleprecision quadprecision make_idv(id) = id; + +// Infinite raising index +doubleprecision quadprecision raise(trig, step, length) = idv +letrec { + 'idv = (idv + step) * reset(trig); +}; + +// Modulo based raising index +doubleprecision quadprecision raise_modulo(trig, step, length) = idv +letrec { + 'idv = fmod(idv + step, length) * reset(trig); +}; + +// Decreasing index starting at 'length' +doubleprecision quadprecision decrease(trig, step, length) = raise(trig, -step, length) + length; + +// Modulo decreasing index starting at 'length' +doubleprecision quadprecision decrease_modulo(trig, step, length) = raise_modulo(trig, -step, length) + length; + +//=========================Two points interpolation functions============================= +//======================================================================================== + +//-------`(it.)interpolate_linear`---------- +// Linear interpolation between 2 values. +// +// #### Usage +// +// ``` +// interpolate_linear(dv,v0,v1) : _ +// ``` +// +// Where: +// +// * `dv`: in the fractional value in [0..1] range +// * `v0`: is the first value +// * `v1`: is the second value +// +// +// #### Reference: +// +// +// +//-------------------------------------------- +declare interpolate_linear author "Stéphane Letz"; +declare interpolate_linear licence "MIT"; + +interpolate_linear(dv,v0,v1) = v0 + dv*(v1-v0); // (faster than v0*(1-dv)+v1*dv which is currently not optimized...) + + +//-------`(it.)interpolate_cosine`---------- +// Cosine interpolation between 2 values. +// +// #### Usage +// +// ``` +// interpolate_cosine(dv,v0,v1) : _ +// ``` +// +// Where: +// +// * `dv`: in the fractional value in [0..1] range +// * `v0`: is the first value +// * `v1`: is the second value +// +// +// #### Reference: +// +// +// +//-------------------------------------------- +declare interpolate_cosine author "Stéphane Letz"; +declare interpolate_cosine licence "MIT"; + +interpolate_cosine(dv,v0,v1) = v0 + a2*(v1-v0) with { a2 = 0.5 * (1.0 - cos(dv*ma.PI)); }; + + +//=========================Four points interpolation functions============================ +//======================================================================================== + +//-------`(it.)interpolate_cubic`---------- +// Cubic interpolation between 4 values. +// +// #### Usage +// +// ``` +// interpolate_cubic(dv,v0,v1,v2,v3) : _ +// ``` +// +// Where: +// +// * `dv`: in the fractional value in [0..1] range +// * `v0`: is the first value +// * `v1`: is the second value +// * `v2`: is the third value +// * `v3`: is the fourth value +// +// +// #### Reference: +// +// +// +//-------------------------------------------- +declare interpolate_cubic author "Stéphane Letz"; +declare interpolate_cubic licence "MIT"; + +interpolate_cubic(dv,v0,v1,v2,v3) + = v1 + 0.5*dv*(v2 - v0 + dv*(2.0*v0 - 5.0*v1 + 4.0*v2 - v3 + dv*(3.0*(v1 - v2) + v3 - v0))); + + +//=========================Two points interpolators======================================= +//======================================================================================== + +//-------`(it.)interpolator_two_points`---------- +// Generic interpolator on two points (current and next index), assuming an increasing index. +// +// #### Usage +// +// ``` +// interpolator_two_points(gen, idv, interpolate_two_points) : si.bus(outputs(gen)) +// ``` +// +// Where: +// +// * `gen`: a circuit with an 'idv' reader input that produces N outputs +// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair +// * `interpolate_two_points`: a two points interpolation function +// +//-------------------------------------------- +declare interpolator_two_points author "Stéphane Letz"; +declare interpolator_two_points licence "MIT"; + +interpolator_two_points(gen, idv, interpolate_two_points) = (gen(id0), gen(id1)) + : ro.interleave(outputs(gen), 2) + : par(i, outputs(gen), interpolate_two_points(dv)) +with { + id0 = int_part(idv); // index integer part + id1 = id0 + 1; // next index + dv = frac_part(idv); // index fractional part in [0..1] +}; + + +//-------`(it.)interpolator_linear`---------- +// Linear interpolator for a 'gen' circuit triggered by an 'idv' input to generate values. +// +// #### Usage +// +// ``` +// interpolator_linear(gen, idv) : si.bus(outputs(gen)) +// ``` +// +// Where: +// +// * `gen`: a circuit with an 'idv' reader input that produces N outputs +// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair +// +//-------------------------------------------- +declare interpolator_linear author "Stéphane Letz"; +declare interpolator_linear licence "MIT"; + +interpolator_linear(gen, idv) = interpolator_two_points(gen, idv, interpolate_linear); + + +//-------`(it.)interpolator_cosine`---------- +// Cosine interpolator for a 'gen' circuit triggered by an 'idv' input to generate values. +// +// #### Usage +// +// ``` +// interpolator_cosine(gen, idv) : si.bus(outputs(gen)) +// ``` +// +// Where: +// +// * `gen`: a circuit with an 'idv' reader input that produces N outputs +// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair +// +//-------------------------------------------- +declare interpolator_cosine author "Stéphane Letz"; +declare interpolator_cosine licence "MIT"; + +interpolator_cosine(gen, idv) = interpolator_two_points(gen, idv, interpolate_cosine); + + +// To be used in 'interpolator_select' +interpolator_null(gen, idv) = interpolator_two_points(gen, idv, \(dv,v0,v1).(v0)); + + +//=========================Four points interpolators====================================== +//======================================================================================== + +//-------`(it.)interpolator_four_points`---------- +// Generic interpolator on interpolator_four_points points (previous, current and two next indexes), assuming an increasing index. +// +// #### Usage +// +// ``` +// interpolator_four_points(gen, idv, interpolate_four_points) : si.bus(outputs(gen)) +// ``` +// +// Where: +// +// * `gen`: a circuit with an 'idv' reader input that produces N outputs +// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair +// * `interpolate_four_points`: a four points interpolation function +// +//-------------------------------------------- +declare interpolator_four_points author "Stéphane Letz"; +declare interpolator_four_points licence "MIT"; + +interpolator_four_points(gen, idv, interpolate_four_points) = (gen(id0), gen(id1), gen(id2), gen(id3)) + : ro.interleave(outputs(gen), 4) + : par(i, outputs(gen), interpolate_four_points(dv)) +with { + id0 = id1 - 1; // previous index + id1 = int_part(idv); // index integer part + id2 = id1 + 1; // next index + id3 = id2 + 1; // next index + dv = frac_part(idv); // index fractional part in [0..1] +}; + + +//-------`(it.)interpolator_cubic`---------- +// Cubic interpolator for a 'gen' circuit triggered by an 'idv' input to generate values +// +// #### Usage +// +// ``` +// interpolator_cubic(gen, idv) : si.bus(outputs(gen)) +// ``` +// +// Where: +// +// * `gen`: a circuit with an 'idv' reader input that produces N outputs +// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair +// +//-------------------------------------------- +declare interpolator_cubic author "Stéphane Letz"; +declare interpolator_cubic licence "MIT"; + +interpolator_cubic(gen, idv) = interpolator_four_points(gen, idv, interpolate_cubic); + +// Enum of interpolation algorithms +MAX_INTER = 4; + +linear = 0; +cosine = 1; +cubic = 2; +nointerp = MAX_INTER-1; + + +//-------`(it.)interpolator_select`---------- +// Generic configurable interpolator (with selector between in [0..3]). The value 3 is used for no interpolation. +// +// #### Usage +// +// ``` +// interpolator_select(gen, idv, sel) : _,_... (equal to N = outputs(gen)) +// ``` +// +// Where: +// +// * `gen`: a circuit with an 'idv' reader input that produces N outputs +// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair +// * `sel`: an interpolation algorithm selector in [0..3] (0 = linear, 1 = cosine, 2 = cubic, 3 = nointerp) +// +//-------------------------------------------- +declare interpolator_select author "Stéphane Letz"; +declare interpolator_select licence "MIT"; + +interpolator_select(gen, idv, sel) = ba.selectmulti(ma.SR/10, interpolators, sel) +with { + interpolators = (interpolator_linear(gen, idv), + interpolator_cosine(gen, idv), + interpolator_cubic(gen, idv), + interpolator_null(gen, idv)); +}; + +//=========================Lagrange based interpolators==================================== +//======================================================================================== + +//-------`(it.)lagrangeCoeffs(N, xCoordsList)` --------------------------------------------- +// +// This is a function to generate N + 1 coefficients for an Nth-order Lagrange +// basis polynomial with arbitrary spacing of the points. +// +// #### Usage +// +// ``` +// lagrangeCoeffs(N, xCoordsList, x) : si.bus(N + 1) +// ``` +// +// Where: +// +// * `N`: order of the interpolation filter, known at compile-time +// * `xCoordsList`: a list of N + 1 elements determining the x-axis coordinates of N + 1 values, known at compile-time +// * `x`: a fractional position on the x-axis to obtain the interpolated y-value +// +// #### Reference +// +// +// +//------------------------------------------------------------ + +declare lagrangeCoeffs author "Dario Sanfilippo"; +declare lagrangeCoeffs copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare lagrangeCoeffs license "MIT license"; +lagrangeCoeffs(N, xCoords, x) = par(n, N + 1, prod(k, N + 1, f(n, k))) + with { + xVals(i) = ba.take(i + 1, xCoords); + f(n, k) = ((x - xVals(k)) * (n != k) + (n == k)) / + ((xVals(n) - xVals(k)) + (n == k)); + }; +// The following definition for uniformely-spaced points interpolation is kept for back-compatibility +lagrange_h(N, x) = lagrangeCoeffs(N, xCoord, x) + with { + xCoord = par(i, N + 1, i); + }; + +//-------`(it.)lagrangeInterpolation(N, xCoordsList)` -------------------------------------- +// +// Nth-order Lagrange interpolator to interpolate between a set of arbitrarily spaced N + 1 points. +// +// #### Usage +// +// ``` +// x , yCoords : lagrangeInterpolation(N, xCoordsList) : _ +// ``` +// +// Where: +// +// * `N`: order of the interpolator, known at compile-time +// * `xCoordsList`: a list of N + 1 elements determining the x-axis spacing of the points, known at compile-time +// * `x`: an x-axis position to interpolate between the y-values +// * `yCoords`: N + 1 elements determining the values of the interpolation points +// +// Example: find the centre position of a four-point set using an order-3 +// Lagrange function fitting the equally-spaced points [2, 5, -1, 3]: +// +// ``` +// N = 3; +// xCoordsList = (0, 1, 2, 3); +// x = N / 2.0; +// yCoords = 2, 5, -1, 3; +// process = x, yCoords : lagrangeInterpolation(N, xCoordsList); +// ``` +// +// which outputs ~1.938. +// +// Example: output the dashed curve showed on the Wikipedia page (top figure, https://en.wikipedia.org/wiki/Lagrange_polynomial): +// +// ``` +// N = 3; +// xCoordsList = (-9, -4, -1, 7); +// x = os.phasor(16, 1) - 9; +// yCoords = 5, 2, -2, 9; +// process = x, yCoords : lagrangeInterpolation(N, xCoordsList); +// ``` +// +// #### Reference +// +// +// Sanfilippo and Parker 2021, "Combining zeroth and first‐order analysis with Lagrange polynomials to reduce artefacts in live concatenative granular processing." Proceedings of the DAFx conference 2021, Vienna, Austria. +// +//------------------------------------------------------------ + +declare lagrangeInterpolation author "Dario Sanfilippo"; +declare lagrangeInterpolation copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare lagrangeInterpolation license "MIT license"; +lagrangeInterpolation(N, xCoords, x) = si.dot(N + 1, lagrangeCoeffs(N, xCoords, x)); +// The following definition for uniformely-spaced points interpolation is kept for back-compatibility +lagrangeN(N, x) = si.dot(N + 1, lagrange_h(N, x)); + +//-------`(it.)frdtable(N, S)` -------------------------------------------- +// +// Look-up circular table with Nth-order Lagrange interpolation for fractional +// indexes. The index is wrapped-around and the table is cycles for an index +// span of size S, which is the table size in samples. +// +// #### Usage +// +// ``` +// frdtable(N, S, init, idx) : _ +// ``` +// +// Where: +// +// * `N`: Lagrange interpolation order, known at compile-time +// * `S`: table size in samples, known at compile-time +// * `init`: signal for table initialisation +// * `idx`: fractional index wrapped-around 0 and S +// +// #### Example test program +// Test the effectiveness of the 5th-order interpolation scheme by +// creating a table look-up oscillator using only 16 points of a sinewave; +// compare the result with a non-interpolated version: +// +// ``` +// N = 5; +// S = 16; +// index = os.phasor(S, 1000); +// process = rdtable(S, os.sinwaveform(S), int(index)) , +// it.frdtable(N, S, os.sinwaveform(S), index); +// ``` +//------------------------------------------------------------ + +declare frdtable author "Dario Sanfilippo"; +declare frdtable copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare frdtable license "LGPL v3.0 license"; +frdtable(N, S, init, idx) = + lagrangeN(N, f_idx, par(i, N + 1, table(i_idx - int(N / 2) + i))) + with { + table(j) = rdtable(S, init, int(ma.modulo(j, S))); + f_idx = ma.frac(idx) + int(N / 2); + i_idx = int(idx); + }; + + +//-------`(it.)frwtable(N, S)` -------------------------------------------- +// +// Look-up updatable circular table with Nth-order Lagrange interpolation for +// fractional indexes. The index is wrapped-around and the table is circular +// indexes ranging from 0 to S, which is the table size in samples. +// +// #### Usage +// +// ``` +// frwtable(N, S, init, w_idx, x, r_idx) : _ +// ``` +// +// Where: +// +// * `N`: Lagrange interpolation order, known at compile-time +// * `S`: table size in samples, known at compile-time +// * `init`: constant for table initialisation, known at compile-time +// * `w_idx`: it should be an INT between 0 and S - 1 +// * `x`: input signal written on the w_idx positions +// * `r_idx`: fractional index wrapped-around 0 and S +// +// #### Example test program +// Test the effectiveness of the 5th-order interpolation scheme by +// creating a table look-up oscillator using only 16 points of a sinewave; +// compare the result with a non-interpolated version: +// +// ``` +// N = 5; +// S = 16; +// rIdx = os.phasor(S, 300); +// wIdx = ba.period(S); +// process = rwtable(S, os.sinwaveform(S), wIdx, os.sinwaveform(S), int(rIdx)) , +// frwtable(N, S, os.sinwaveform(S), wIdx, os.sinwaveform(S), rIdx); +// ``` +//------------------------------------------------------------ + +declare frwtable author "Dario Sanfilippo"; +declare frwtable copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare frwtable license "LGPL v3.0 license"; +frwtable(N, S, init, w_idx, x, r_idx) = + lagrangeN(N, f_idx, par(i, N + 1, table(i_idx - int(N / 2) + i))) + with { + table(j) = rwtable(S, init, w_idx, x, int(ma.modulo(j, S))); + f_idx = ma.frac(r_idx) + int(N / 2); + i_idx = int(r_idx); + }; diff --git a/dist/examples/LIBRARIES/maths.lib b/dist/examples/LIBRARIES/maths.lib new file mode 100644 index 00000000..df261890 --- /dev/null +++ b/dist/examples/LIBRARIES/maths.lib @@ -0,0 +1,758 @@ +//################################### maths.lib ########################################## +// Mathematic library for Faust. Its official prefix is `ma`. +// +// #### References +// * +//######################################################################################## +// Some functions are implemented as Faust foreign functions of `math.h` functions +// that are not part of Faust's primitives. Defines also various constants and several +// utilities. +//######################################################################################## + +// ## History +// * 06/13/2016 [RM] normalizing and integrating to new libraries +// * 07/08/2015 [YO] documentation comments +// * 20/06/2014 [SL] added FTZ function +// * 22/06/2013 [YO] added float|double|quad variants of some foreign functions +// * 28/06/2005 [YO] postfixed functions with 'f' to force float version instead of double +// * 28/06/2005 [YO] removed 'modf' because it requires a pointer as argument + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2003-2016 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +// This library contains platform specific constants +pl = library("platform.lib"); +ma = library("maths.lib"); // for compatible copy/paste out of this file + +declare name "Faust Math Library"; +declare version "2.5"; +declare author "GRAME"; +declare copyright "GRAME"; +declare license "LGPL with exception"; + +//=============================Functions Reference======================================== +//======================================================================================== + + +//---------------------------------`(ma.)SR`--------------------------------------- +// Current sampling rate given at init time. Constant during program execution. +// +// #### Usage +// +// ``` +// SR : _ +// ``` +//----------------------------------------------------------------------------- +SR = pl.SR; + +//---------------------------------`(ma.)T`--------------------------------------- +// Current sampling rate given at init time. Constant during program execution. +// +// #### Usage +// +// ``` +// T : _ +// ``` +//----------------------------------------------------------------------------- +T = 1.0 / SR; + +//---------------------------------`(ma.)BS`--------------------------------------- +// Current block-size. Can change during the execution at each block. +// +// #### Usage +// +// ``` +// BS : _ +// ``` +//----------------------------------------------------------------------------- +BS = pl.BS; + + +//---------------------------------`(ma.)PI`--------------------------------------- +// Constant PI in double precision. +// +// #### Usage +// +// ``` +// PI : _ +// ``` +//----------------------------------------------------------------------------- +PI = 3.14159265358979323846; + + +//---------------------------------`(ma.)E`--------------------------------------- +// Constant e in double precision. +// +// #### Usage +// +// ``` +// E : _ +// ``` +//----------------------------------------------------------------------------- +E = 2.71828182845904523536; + + +//---------------------------------`(ma.)EPSILON`--------------------------------------- +// Constant EPSILON in simple/double/quad precision. +// +// #### Usage +// +// ``` +// EPSILON : _ +// ``` +//----------------------------------------------------------------------------- +singleprecision EPSILON = 1.192092896e-07; +doubleprecision EPSILON = 2.2204460492503131e-016; +quadprecision EPSILON = 2.2204460492503131e-016; +fixedpointprecision EPSILON = 2.2204460492503131e-016; + + +//---------------------------------`(ma.)MIN`--------------------------------------- +// Constant MIN in simple/double/quad precision (minimal positive value). +// +// #### Usage +// +// ``` +// MIN : _ +// ``` +//----------------------------------------------------------------------------- +singleprecision MIN = 1.175494351e-38; +doubleprecision MIN = 2.2250738585072014e-308; +quadprecision MIN = 2.2250738585072014e-308; +fixedpointprecision MIN = 2.2250738585072014e-308; + + +//---------------------------------`(ma.)MAX`------------------------------ +// Constant MAX in simple/double/quad precision (maximal positive value). +// +// #### Usage +// +// ``` +// MAX : _ +// ``` +//----------------------------------------------------------------------------- +singleprecision MAX = 3.402823466e+38; +doubleprecision MAX = 1.7976931348623158e+308; +quadprecision MAX = 1.7976931348623158e+308; +fixedpointprecision MAX = 1.7976931348623158e+308; + +// Obsolete, kept for compatibility reasons +INFINITY = MAX; + +//---------------------------------`(ma.)FTZ`--------------------------------------- +// Flush to zero: force samples under the "maximum subnormal number" +// to be zero. Usually not needed in C++ because the architecture +// file take care of this, but can be useful in JavaScript for instance. +// +// #### Usage +// +// ``` +// _ : FTZ : _ +// ``` +// +// #### Reference +// +// +//----------------------------------------------------------------------------- +FTZ(x) = x * (abs(x) > MIN); + + +//---------------------------------`(ma.)copysign`--------------------------------------- +// Changes the sign of x (first input) to that of y (second input). +// +// #### Usage +// +// ``` +// _,_ : copysign : _ +// ``` +//----------------------------------------------------------------------------- +copysign = ffunction(float copysignf|copysign|copysignl (float, float), ,""); + + +//---------------------------------`(ma.)neg`--------------------------------------- +// Invert the sign (-x) of a signal. +// +// #### Usage +// +// ``` +// _ : neg : _ +// ``` +//----------------------------------------------------------------------------- +neg(x) = -x; + + +//-------`(ma.)sub(x,y)`------------------ +// Subtract `x` and `y`. +// +// #### Usage +// +// ``` +// _,_ : sub : _ +// ``` +//------------------------------ +sub(x,y) = y-x; + + +//---------------------------------`(ma.)inv`--------------------------------------- +// Compute the inverse (1/x) of the input signal. +// +// #### Usage +// +// ``` +// _ : inv : _ +// ``` +//----------------------------------------------------------------------------- +inv(x) = 1/x; + + +//---------------------------------`(ma.)cbrt`-------------------------------------- +// Computes the cube root of of the input signal. +// +// #### Usage +// +// ``` +// _ : cbrt : _ +// ``` +//----------------------------------------------------------------------------- +cbrt = ffunction(float cbrtf|cbrt|cbrtl (float), ,""); + + +//---------------------------------`(ma.)hypot`------------------------------------- +// Computes the euclidian distance of the two input signals +// sqrt(x*x+y*y) without undue overflow or underflow. +// +// #### Usage +// +// ``` +// _,_ : hypot : _ +// ``` +//----------------------------------------------------------------------------- +hypot = ffunction(float hypotf|hypot|hypotl (float, float), ,""); + + +//---------------------------------`(ma.)ldexp`------------------------------------- +// Takes two input signals: x and n, and multiplies x by 2 to the power n. +// +// #### Usage +// +// ``` +// _,_ : ldexp : _ +// ``` +//----------------------------------------------------------------------------- +ldexp = ffunction(float ldexpf|ldexp|ldexpl (float, int), ,""); + + +//---------------------------------`(ma.)scalb`------------------------------------- +// Takes two input signals: x and n, and multiplies x by 2 to the power n. +// +// #### Usage +// +// ``` +// _,_ : scalb : _ +// ``` +//----------------------------------------------------------------------------- +scalb = ffunction(float scalbnf|scalbn|scalbnl (float, int), ,""); + + +//---------------------------------`(ma.)log1p`---------------------------------- +// Computes log(1 + x) without undue loss of accuracy when x is nearly zero. +// +// #### Usage +// +// ``` +// _ : log1p : _ +// ``` +//----------------------------------------------------------------------------- +log1p = ffunction(float log1pf|log1p|log1pl (float), ,""); + + +//---------------------------------`(ma.)logb`--------------------------------------- +// Return exponent of the input signal as a floating-point number. +// +// #### Usage +// +// ``` +// _ : logb : _ +// ``` +//----------------------------------------------------------------------------- +logb = ffunction(float logbf|logb|logbl (float), ,""); + + +//---------------------------------`(ma.)ilogb`------------------------------------- +// Return exponent of the input signal as an integer number. +// +// #### Usage +// +// ``` +// _ : ilogb : _ +// ``` +//----------------------------------------------------------------------------- +ilogb = ffunction(int ilogbf|ilogb|ilogbl (float), ,""); + + +//---------------------------------`(ma.)log2`------------------------------------- +// Returns the base 2 logarithm of x. +// +// #### Usage +// +// ``` +// _ : log2 : _ +// ``` +//----------------------------------------------------------------------------- +log2(x) = log(x)/log(2.0); + + +//---------------------------------`(ma.)expm1`------------------------------------- +// Return exponent of the input signal minus 1 with better precision. +// +// #### Usage +// +// ``` +// _ : expm1 : _ +// ``` +//----------------------------------------------------------------------------- +expm1 = ffunction(float expm1f|expm1|expm1l (float), ,""); + + +//---------------------------------`(ma.)acosh`------------------------------------- +// Computes the principle value of the inverse hyperbolic cosine +// of the input signal. +// +// #### Usage +// +// ``` +// _ : acosh : _ +// ``` +//----------------------------------------------------------------------------- +acosh = ffunction(float acoshf|acosh|acoshl (float), , ""); + + +//--------------------------------`(ma.)asinh`----------------------------------- +// Computes the inverse hyperbolic sine of the input signal. +// +// #### Usage +// +// ``` +// _ : asinh : _ +// ``` +//----------------------------------------------------------------------------- +asinh = ffunction(float asinhf|asinh|asinhl (float), , ""); + + +//--------------------------------`(ma.)atanh`----------------------------------- +// Computes the inverse hyperbolic tangent of the input signal. +// +// #### Usage +// +// ``` +// _ : atanh : _ +// ``` +//----------------------------------------------------------------------------- +atanh = ffunction(float atanhf|atanh|atanhl (float), , ""); + + +//---------------------------------`(ma.)sinh`--------------------------------------- +// Computes the hyperbolic sine of the input signal. +// +// #### Usage +// +// ``` +// _ : sinh : _ +// ``` +//----------------------------------------------------------------------------- +sinh = ffunction(float sinhf|sinh|sinhl (float), , ""); + + +//---------------------------------`(ma.)cosh`-------------------------------------- +// Computes the hyperbolic cosine of the input signal. +// +// #### Usage +// +// ``` +// _ : cosh : _ +// ``` +//----------------------------------------------------------------------------- +cosh = ffunction(float coshf|cosh|coshl (float), , ""); + + +//---------------------------------`(ma.)tanh`-------------------------------------- +// Computes the hyperbolic tangent of the input signal. +// +// #### Usage +// +// ``` +// _ : tanh : _ +// ``` +//----------------------------------------------------------------------------- +tanh = ffunction(float tanhf|tanh|tanhl (float), ,""); + + +//---------------------------------`(ma.)erf`--------------------------------------- +// Computes the error function of the input signal. +// +// #### Usage +// +// ``` +// _ : erf : _ +// ``` +//----------------------------------------------------------------------------- +erf = ffunction(float erff|erf|erfl(float), ,""); + + +//---------------------------------`(ma.)erfc`--------------------------------------- +// Computes the complementary error function of the input signal. +// +// #### Usage +// +// ``` +// _ : erfc : _ +// ``` +//----------------------------------------------------------------------------- +erfc = ffunction(float erfcf|erfc|erfcl(float), ,""); + + +//---------------------------------`(ma.)gamma`------------------------------------- +// Computes the gamma function of the input signal. +// +// #### Usage +// +// ``` +// _ : gamma : _ +// ``` +//----------------------------------------------------------------------------- +gamma = ffunction(float tgammaf|tgamma|tgammal(float), ,""); + + +//---------------------------------`(ma.)lgamma`------------------------------------ +// Calculates the natural logorithm of the absolute value of +// the gamma function of the input signal. +// +// #### Usage +// +// ``` +// _ : lgamma : _ +// ``` +//----------------------------------------------------------------------------- +lgamma = ffunction(float lgammaf|lgamma|lgammal(float), ,""); + + +//----------------------------------`(ma.)J0`--------------------------------------- +// Computes the Bessel function of the first kind of order 0 +// of the input signal. +// +// #### Usage +// +// ``` +// _ : J0 : _ +// ``` +//----------------------------------------------------------------------------- +J0 = ffunction(float j0(float), ,""); + + +//----------------------------------`(ma.)J1`--------------------------------------- +// Computes the Bessel function of the first kind of order 1 +// of the input signal. +// +// #### Usage +// +// ``` +// _ : J1 : _ +// ``` +//----------------------------------------------------------------------------- +J1 = ffunction(float j1(float), ,""); + + +//----------------------------------`(ma.)Jn`--------------------------------------- +// Computes the Bessel function of the first kind of order n +// (first input signal) of the second input signal. +// +// #### Usage +// +// ``` +// _,_ : Jn : _ +// ``` +//----------------------------------------------------------------------------- +Jn = ffunction(float jn(int, float), ,""); + + +//----------------------------------`(ma.)Y0`--------------------------------------- +// Computes the linearly independent Bessel function of the second kind +// of order 0 of the input signal. +// +// #### Usage +// +// ``` +// _ : Y0 : _ +// ``` +//----------------------------------------------------------------------------- +Y0 = ffunction(float y0(float), ,""); + + +//----------------------------------`(ma.)Y1`--------------------------------------- +// Computes the linearly independent Bessel function of the second kind +// of order 1 of the input signal. +// +// #### Usage +// +// ``` +// _ : Y0 : _ +// ``` +//----------------------------------------------------------------------------- +Y1 = ffunction(float y1(float), ,""); + + +//----------------------------------`(ma.)Yn`--------------------------------------- +// Computes the linearly independent Bessel function of the second kind +// of order n (first input signal) of the second input signal. +// +// #### Usage +// +// ``` +// _,_ : Yn : _ +// ``` +//----------------------------------------------------------------------------- +Yn = ffunction(float yn(int, float), ,""); + + +//----------------------------`(ma.)fabs`, `(ma.)fmax`, `(ma.)fmin`--------------------------- +// Just for compatibility... +// +// ``` +// fabs = abs +// fmax = max +// fmin = min +// ``` +//----------------------------------------------------------------------------- +fabs = abs; +fmax = max; +fmin = min; + +//-------------------------------`(ma.)np2`-------------------------------------- +// Gives the next power of 2 of x. +// +// #### Usage +// +// ``` +// np2(n) : _ +// ``` +// +// Where: +// +// * `n`: an integer +//----------------------------------------------------------------------------- +np2 = -(1) <: >>(1)|_ <: >>(2)|_ <: >>(4)|_ <: >>(8)|_ <: >>(16)|_ : +(1); + + +//-----------------------------`(ma.)frac`--------------------------------------- +// Gives the fractional part of n. +// +// #### Usage +// +// ``` +// frac(n) : _ +// ``` +// +// Where: +// +// * `n`: a decimal number +//------------------------------------------------------------------------------ +frac(n) = n - floor(n); +decimal = frac; + +// NOTE: decimal does the same thing as frac but using floor instead. JOS uses frac a lot +// in filters.lib so we decided to keep that one... decimal is declared though for +// backward compatibility. +// decimal(n) = n - floor(n); + + +//-------------------------------`(ma.)modulo`--------------------------------------- +// Modulus operation. +// +// #### Usage +// +// ``` +// modulo(x,y) : _ +// ``` +// +// Where: +// +// * `x`: the numerator +// * `y`: the denominator +//------------------------------------------------------------------------------ +modulo(x,y) = (x % y + y) % y; + + +//---------------`(ma.)isnan`---------------- +// Return non-zero if x is a NaN. +// +// #### Usage +// +// ``` +// isnan(x) +// _ : isnan : _ +// ``` +// +// Where: +// +// * `x`: signal to analyse +//------------------------------------------ +isnan = ffunction(int isnanf|isnan|isnanl (float),,""); + + +//---------------`(ma.)isinf`---------------- +// Return non-zero if x is a positive or negative infinity. +// +// #### Usage +// +// ``` +// isinf(x) +// _ : isinf : _ +// ``` +// +// Where: +// +// * `x`: signal to analyse +//------------------------------------------ +isinf = ffunction(int isinff|isinf|isinfl (float),,""); + +nextafter = ffunction(float nextafter(float, float),,""); + + +//---------------------------`(ma.)chebychev`------------------------------- +// Chebychev transformation of order N. +// +// #### Usage +// +// ``` +// _ : chebychev(N) : _ +// ``` +// +// Where: +// +// * `N`: the order of the polynomial, a constant numerical expression +// +// #### Semantics +// +// ``` +// T[0](x) = 1, +// T[1](x) = x, +// T[n](x) = 2x*T[n-1](x) - T[n-2](x) +// ``` +// +// #### Reference +// +// +//------------------------------------------------------------------------- +chebychev(0,x) = 1; +chebychev(1,x) = x; +chebychev(n,x) = 2*x*chebychev(n-1, x) - chebychev(n-2, x); + + +//------------------------`(ma.)chebychevpoly`------------------------------- +// Linear combination of the first Chebyshev polynomials. +// +// #### Usage +// +// ``` +// _ : chebychevpoly((c0,c1,...,cn)) : _ +// ``` +// +// Where: +// +// * `cn`: the different Chebychevs polynomials such that: +// chebychevpoly((c0,c1,...,cn)) = Sum of chebychev(i)*ci +// +// #### Reference +// +// +//------------------------------------------------------------------------- +chebychevpoly(lcoef) = _ <: L(0,lcoef) :> _ + with { + L(n,(c,cs)) = chebychev(n)*c, L(n+1,cs); + L(n,c) = chebychev(n)*c; + }; + + +//------------------`(ma.)diffn`---------------------------- +// Negated first-order difference. +// +// #### Usage +// +// ``` +// _ : diffn : _ +// ``` +//-------------------------------------------------------- +diffn(x) = x' - x; // negated first-order difference + + +//------------------`(ma.)signum`---------------------------- +// The signum function signum(x) is defined as +// -1 for x<0, 0 for x==0, and 1 for x>0. +// +// #### Usage +// +// ``` +// _ : signum : _ +// ``` +//-------------------------------------------------------- +signum(x) = (x>0)-(x<0); + + +//------------------`(ma.)nextpow2`---------------------------- +// The nextpow2(x) returns the lowest integer m such that +// 2^m >= x. +// +// #### Usage +// +// ``` +// 2^nextpow2(n) : _ +// ``` +// Useful for allocating delay lines, e.g., +// ``` +// delay(2^nextpow2(maxDelayNeeded), currentDelay); +// ``` +//-------------------------------------------------------- +nextpow2(x) = ceil(log(x)/log(2.0)); + + +//--------------------`(ma.)zc`------------------------------------------------ +// Indicator function for zero-crossing: it returns 1 if a zero-crossing +// occurs, 0 otherwise. +// +// #### Usage +// +// ``` +// _ : zc : _ +// ``` +//----------------------------------------------------------------------------- +zc(x) = x * x' < 0; + diff --git a/dist/examples/LIBRARIES/maxmsp.lib b/dist/examples/LIBRARIES/maxmsp.lib new file mode 100644 index 00000000..08a78eee --- /dev/null +++ b/dist/examples/LIBRARIES/maxmsp.lib @@ -0,0 +1,237 @@ +//#################################### maxmsp.lib ######################################## +// MaxMSP compatibility Library. +// +// #### References +// * +//######################################################################################## + + + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2019-2020 GRAME, Centre National de Creation Musicale +--------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commerci +************************************************************************ +************************************************************************/ + +ba = library("basics.lib"); +ma = library("maths.lib"); + +declare name "MaxMSP compatibility Library"; +declare author "GRAME"; +declare copyright "GRAME"; +declare version "1.1"; +declare license "LGPL with exception"; + +atodb = db2lin; + +//------------------------------------------------------------------------- +// +// Implementation of MaxMSP filtercoeff +// +// from : Cookbook formulae for audio EQ biquad filter coefficients +// by : Robert Bristow-Johnson +// URL : +// +//------------------------------------------------------------------------- + +filtercoeff(f0, dBgain, Q) = environment +{ + //---------------------------------------- + // biquad coeffs for various filters + // usage : filtercoeff(f0, dBgain, Q).LPF + //---------------------------------------- + + LPF = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = (1 - cos(w0))/2; + b1 = 1 - cos(w0); + b2 = (1 - cos(w0))/2; + a0 = 1 + alpha; + a1 = -2*cos(w0); + a2 = 1 - alpha; + }; + + HPF = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = (1 + cos(w0))/2; + b1 = -1 - cos(w0); + b2 = (1 + cos(w0))/2; + a0 = 1 + alpha; + a1 = -2*cos(w0); + a2 = 1 - alpha; + }; + + BPF = rbjcoef(a0, a1, a2, b0, b1, b2) // constant 0 dB peak gain + with { + b0 = alpha; + b1 = 0; + b2 = -alpha; + a0 = 1 + alpha; + a1 = -2*cos(w0); + a2 = 1 - alpha; + }; + + notch = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = 1; + b1 = -2*cos(w0); + b2 = 1; + a0 = 1 + alpha; + a1 = -2*cos(w0); + a2 = 1 - alpha; + }; + + APF = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = 1 - alpha; + b1 = -2*cos(w0); + b2 = 1 + alpha; + a0 = 1 + alpha; + a1 = -2*cos(w0); + a2 = 1 - alpha; + }; + + peakingEQ = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = 1 + alpha*A; + b1 = -2*cos(w0); + b2 = 1 - alpha*A; + a0 = 1 + alpha/A; + a1 = -2*cos(w0); + a2 = 1 - alpha/A; + }; + + peakNotch = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = 1 + alpha*G; + b1 = -2*cos(w0); + b2 = 1 - alpha*G; + a0 = 1 + alpha/G; + a1 = -2*cos(w0); + a2 = 1 - alpha/G; + }; + + lowShelf = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = A*((A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha); + b1 = 2*A*((A-1) - (A+1)*cos(w0)); + b2 = A*((A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha); + a0 = (A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha; + a1 = -2*((A-1) + (A+1)*cos(w0)); + a2 = (A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha; + }; + + highShelf = rbjcoef(a0, a1, a2, b0, b1, b2) + with { + b0 = A*((A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha); + b1 = -2*A*((A-1) + (A+1)*cos(w0)); + b2 = A*((A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha); + a0 = (A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha; + a1 = 2*((A-1) - (A+1)*cos(w0)); + a2 = (A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha; + }; + + // --------------------- implementation ------------------------------ + + // convert rbj coeffs to biquad coeffs + rbjcoef(a0,a1,a2,b0,b1,b2) = (b0/a0, b1/a0, b2/a0, a1/a0, a2/a0); + + // common values + alpha = sin(w0)/(2*max(0.001,Q)); + w0 = 2*ma.PI*max(0,f0)/Fs; + Fs = ma.SR; + A = 10^(dBgain/40); // (for peaking and shelving EQ filters only) + G = sqrt(max(0.00001, dBgain)); // When gain is a linear values (i.e. not in dB) +}; + + +//------------------------------------------------------------------------- +// Implementation of MaxMSP biquad~ +// y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] - b1 * y[n-1] - b2 * y[n-2] +//------------------------------------------------------------------------- + +biquad(x,a0,a1,a2,b1,b2) = x : + ~ ((-1)*conv2(b1, b2)) : conv3(a0, a1, a2) + with { + conv2(c0,c1,x) = c0*x+c1*x'; + conv3(c0,c1,c2,x) = c0*x+c1*x'+c2*x''; + }; + +//------------------------------------------------------------------------- +// +// Filters using filtercoeff and biquad +// +//------------------------------------------------------------------------- + +// Low Pass Filter +LPF(x, f0, gain, Q)= x , filtercoeff(f0,gain,Q).LPF : biquad; + +// High Pass Filter +HPF(x, f0, gain, Q) = x , filtercoeff(f0,gain,Q).HPF : biquad; + +// Band Pass Filter +BPF(x, f0, gain, Q) = x , filtercoeff(f0,gain,Q).BPF : biquad; + +// notch Filter +notch(x, f0, gain, Q)= x , filtercoeff(f0,gain,Q).notch : biquad; + +// All Pass Filter +APF(x, f0, gain, Q) = x , filtercoeff(f0,gain,Q).APF : biquad; + +// ???? +peakingEQ(x, f0, gain, Q) = x , filtercoeff(f0,gain,Q).peakingEQ : biquad; + +// Max peakNotch is like peakingEQ but with a linear gain +peakNotch(x, f0, gain, Q) = x , filtercoeff(f0,gain,Q).peakNotch : biquad; + +// ???? +lowShelf(x, f0, gain, Q) = x , filtercoeff(f0,gain,Q).lowShelf : biquad; + +// ???? +highShelf(x, f0, gain, Q) = x , filtercoeff(f0,gain,Q).highShelf : biquad; + + +//------------------------------------------------------------------------- +// Implementation of Max/MSP line~. Generate signal ramp or envelop +// +// USAGE : line(value, time) +// value : the desired output value +// time : the interpolation time to reach this value (in milliseconds) +// +// NOTE : the interpolation process is restarted every time the desired +// output value changes. The interpolation time is sampled only then. +//------------------------------------------------------------------------- + +line(value, time) = state~(_,_):!,_ + with { + state(t, c) = nt,nc + with { + nt = ba.if(value != value', samples, t-1); + nc = ba.if(nt > 0, c + (value - c)/nt, value); + samples = time*ma.SR/1000.0; + }; + }; diff --git a/dist/examples/LIBRARIES/mi.lib b/dist/examples/LIBRARIES/mi.lib new file mode 100644 index 00000000..f8ad2ab8 --- /dev/null +++ b/dist/examples/LIBRARIES/mi.lib @@ -0,0 +1,528 @@ +//############################# mi.lib ######################################### +// This ongoing work is the fruit of a collaboration between GRAME-CNCM and +// the ANIS (Arts Numériques et Immersions Sensorielles) research group from +// GIPSA-Lab (Université Grenoble Alpes). +// +// This library implements basic 1-DoF mass-interaction physics algorithms, +// allowing to declare and connect physical elements (masses, springs, non +// linear interactions, etc.) together to form topological networks. +// Models can be assembled by hand, however in more complex scenarios it is +// recommended to use a scripting tool (such as MIMS) to generate the FAUST +// signal routing for a given physical network. Its official prefix is `mi`. +// +// +// +// +// +// +// ## Sources +// +// The core mass-interaction algorithms implemented in this library are in the public +// domain and are disclosed in the following scientific publications: +// +// * Claude Cadoz, Annie Luciani, Jean-Loup Florens, Curtis Roads and Françoise +// Chabade. Responsive Input Devices and Sound Synthesis by Stimulation of +// Instrumental Mechanisms: The Cordis System. Computer Music Journal, Vol 8. +// No. 3, 1984. +// * Claude Cadoz, Annie Luciani and Jean Loup Florens. CORDIS-ANIMA: A Modeling +// and Simulation System for Sound and Image Synthesis: The General Formalism. +// Computer Music Journal. Vol. 17, No. 1, 1993. +// * Alexandros Kontogeorgakopoulos and Claude Cadoz. Cordis Anima Physical +// Modeling and Simulation System Analysis. In Proceedings of the Sound and Music +// Computing Conference (SMC-07), Lefkada, Greece, 2007. +// * Nicolas Castagne, Claude Cadoz, Ali Allaoui and Olivier Tache. G3: Genesis +// Software Environment Update. In Proceedings of the International Computer +// Music Conference (ICMC-09), Montreal, Canada, 2009. +// * Nicolas Castagné and Claude Cadoz. Genesis 3: Plate-forme pour la création +// musicale à l'aide des modèles physiques Cordis-Anima. In Proceedings of the +// Journée de l'Informatique Musicale, Grenoble, France, 2009. +// * Edgar Berdahl and Julius O. Smith. An Introduction to the Synth-A-Modeler +// Compiler: Modular and Open-Source Sound Synthesis using Physical Models. In +// Proceedings of the Linux Audio Conference (LAC-12), Stanford, USA, 2012. +// * James Leonard and Claude Cadoz. Physical Modelling Concepts for a Collection +// of Multisensory Virtual Musical Instruments. In Proceedings of the New +// Interfaces for Musical Expression (NIME-15) Conference, Baton Rouge, USA, 2015. +// +// #### References +// * +//############################################################################## + +ma = library("maths.lib"); +ba = library("basics.lib"); + +declare name "Faust mass-interaction physical modelling library"; +declare version "0.0"; +declare author "James Leonard"; +declare author "Romain Michon"; +declare copyright "2018-2020 GRAME / GIPSA-Lab"; + +//===============================Utility Functions======================================== +// These utility functions are used to help certain operations (e.g. define initial +// positions and velocities for physical elements). +//======================================================================================== + + +//------------------------`(mi.)initState`---------------------- +// Used to set initial delayed position values that must be initialised +// at step 0 of the physics simulation. +// +// If you develop any of your own modules, you will need to use this (see +// `mass` and `springDamper` algorithm codes for examples). +// +// #### Usage +// +// ``` +// x : initState(x0) : _ +// ``` +// +// Where: +// +// * `x`: position value signal +// * `x0`: initial value for position +//--------------------------------------------------------- +initState(init) = R(0,init) +with{ + R(n,(initn,init)) = +(1: ba.impulsify@n * initn) : R(n+1,init); + R(n,initn) = +(1 : ba.impulsify@n * initn); +}; + + +//=================================Mass Algorithms======================================== +// All mass-type physical element functions are declared here. They all expect to receive +// a force input signal and produce a position signal. +// All physical parameters are expressed in sample-rate dependant values. +//======================================================================================== + + +//------------------------`(mi.)mass`---------------------- +// Implementation of a punctual mass element. +// Takes an input force and produces output position. +// +// #### Usage +// +// ``` +// mass(m, grav, x0, xr0),_ : _ +// ``` +// +// Where: +// +// * `m`: mass value +// * `grav`: gravity force value +// * `x0`: initial position +// * `xr0`: initial delayed position (inferred from initial velocity) +//--------------------------------------------------------- +mass(m, grav, x0, x1) = equation +with{ + A = 2; + B = -1; + C = 1/m; + equation = x + letrec{ + 'x = A*(x : initState(x0)) + B*(x' : initState((x1,x0))) + (_-grav)*(C); + }; +}; + + +//------------------------`(mi.)oscil`---------------------- +// Implementation of a simple linear harmonic oscillator. +// Takes an input force and produces output position. +// +// #### Usage +// +// ``` +// oscil(m, k, z, grav, x0, xr0),_ : _ +// ``` +// +// Where: +// +// * `m`: mass value +// * `k`: stiffness value +// * `z`: damping value +// * `grav`: gravity force value +// * `x0`: initial position +// * `xr0`: initial delayed position (inferred from initial velocity) +//--------------------------------------------------------- +oscil(m, k, z, grav, x0, x1) = equation +with{ + A = 2 - (k + z)/m; + B = z/m - 1; + C = 1/m; + equation = x + letrec{ + 'x = A*(x : initState(x0)) + B*(x' : initState((x1, x0))) + (_-grav)*(C); + }; +}; + + +//------------------------`(mi.)ground`---------------------- +// Implementation of a fixed point element. +// The position output produced by this module never changes, however +// it still expects a force input signal (for compliance with connection +// rules). +// +// #### Usage +// +// ``` +// ground(x0),_ : _ +// ``` +// +// Where: +// +// * `x0`: initial position +//--------------------------------------------------------- +ground(x0) = equation +with{ + // could this term be removed or simlified? Need "unused" input force signal for the routing scheme to work + C = 0; + equation = x + letrec{ + 'x = (x : initState(x0)) + *(C); + }; +}; + + +//------------------------`(mi.)posInput`---------------------- +// Implementation of a position input module (driven by an outside +// signal). Takes two signal inputs: incoming force (which doesn't +// affect position) and the driving position signal. +// +// #### Usage +// +// ``` +// posInput(x0),_,_ : _ +// ``` +// +// Where: +// +// * `x0`: initial position +//--------------------------------------------------------- +posInput(init) = _,_ : !,_ : initState(init); + + +//===============================Interaction Algorithms==================================== +// All interaction-type physical element functions are declared here. They each expect to +// receive two position signals (coming from the two mass-elements that they connect) and +// produce two equal and opposite force signals that must be routed back to the mass +// elements' inputs. +// All physical parameters are expressed in sample-rate dependant values. +//========================================================================================= + + +//------------------------`(mi.)spring`---------------------- +// Implementation of a linear elastic spring interaction. +// +// #### Usage +// +// ``` +// spring(k, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `k`: stiffness value +// * `x1r`: initial delayed position of mass 1 (unused here) +// * `x2r`: initial delayed position of mass 2 (unused here) +//--------------------------------------------------------- +spring(k, x1r0, x2r0, x1, x2) = + k*deltapos <: *(-1),_ +with{ + deltapos = x1-x2; +}; + + +//------------------------`(mi.)damper`---------------------- +// Implementation of a linear damper interaction. +// Beware: in 32bit precision mode, damping forces can become +// truncated if position values are not centered around zero! +// +// #### Usage +// +// ``` +// damper(z, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `z`: damping value +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +damper(z, x1r0, x2r0, x1, x2) = + z*deltavel <: *(-1),_ +with{ + deltavel = (x1 - x1' : initState(x1r0)) - (x2 - x2' : initState(x2r0)); +}; + + +//------------------------`(mi.)springDamper`---------------------- +// Implementation of a linear viscoelastic spring-damper interaction +// (a combination of the spring and damper modules). +// +// #### Usage +// +// ``` +// springDamper(k, z, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `k`: stiffness value +// * `z`: damping value +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +springDamper(k, z, x1r0, x2r0, x1, x2) = + k*deltapos + + z*deltavel <: *(-1),_ +with{ + deltapos = x1-x2; + deltavel = (x1 - x1' : initState(x1r0)) - (x2 - x2' : initState(x2r0)); +}; + + +//------------------------`(mi.)nlSpringDamper2`---------------------- +// Implementation of a non-linear viscoelastic spring-damper interaction +// containing a quadratic term (function of squared distance). +// Beware: at high displacements, this interaction will break numerical +// stability conditions ! The `nlSpringDamperClipped` is a safer option. +// +// #### Usage +// +// ``` +// nlSpringDamper2(k, q, z, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `k`: linear stiffness value +// * `q`: quadratic stiffness value +// * `z`: damping value +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +nlSpringDamper2(k, q, z, x1r0, x2r0, x1, x2) = + k*deltapos + q * ma.signum(deltapos) * pow(deltapos, 2) + + z*deltavel <: *(-1),_ +with{ + deltapos = x1-x2; + deltavel = (x1 - x1' : initState(x1r0)) - (x2 - x2' : initState(x2r0)); +}; + + +//------------------------`(mi.)nlSpringDamper3`---------------------- +// Implementation of a non-linear viscoelastic spring-damper interaction +// containing a cubic term (function of distance^3). +// Beware: at high displacements, this interaction will break numerical +// stability conditions ! The `nlSpringDamperClipped` is a safer option. +// +// #### Usage +// +// ``` +// nlSpringDamper3(k, q, z, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `k`: linear stiffness value +// * `q`: cubic stiffness value +// * `z`: damping value +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +nlSpringDamper3(k, q, z, x1r0, x2r0, x1, x2) = + k*deltapos + q * pow(deltapos, 3) + + z*deltavel <: *(-1),_ +with{ + deltapos = x1-x2; + deltavel = (x1 - x1' : initState(x1r0)) - (x2 - x2' : initState(x2r0)); +}; + + +//------------------------`(mi.)nlSpringDamperClipped`---------------------- +// Implementation of a non-linear viscoelastic spring-damper interaction +// containing a cubic term (function of distance^3), bound by an +// upper linear stiffness (hard-clipping). +// +// This bounding means that when faced with strong displacements, the +// interaction profile will "clip" at a given point and never produce +// forces higher than the bounding equivalent linear spring, stopping models +// from becoming unstable. +// +// So far the interaction clips "hard" (with no soft-knee spline +// interpolation, etc.) +// +// #### Usage +// +// ``` +// nlSpringDamperClipped(s, c, k, z, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `s`: linear stiffness value +// * `c`: cubic stiffness value +// * `k`: upper-bound linear stiffness value +// * `z`: (linear) damping value +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +nlSpringDamperClipped(s, c, k, z, x1r0, x2r0, x1, x2) = + select2(c == 0, + select2(s >= k, + select2(absdeltapos <= b, + // Overdamping induced here to prevent "locked" states... + k * deltapos + (z+0.3*k)*deltavel, + s * deltapos + c * pow(deltapos, 3) + z*deltavel + ), + k * deltapos + z*deltavel + ), + s * deltapos + z*deltavel + )<: *(-1),_ +with{ + b = sqrt(k-s)/c; + deltapos = x1-x2; + deltavel = (x1 - x1' : initState(x1r0)) - (x2 - x2' : initState(x2r0)); + absdeltapos = abs(deltapos); + +}; + + +//------------------------`(mi.)nlPluck`---------------------- +// Implementation of a piecewise linear plucking interaction. +// The symmetric function provides a repulsive viscoelastic interaction +// upon contact, until a tipping point is reached (when the plucking occurs). +// The tipping point depends both on the stiffness and the distance scaling +// of the interaction. +// +// +// #### Usage +// +// ``` +// nlPluck(knl, scale, z, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `knl`: stiffness scaling parameter (vertical stretch of the NL function) +// * `scale`: distance scaling parameter (horizontal stretch of the NL function) +// * `z`: (linear) damping value +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +nlPluck(k, scale, z, x1r0, x2r0, x1, x2) = + select2(absdeltapos < tipdist, + select2(absdeltapos < scale, + 0, + ma.signum(deltapos)* -tipdist * k + Kend * deltapos + + z* deltavel + ), + (k - Kend) * -deltapos + z* deltavel + ) <: *(-1),_ +with{ + deltapos = x1 - x2; + deltavel = (x1 - x1' : initState(x1r0)) - (x2 - x2' : initState(x2r0)); + + absdeltapos = abs(deltapos); + sharpness = 10; + tipdist = scale / sharpness; + Kend = k / sharpness; +}; + + +//------------------------`(mi.)nlBow`---------------------- +// Implementation of a non-linear friction based interaction +// that allows for stick-slip bowing behaviour. +// Two versions are proposed : a piecewise linear function (very +// similar to the `nlPluck`) or a mathematical approximation (see +// Stefan Bilbao's book, Numerical Sound Synthesis). +// +// +// #### Usage +// +// ``` +// nlBow(znl, scale, type, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `znl`: friction scaling parameter (vertical stretch of the NL function) +// * `scale`: velocity scaling parameter (horizontal stretch of the NL function) +// * `type`: interaction profile (0 = piecewise linear, 1 = smooth function) +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +nlBow(z, scale, type, x1r0, x2r0, x1, x2) = + select2(type > 0, + select2(absdeltavel < tipvel, + select2(absdeltavel < scale, + 0, + ma.signum(deltavel)* tipvel * z - Zend * deltavel + ), + (z - Zend) * deltavel + ), + 0.63 * z * deltavel *exp(-4*pow(deltavel/scale, 2) + 1/2) + ) + <: *(-1),_ +with{ + deltavel = (x1 - x1' : initState(x1r0)) - (x2 - x2' : initState(x2r0)); + absdeltavel = abs(deltavel); + sharpness = 3; + tipvel = scale / sharpness; + Zend = z / sharpness; +}; + + +//------------------------`(mi.)collision`---------------------- +// Implementation of a collision interaction, producing linear visco-elastic +// repulsion forces when two mass elements are interpenetrating. +// +// +// #### Usage +// +// ``` +// collision(k, z, thres, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `k`: collision stiffness parameter +// * `z`: collision damping parameter +// * `thres`: threshold distance for the contact between elements +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +collision(k,z,thres,x1r0,x2r0,x1,x2) = + springDamper(k,z,x1r0,x2r0,x1+thres,x2) : (select2(comp,0,_),select2(comp,0,_)) +with{ + comp = (x2-x1) < thres; +}; + + +//------------------------`(mi.)nlCollisionClipped`---------------------- +// Implementation of a collision interaction, producing non-linear +// visco-elastic repulsion forces when two mass elements are interpenetrating. +// Bound by an upper stiffness value to maintain stability. +// This interaction is particularly useful for more realistic contact dynamics +// (greater difference in velocity provides sharper contacts, and reciprocally). +// +// #### Usage +// +// ``` +// nlCollisionClipped(s, c, k, z, thres, x1r, x2r),_,_ : _,_ +// ``` +// +// Where: +// +// * `s`: collision linear stiffness parameter +// * `c`: collision cubic stiffness parameter +// * `k`: collision upper-bounding stiffness parameter +// * `z`: collision damping parameter +// * `thres`: threshold distance for the contact between elements +// * `x1r`: initial delayed position of mass 1 +// * `x2r`: initial delayed position of mass 2 +//--------------------------------------------------------- +nlCollisionClipped(s, c, k, z, thres, x1r0, x2r0, x1, x2) = + nlSpringDamperClipped(s,c,k,z,x1r0,x2r0,x1+thres,x2) : (select2(comp,0,_),select2(comp,0,_)) +with{ + comp = (x2-x1) < thres; +}; diff --git a/dist/examples/LIBRARIES/misceffects.lib b/dist/examples/LIBRARIES/misceffects.lib new file mode 100644 index 00000000..3b174de1 --- /dev/null +++ b/dist/examples/LIBRARIES/misceffects.lib @@ -0,0 +1,588 @@ +//################################## misceffects.lib ########################################## +// This library contains a collection of audio effects. Its official prefix is `ef`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2003-2016 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +ba = library("basics.lib"); +de = library("delays.lib"); +si = library("signals.lib"); +an = library("analyzers.lib"); +fi = library("filters.lib"); +ef = library("misceffects.lib"); // for compatible copy/paste out of this file + +declare name "Misc Effects Library"; +declare version "2.0"; + +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2019 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +MarkDown comments in this section are Copyright 2016-2019 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees!) + +************************************************************************/ + +//======================================Dynamic=========================================== +//======================================================================================== + +//---------------------`(ef.)cubicnl`----------------------- +// Cubic nonlinearity distortion. +// `cubicnl` is a standard Faust function. +// +// #### Usage: +// +// ``` +// _ : cubicnl(drive,offset) : _ +// _ : cubicnl_nodc(drive,offset) : _ +// ``` +// +// Where: +// +// * `drive`: distortion amount, between 0 and 1 +// * `offset`: constant added before nonlinearity to give even harmonics. Note: offset +// can introduce a nonzero mean - feed cubicnl output to dcblocker to remove this. +// +// #### References: +// +// * +// * +//------------------------------------------------------------ +cubicnl(drive,offset) = *(pregain) : +(offset) : clip(-1,1) : cubic +with { + pregain = pow(10.0,2*drive); + clip(lo,hi) = min(hi) : max(lo); + cubic(x) = x - x*x*x/3; + postgain = max(1.0,1.0/pregain); +}; + +cubicnl_nodc(drive,offset) = cubicnl(drive,offset) : fi.dcblocker; + + +//-----------------`(ef.)gate_mono`------------------- +// Mono signal gate. +// `gate_mono` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : gate_mono(thresh,att,hold,rel) : _ +// ``` +// +// Where: +// +// * `thresh`: dB level threshold above which gate opens (e.g., -60 dB) +// * `att`: attack time = time constant (sec) for gate to open (e.g., 0.0001 s = 0.1 ms) +// * `hold`: hold time = time (sec) gate stays open after signal level < thresh (e.g., 0.1 s) +// * `rel`: release time = time constant (sec) for gate to close (e.g., 0.020 s = 20 ms) +// +// #### References +// +// * +// * +// * +//------------------------------------------------------------ +gate_mono(thresh,att,hold,rel,x) = x * gate_gain_mono(thresh,att,hold,rel,x); + + +//-----------------`(ef.)gate_stereo`------------------- +// Stereo signal gates. +// `gate_stereo` is a standard Faust function. +// +// #### Usage +// +// ``` +// _,_ : gate_stereo(thresh,att,hold,rel) : _,_ +// ``` +// +// Where: +// +// * `thresh`: dB level threshold above which gate opens (e.g., -60 dB) +// * `att`: attack time = time constant (sec) for gate to open (e.g., 0.0001 s = 0.1 ms) +// * `hold`: hold time = time (sec) gate stays open after signal level < thresh (e.g., 0.1 s) +// * `rel`: release time = time constant (sec) for gate to close (e.g., 0.020 s = 20 ms) +// +// #### References +// +// * +// * +// * +//------------------------------------------------------------ +gate_stereo(thresh,att,hold,rel,x,y) = ggm*x, ggm*y with { + ggm = gate_gain_mono(thresh,att,hold,rel,abs(x)+abs(y)); +}; + +gate_gain_mono(thresh,att,hold,rel,x) = x : extendedrawgate : an.amp_follower_ar(att,rel) with { + extendedrawgate(x) = max(float(rawgatesig(x)),holdsig(x)); + rawgatesig(x) = inlevel(x) > ba.db2linear(thresh); + minrate = min(att,rel); + inlevel = an.amp_follower_ar(minrate,minrate); + holdcounter(x) = (max(holdreset(x) * holdsamps,_) ~-(1)); + holdsig(x) = holdcounter(x) > 0; + holdreset(x) = rawgatesig(x) < rawgatesig(x)'; // reset hold when raw gate falls + holdsamps = int(hold*ma.SR); +}; + + +//=====================================Filtering========================================== +//======================================================================================== + +//-------------------------`(ef.)speakerbp`------------------------------- +// Dirt-simple speaker simulator (overall bandpass eq with observed +// roll-offs above and below the passband). +// +// Low-frequency speaker model = +12 dB/octave slope breaking to +// flat near f1. Implemented using two dc blockers in series. +// +// High-frequency model = -24 dB/octave slope implemented using a +// fourth-order Butterworth lowpass. +// +// Example based on measured Celestion G12 (12" speaker): +// +// `speakerbp` is a standard Faust function. +// +// #### Usage +// +// ``` +// speakerbp(f1,f2) +// _ : speakerbp(130,5000) : _ +// ``` +//------------------------------------------------------------ +// TODO: perhaps this should be moved to physmodels.lib +// [JOS: I don't think so because it's merely a bandpass filter tuned to speaker bandwidth] +speakerbp(f1,f2) = fi.dcblockerat(f1) : fi.dcblockerat(f1) : fi.lowpass(4,f2); + + +//------------`(ef.)piano_dispersion_filter`--------------- +// Piano dispersion allpass filter in closed form. +// +// #### Usage +// +// ``` +// piano_dispersion_filter(M,B,f0) +// _ : piano_dispersion_filter(1,B,f0) : +(totalDelay),_ : fdelay(maxDelay) : _ +// ``` +// +// Where: +// +// * `M`: number of first-order allpass sections (compile-time only) +// Keep below 20. 8 is typical for medium-sized piano strings. +// * `B`: string inharmonicity coefficient (0.0001 is typical) +// * `f0`: fundamental frequency in Hz +// +// #### Outputs +// +// * MINUS the estimated delay at `f0` of allpass chain in samples, +// provided in negative form to facilitate subtraction +// from delay-line length. +// * Output signal from allpass chain +// +// #### Reference +// +// * "Dispersion Modeling in Waveguide Piano Synthesis Using Tunable +// Allpass Filters", by Jukka Rauhala and Vesa Valimaki, DAFX-2006, pp. 71-76 +// * +// An erratum in Eq. (7) is corrected in Dr. Rauhala's encompassing +// dissertation (and below). +// * +//------------------------------------------------------------ +// TODO: perhaps this should be moved to physmodels.lib? +// [JOS: I vote yes when there is a piano model in physmodels.lib.] + +piano_dispersion_filter(M,B,f0) = -Df0*M,seq(i,M,fi.tf1(a1,1,a1)) +with { + a1 = (1-D)/(1+D); // By Eq. 3, have D >= 0, hence a1 >= 0 also + D = exp(Cd - Ikey(f0)*kd); + trt = pow(2.0,1.0/12.0); // 12th root of 2 + logb(b,x) = log(x) / log(b); // log-base-b of x + Ikey(f0) = logb(trt,f0*trt/27.5); + Bc = max(B,0.000001); + kd = exp(k1*log(Bc)*log(Bc) + k2*log(Bc)+k3); + Cd = exp((m1*log(M)+m2)*log(Bc)+m3*log(M)+m4); + k1 = -0.00179; + k2 = -0.0233; + k3 = -2.93; + m1 = 0.0126; + m2 = 0.0606; + m3 = -0.00825; + m4 = 1.97; + wT = 2*ma.PI*f0/ma.SR; + polydel(a) = atan(sin(wT)/(a+cos(wT)))/wT; + Df0 = polydel(a1) - polydel(1.0/a1); +}; + +//-------------------------`(ef.)stereo_width`--------------------------- +// Stereo Width effect using the Blumlein Shuffler technique. +// `stereo_width` is a standard Faust function. +// +// #### Usage +// +// ``` +// _,_ : stereo_width(w) : _,_ +// ``` +// +// Where: +// +// * `w`: stereo width between 0 and 1 +// +// At `w=0`, the output signal is mono ((left+right)/2 in both channels). +// At `w=1`, there is no effect (original stereo image). +// Thus, w between 0 and 1 varies stereo width from 0 to "original". +// +// #### Reference +// +// * "Applications of Blumlein Shuffling to Stereo Microphone Techniques" +// Michael A. Gerzon, JAES vol. 42, no. 6, June 1994 +//------------------------------------------------------------ +stereo_width(w) = shuffle : *(mgain),*(sgain) : shuffle +with { + shuffle = _,_ <: +,-; // normally scaled by 1/sqrt(2) for orthonormality, + mgain = 1-w/2; // but we pick up the needed normalization here. + sgain = w/2; +}; + +//===========================================Meshes======================================= +//======================================================================================== + + +// TODO: the following should be in physmodels.lib when it will be operational +// [JOS: I think a new "Meshes" section would fit well after Modal Percussions.] +//----------------------------------`(ef.)mesh_square`------------------------------ +// Square Rectangular Digital Waveguide Mesh. +// +// #### Usage +// +// ``` +// bus(4*N) : mesh_square(N) : bus(4*N) +// ``` +// +// Where: +// +// * `N`: number of nodes along each edge - a power of two (1,2,4,8,...) +// +// #### Reference +// +// +// +// #### Signal Order In and Out +// +// The mesh is constructed recursively using 2x2 embeddings. Thus, +// the top level of `mesh_square(M)` is a block 2x2 mesh, where each +// block is a `mesh(M/2)`. Let these blocks be numbered 1,2,3,4 in the +// geometry NW,NE,SW,SE, i.e., as +// 1 2 +// 3 4 +// Each block has four vector inputs and four vector outputs, where the +// length of each vector is `M/2`. Label the input vectors as Ni,Ei,Wi,Si, +// i.e., as the inputs from the North, East South, and West, +// and similarly for the outputs. Then, for example, the upper +// left input block of M/2 signals is labeled 1Ni. Most of the +// connections are internal, such as 1Eo -> 2Wi. The `8*(M/2)` input +// signals are grouped in the order +// 1Ni 2Ni +// 3Si 4Si +// 1Wi 3Wi +// 2Ei 4Ei +// and the output signals are +// 1No 1Wo +// 2No 2Eo +// 3So 3Wo +// 4So 4Eo +// or +// +// In: 1No 1Wo 2No 2Eo 3So 3Wo 4So 4Eo +// +// Out: 1Ni 2Ni 3Si 4Si 1Wi 3Wi 2Ei 4Ei +// +// Thus, the inputs are grouped by direction N,S,W,E, while the +// outputs are grouped by block number 1,2,3,4, which can also be +// interpreted as directions NW, NE, SW, SE. A simple program +// illustrating these orderings is `process = mesh_square(2);`. +// +// #### Example +// +// Reflectively terminated mesh impulsed at one corner: +// +// ``` +// mesh_square_test(N,x) = mesh_square(N)~(busi(4*N,x)) // input to corner +// with { busi(N,x) = bus(N) : par(i,N,*(-1)) : par(i,N-1,_), +(x); }; +// process = 1-1' : mesh_square_test(4); // all modes excited forever +// ``` +// +// In this simple example, the mesh edges are connected as follows: +// +// 1No -> 1Ni, 1Wo -> 2Ni, 2No -> 3Si, 2Eo -> 4Si, +// +// 3So -> 1Wi, 3Wo -> 3Wi, 4So -> 2Ei, 4Eo -> 4Ei +// +// A routing matrix can be used to obtain other connection geometries. +//------------------------------------------------------------ +// four-port scattering junction: +mesh_square(1) = + si.bus(4) <: par(i,4,*(-1)), (si.bus(4) :> (*(.5)) <: si.bus(4)) :> si.bus(4); + +// rectangular NxN square waveguide mesh: +mesh_square(N) = si.bus(4*N) : (route_inputs(N/2) : par(i,4,mesh_square(N/2))) + ~(prune_feedback(N/2)) + : prune_outputs(N/2) : route_outputs(N/2) : si.bus(4*N) +with { + // select block i of N, block size = M: + s(i,N,M) = par(j, M*N, Sv(i, j)) + with { Sv(i,i) = si.bus(N); Sv(i,j) = si.block(N); }; + + // prune mesh outputs down to the signals which make it out: + prune_outputs(N) + = si.bus(16*N) : + si.block(N), si.bus(N), si.block(N), si.bus(N), + si.block(N), si.bus(N), si.bus(N), si.block(N), + si.bus(N), si.block(N), si.block(N), si.bus(N), + si.bus(N), si.block(N), si.bus(N), si.block(N) + : si.bus(8*N); + + // collect mesh outputs into standard order (N,W,E,S): + route_outputs(N) + = si.bus(8*N) + <: s(4,N,8),s(5,N,8), s(0,N,8),s(2,N,8), + s(3,N,8),s(7,N,8), s(1,N,8),s(6,N,8) + : si.bus(8*N); + + // collect signals used as feedback: + prune_feedback(N) = si.bus(16*N) : + si.bus(N), si.block(N), si.bus(N), si.block(N), + si.bus(N), si.block(N), si.block(N), si.bus(N), + si.block(N), si.bus(N), si.bus(N), si.block(N), + si.block(N), si.bus(N), si.block(N), si.bus(N) : + si.bus(8*N); + + // route mesh inputs (feedback, external inputs): + route_inputs(N) = si.bus(8*N), si.bus(8*N) + <:s(8,N,16),s(4,N,16), s(12,N,16),s(3,N,16), + s(9,N,16),s(6,N,16), s(1,N,16),s(14,N,16), + s(0,N,16),s(10,N,16), s(13,N,16),s(7,N,16), + s(2,N,16),s(11,N,16), s(5,N,16),s(15,N,16) + : si.bus(16*N); +}; + +//--------------------`(ef.)reverseEchoN(nChans,delay)`------------------- +// Reverse echo effect. +// +// #### Usage +// +// ``` +// _ : ef.reverseEchoN(N,delay) : si.bus(N) +// ``` +// +// Where: +// +// * `N`: Number of output channels desired (1 or more) +// * `delay`: echo delay (integer power of 2) +// +// #### Demo +// +// ``` +// _ : dm.reverseEchoN(N) : _,_ +// ``` +// +// #### Description +// +// The effect uses N instances of reverseDelayRamped at different phases. +// +//------------------------------------------------------------ +reverseEchoN(N,delMax) = _<: par(i,N,ef.reverseDelayRamped(delMax,i/N)); + +//-------------------`(ef.)reverseDelayRamped(delay,phase)`------------------ +// Reverse delay with amplitude ramp. +// +// #### Usage +// +// ``` +// _ : ef.reverseDelayRamped(delay,phase) : _ +// ``` +// +// Where: +// +// * `delay`: echo delay (integer power of 2) +// * `phase`: float between 0 and 1 giving ramp delay phase*delay +// +// #### Demo +// +// ``` +// _ : ef.reverseDelayRamped(32,0.6) : _,_ +// ``` +// +//------------------------------------------------------------ +reverseDelayRamped(delMax,phs) = rampGain * de.delay(delMax,del) with { + rampGain = 4 * (del/delMax) * (1 - del/delMax); // suppress click when delay-line wraps around + delOffset = int(floor(0.5 + delMax * max(0,min(0.999999,phs)))); // starting point in delay line + startPulse = (1-1') * delOffset; + del = int(startPulse : + ~ +(2)) & (delMax-1); +}; + +//-------------------`(ef.)uniformPanToStereo(nChans)`------------------ +// Pan nChans channels to the stereo field, spread uniformly left to right. +// +// #### Usage +// +// ``` +// si.bus(N) : ef.uniformPanToStereo(N) : _,_ +// ``` +// +// Where: +// +// * `N`: Number of input channels to pan down to stereo +// +// #### Demo +// +// ``` +// _,_,_ : ef.uniformPanToStereo(3) : _,_ +// ``` +// +//------------------------------------------------------------ +uniformPanToStereo(N) = si.bus(N) <: par(i,2*N,_) : + (par(i,N,*(i/(N-1))) :> _), + (par(i,N,*(1-i/(N-1))) :> _); + +// end jos section +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +//========================================Time Based====================================== +//======================================================================================== + +//----------`(ef.)echo`---------- +// A simple echo effect. +// `echo` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : echo(maxDuration,duration,feedback) : _ +// ``` +// +// Where: +// +// * `maxDuration`: the max echo duration in seconds +// * `duration`: the echo duration in seconds +// * `feedback`: the feedback coefficient +//---------------------------------------------------- +declare echo author "Romain Michon"; + +echo(maxDuration,duration,feedback) = +~de.delay(maxDel,del)*feedback +with{ + maxDel = ma.SR*maxDuration; + del = ma.SR*duration; +}; + +// TODO demo function for echo + +//=======================================Pitch Shifting=================================== +//======================================================================================== + +//--------------`(ef.)transpose`---------------- +// A simple pitch shifter based on 2 delay lines. +// `transpose` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : transpose(w, x, s) : _ +// ``` +// +// Where: +// +// * `w`: the window length (samples) +// * `x`: crossfade duration duration (samples) +// * `s`: shift (semitones) +//----------------------------------------- +transpose(w, x, s, sig) = de.fdelay(maxDelay,d,sig)*ma.fmin(d/x,1) + + de.fdelay(maxDelay,d+w,sig)*(1-ma.fmin(d/x,1)) +with { + maxDelay = 65536; + i = 1 - pow(2, s/12); + d = i : (+ : +(w) : fmod(_,w)) ~ _; +}; + +//////////////////////////////////Deprecated Functions//////////////////////////////////// +// This section implements functions that used to be in music.lib but that are now +// considered as "deprecated". +////////////////////////////////////////////////////////////////////////////////////////// + +echo1s = vgroup("echo 1000", +~(de.delay(65536, int(hslider("millisecond", 0, 0, 1000, 0.10)*ba.millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0))); +echo2s = vgroup("echo 2000", +~(de.delay(131072, int(hslider("millisecond", 0, 0, 2000, 0.25)*ba.millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0))); +echo5s = vgroup("echo 5000", +~(de.delay(262144, int(hslider("millisecond", 0, 0, 5000, 0.50)*ba.millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0))); +echo10s = vgroup("echo 10000", +~(de.delay(524288, int(hslider("millisecond", 0, 0, 10000, 1.00)*ba.millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0))); +echo21s = vgroup("echo 21000", +~(de.delay(1048576, int(hslider("millisecond", 0, 0, 21000, 1.00)*ba.millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0))); +echo43s = vgroup("echo 43000", +~(de.delay(2097152, int(hslider("millisecond", 0, 0, 43000, 1.00)*ba.millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0))); diff --git a/dist/examples/LIBRARIES/noises.lib b/dist/examples/LIBRARIES/noises.lib new file mode 100644 index 00000000..f732eaef --- /dev/null +++ b/dist/examples/LIBRARIES/noises.lib @@ -0,0 +1,487 @@ +//##################################### noises.lib ######################################## +// Faust Noise Generator Library. Its official prefix is `no`. +// +// #### References +// * +//######################################################################################## + +ma = library("maths.lib"); +ba = library("basics.lib"); +fi = library("filters.lib"); +os = library("oscillators.lib"); +no = library("noises.lib"); // for compatible copy/paste out of this file + +declare name "Faust Noise Generator Library"; +declare version "0.4"; + +//=============================Functions Reference======================================== +//======================================================================================== + +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +noise_env(seed) = environment { + + RANDMAX = 2147483647.0; // = 2^31-1 = MAX_SIGNED_INT in 32 bits + + noise = random / RANDMAX + with { + random = +(seed) ~ *(1103515245); // "linear congruential" + }; + + multirandom(N) = randomize(N) ~_ + with { + randomize(1) = +(seed) : *(1103515245); + randomize(N) = randomize(1) <: randomize(N-1),_; + }; + + multinoise(N) = multirandom(N) : par(i, N, /(RANDMAX)) : par(i, N, float); + + noises(N,i) = multinoise(N) : ba.selector(i,N); + +}; + + +//-------`(no.)noise`---------- +// White noise generator (outputs random number between -1 and 1). +// `noise` is a standard Faust function. +// +// #### Usage +// +// ``` +// noise : _ +// ``` +//------------------------ +noise = noise_env(12345).noise; + + +//---------------------`(no.)multirandom`-------------------------- +// Generates multiple decorrelated random numbers in parallel. +// +// #### Usage +// ``` +// multirandom(N) : si.bus(N) +// ``` +// +// Where: +// +// * `N`: the number of decorrelated random numbers in parallel, a constant numerical expression +//------------------------------------------------------------- +multirandom(N) = noise_env(12345).multirandom(N); + + +//-----------------------`(no.)multinoise`------------------------ +// Generates multiple decorrelated noises in parallel. +// +// #### Usage +// +// ``` +// multinoise(N) : si.bus(N) +// ``` +// +// Where: +// +// * `N`: the number of decorrelated random numbers in parallel, a constant numerical expression +//------------------------------------------------------------ +multinoise(N) = noise_env(12345).multinoise(N); + + +//-----------------------`(no.)noises`------------------------ +// A convenient wrapper around multinoise. +// +// #### Usage +// +// ``` +// noises(N,i) : _ +// ``` +// +// Where: +// +// * `N`: the number of decorrelated random numbers in parallel, a constant numerical expression +// * `i`: the selected random number (i in [0..N[) +//---------------------------------------------------------- +noises(N,i) = noise_env(12345).noises(N,i); + + +//-----------------------`(no.)randomseed`------------------------ +// A random seed based on the foreign function `arc4random` +// (see man arc4random). Used in `rnoise`, `rmultirandom`, etc. to +// avoid having the same pseudo random sequence at each run. +// +// WARNING: using the foreign function `arc4random`, so only available in C/C++ and LLVM backends. +// +// #### Usage +// +// ``` +// randomseed : _ +// ``` +// +//------------------------------------------------------------ +randomseed = ffunction(int arc4random(), , ""), 12345 : select2(1'); + + +//-----------------------`(no.)rnoise`----------------------- +// A randomized white noise generator (outputs random number between -1 and 1). +// +// WARNING: using the foreign function `arc4random`, so only available in C/C++ and LLVM backends. +// +// #### Usage +// +// ``` +// rnoise : _ +// ``` +//------------------------ +rnoise = noise_env(randomseed).noise; + + +//---------------------`(no.)rmultirandom`-------------------------- +// Generates multiple decorrelated random numbers in parallel. +// +// WARNING: using the foreign function `arc4random`, so only available in C/C++ and LLVM backends. +// +// #### Usage +// ``` +// rmultirandom(N) : _ +// ``` +// +// Where: +// +// * `N`: the number of decorrelated random numbers in parallel, a constant numerical expression +//------------------------------------------------------------- +rmultirandom(N) = noise_env(randomseed).multirandom(N); + + +//-----------------------`(no.)rmultinoise`------------------------ +// Generates multiple decorrelated noises in parallel. +// +// WARNING: using the foreign function `arc4random`, so only available in C/C++ and LLVM backends. +// +// #### Usage +// +// ``` +// rmultinoise(N) : _ +// ``` +// +// Where: +// +// * `N`: the number of decorrelated random numbers in parallel, a constant numerical expression +//------------------------------------------------------------ +rmultinoise(N) = noise_env(randomseed).multinoise(N); + + +//-----------------------`(no.)rnoises`------------------------ +// A convenient wrapper around rmultinoise. +// +// WARNING: using the foreign function `arc4random`, so only available in C/C++ and LLVM backends. +// +// #### Usage +// +// ``` +// rnoises(N,i) : _ +// ``` +// +// Where: +// +// * `N`: the number of decorrelated random numbers in parallel +// * `i`: the selected random number (i in [0..N[) +//---------------------------------------------------------- +rnoises(N,i) = noise_env(randomseed).noises(N,i); + + +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2017 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +All MarkDown comments in this section are Copyright 2016-2017 by Romain +Michon and/or Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees) + +************************************************************************/ + +//---------------------------`(no.)pink_noise`-------------------------- +// Pink noise (1/f noise) generator (third-order approximation covering the audio band well). +// `pink_noise` is a standard Faust function. +// +// #### Usage +// ``` +// pink_noise : _ +// ``` +// +// #### Reference +// +// +// #### Alternatives +// Higher-order approximations covering any frequency band can be obtained using +// ``` +// no.noise : fi.spectral_tilt(order,lowerBandLimit,Bandwidth,p) +// ``` +// where `p=-0.5` means filter rolloff `f^(-1/2)` which gives 1/f rolloff in the +// power spectral density, and can be changed to other real values. +// +// #### Example +// // pink_noise_compare.dsp - compare three pinking filters +// ``` +// process = pink_noises with { +// f0 = 35; // Lower bandlimit in Hz +// bw3 = 0.7 * ma.SR/2.0 - f0; // Bandwidth in Hz, 3rd order case +// bw9 = 0.8 * ma.SR/2.0 - f0; // Bandwidth in Hz, 9th order case +// pink_tilt_3 = fi.spectral_tilt(3,f0,bw3,-0.5); +// pink_tilt_9 = fi.spectral_tilt(9,f0,bw9,-0.5); +// pink_noises = 1-1' <: +// no.pink_filter, // original designed by invfreqz in Octave +// pink_tilt_3, // newer method using the same filter order +// pink_tilt_9; // newer method using a higher filter order +// }; +// ``` +// +// #### Output of Example +// ``` +// faust2octave pink_noise_compare.dsp +// Octave:1> semilogx(20*log10(abs(fft(faustout,8192))(1:4096,:))); +// ... +// ``` +// pink_noise_demo figure +//------------------------------------------------------------ +pink_filter = fi.iir((0.049922035, -0.095993537, 0.050612699, -0.004408786), + (-2.494956002, 2.017265875, -0.522189400)); + +pink_noise = noise : pink_filter; + +pink_noise_m = pink_noise * 12.5; // Equalizes loudness to that of no.noise (thanks Mykle Hansen) - beware of clipping + + +//-------------------------`(no.)pink_noise_vm`------------------- +// Multi pink noise generator. +// +// #### Usage +// +// ``` +// pink_noise_vm(N) : _ +// ``` +// +// Where: +// +// * `N`: number of latched white-noise processes to sum, +// not to exceed sizeof(int) in C++ (typically 32). +// +// #### References +// +// * +// * +//------------------------------------------------------------ +pink_noise_vm(N) = noise <: _,par(i,N,ba.latch(clock(i))) :> _ +with { + clock(i) = (ba.time>>i)&1; // i'th latch clock signal +}; + + +//--------------------`(no.)lfnoise`, `(no.)lfnoise0` and `(no.)lfnoiseN`----------------- +// Low-frequency noise generators (Butterworth-filtered downsampled white noise). +// +// #### Usage +// +// ``` +// lfnoise0(rate) : _ // new random number every int(SR/rate) samples or so +// lfnoiseN(N,rate) : _ // same as "lfnoise0(rate) : lowpass(N,rate)" [see filters.lib] +// lfnoise(rate) : _ // same as "lfnoise0(rate) : seq(i,5,lowpass(N,rate))" (no overshoot) +// ``` +// +// #### Example +// +// (view waveforms in faust2octave): +// +// ``` +// rate = SR/100.0; // new random value every 100 samples (SR from music.lib) +// process = lfnoise0(rate), // sampled/held noise (piecewise constant) +// lfnoiseN(3,rate), // lfnoise0 smoothed by 3rd order Butterworth LPF +// lfnoise(rate); // lfnoise0 smoothed with no overshoot +// ``` +//------------------------------------------------------------ +lfnoise0(freq) = noise : ba.latch(os.oscrs(freq)); +lfnoiseN(N,freq) = lfnoise0(freq) : fi.lowpass(N,freq); // Nth-order Butterworth lowpass +lfnoise(freq) = lfnoise0(freq) : seq(i,5,fi.lowpass(1,freq)); // non-overshooting lowpass + + +//-------------------------`(no.)sparse_noise`------------------- +// Sparse noise generator. +// +// #### Usage +// +// ``` +// sparse_noise(f0) : _ +// ``` +// +// Where: +// +// * ` f0`: average frequency of noise impulses per second +// +// Random impulses in the amplitude range -1 to 1 are generated +// at an average rate of f0 impulses per second. +// +// #### Reference +// +// * See velvet_noise +//------------------------------------------------------------ +sparse_noise(f0) = sn +with { + saw = os.lf_sawpos(f0); + sawdiff = saw - saw'; + e = float(no.noise); // float() keeps 4.656613e-10f scaling here instead of later + eHeld = e : ba.latch(sawdiff); + eHeldPos = 0.5 + 0.5 * eHeld; + crossed = (saw >= eHeldPos) * (saw' < eHeldPos); + sn = e' * float(crossed); +}; + + +//-------------------------`(no.)velvet_noise_vm`------------------- +// Velvet noise generator. +// +// #### Usage +// +// ``` +// velvet_noise(amp, f0) : _ +// ``` +// +// Where: +// +// * `amp`: amplitude of noise impulses (positive and negative) +// * ` f0`: average frequency of noise impulses per second +// +// #### Reference +// +// * Matti Karjalainen and Hanna Jarvelainen, +// "Reverberation Modeling Using Velvet Noise", +// in Proc. 30th Int. Conf. Intelligent Audio Environments (AES07), +// March 2007. +// +//------------------------------------------------------------ +velvet_noise(amp, f0) = vn +with { + sn = no.sparse_noise(f0); + vn = amp * ma.signum(sn); +}; + + +//----------------------------`(no.)gnoise`------------------------ +// Approximate zero-mean, unit-variance Gaussian white noise generator. +// +// #### Usage +// +// ``` +// gnoise(N) : _ +// ``` +// +// Where: +// +// * `N`: number of uniform random numbers added to approximate Gaussian white noise +// +// #### Reference +// +// * See Central Limit Theorem +// +//------------------------------------------------------------ +gnoise(N) = uvgwn +with { + uwn = no.multinoise(N); // uniform white noise in [-1,1] on N channels + gwn = uwn :> _; // sum of uniform approaches Gaussian by centeral limit thm + sigma = sqrt(N/3.0); // rms of each uwn channel + uvgwn = gwn / sigma; // approaches zero-mean, unit-variance Gaussian white noise, for large N +}; + +gnoisem(N) = gnoise(N) * 0.625; // Equalizes loudness to that of no.noise (thanks Mykle Hansen) + + +/*** END jos section ***/ + +//######################################################################################## +/************************************************************************ +FAUST library file, further contributions section + +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ + +//-----------------`(no.)colored_noise`-------------------- +// Generates a colored noise signal with an arbitrary spectral +// roll-off factor (alpha) over the entire audible frequency range +// (20-20000 Hz). The output is normalized so that an equal RMS +// level is maintained for different values of alpha. +// +// #### Usage +// +// ``` +// colored_noise(N,alpha) : _ +// ``` +// +// Where: +// +// * `N`: desired integer filter order (constant numerical expression) +// * `alpha`: slope of roll-off, between -1 and 1. -1 corresponds to +// brown/red noise, -1/2 pink noise, 0 white noise, 1/2 blue noise, +// and 1 violet/azure noise. +// +// #### Examples +// See `dm.colored_noise_demo`. +// +//------------------------------------------------- +declare colored_noise author "Constantinos Odysseas Economou"; +declare colored_noise copyright "Copyright (C) 2022 Constantinos Odysseas Economou "; +declare colored_noise license "MIT-style STK-4.3 license"; + +colored_noise(N,alpha) = no.noise : fi.dcblocker : fi.spectral_tilt(N,fmin,bw,alpha) : *(uniNorm(alpha * 2)) : max(-1.0) : min(1.0) +with { + fmin = 20.0; + fmax = 20000.0; + bw = fmax - fmin; + + uniNorm(alpha) = (a*exp(-alpha*b))+(c*exp(-alpha*d)) : pow(-1) + with{ + a = ba.if(ma.signum(alpha) > 0, 1, 0.8016); + b = ba.if(ma.signum(alpha) > 0, -4.28, -2.633); + c = ba.if(ma.signum(alpha) > 0, 0, 0.1984); + d = ba.if(ma.signum(alpha) > 0, 0, -0.7196); + }; +}; diff --git a/dist/examples/LIBRARIES/oscillators.lib b/dist/examples/LIBRARIES/oscillators.lib new file mode 100644 index 00000000..84693aa0 --- /dev/null +++ b/dist/examples/LIBRARIES/oscillators.lib @@ -0,0 +1,1778 @@ +//############################## oscillators.lib ###################################### +// This library contains a collection of sound generators. Its official prefix is `os`. +// +// The oscillators library is organized into 9 sections: +// +// * [Wave-Table-Based Oscillators](#wave-table-based-oscillators) +// * [Low Frequency Oscillators](#low-frequency-oscillators) +// * [Low Frequency Sawtooths](#low-frequency-sawtooths) +// * [Alias-Suppressed Sawtooth](#alias-suppressed-sawtooth) +// * [Alias-Suppressed Pulse, Square, and Impulse Trains](#alias-suppressed-pulse-square-and-impulse-trains) +// * [Filter-Based Oscillators](#filter-based-oscillators) +// * [Waveguide-Resonator-Based Oscillators](#waveguide-resonator-based-oscillators) +// * [Casio CZ Oscillators](#casio-cz-oscillators) +// * [PolyBLEP-Based Oscillators](#polyblep-based-oscillators) +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +ba = library("basics.lib"); +fi = library("filters.lib"); +si = library("signals.lib"); + +declare name "Faust Oscillator Library"; +declare version "0.3"; + +// This library contains platform specific constants +pl = library("platform.lib"); + +//=========================Wave-Table-Based Oscillators=================================== +//======================================================================================== + + +//-----------------------`(os.)sinwaveform`------------------------ +// Sine waveform ready to use with a `rdtable`. +// +// #### Usage +// +// ``` +// sinwaveform(tablesize) : _ +// ``` +// +// Where: +// +// * `tablesize`: the table size +//------------------------------------------------------------ +sinwaveform(tablesize) = + sin(float(ba.period(tablesize)) * (2.0 * ma.PI) / float(tablesize)); + + +//-----------------------`(os.)coswaveform`------------------------ +// Cosine waveform ready to use with a `rdtable`. +// +// #### Usage +// +// ``` +// coswaveform(tablesize) : _ +// ``` +// +// Where: +// +// * `tablesize`: the table size +//------------------------------------------------------------ +coswaveform(tablesize) = + cos(float(ba.period(tablesize)) * (2.0 * ma.PI) / float(tablesize)); + + +// Generic phasor with `reset` and `phase` parameters to be specialised in concrete use-cases. +// The `reset` must be 1 on first sample for the `phase` to be properly initialized. +phasor_imp(freq, reset, phase) = (select2(reset, +(freq/ma.SR), phase) : ma.decimal) ~ _; + +// Version to be used with tables +phasor_table(tablesize, freq, reset, phase) = phasor_imp(freq, reset, phase) : *(float(tablesize)); + +//-----------------------`(os.)phasor`------------------------ +// A simple phasor to be used with a `rdtable`. +// `phasor` is a standard Faust function. +// +// #### Usage +// +// ``` +// phasor(tablesize,freq) : _ +// ``` +// +// Where: +// +// * `tablesize`: the table size +// * `freq`: the frequency in Hz +//------------------------------------------------------------ +phasor(tablesize, freq) = phasor_table(tablesize, freq, 0, 0); + + +//-----------------------`(os.)hs_phasor`------------------------ +// Hardsyncing phasor to be used with a `rdtable`. +// +// #### Usage +// +// ``` +// hs_phasor(tablesize,freq,reset) : _ +// ``` +// +// Where: +// +// * `tablesize`: the table size +// * `freq`: the frequency in Hz +// * `reset`: a reset signal, reset phase to 0 when equal to 1 +//--------------------------------------------------------- +declare hs_phasor author "Mike Olsen, revised by Stéphane Letz"; + +hs_phasor(tablesize, freq, reset) = phasor_table(tablesize, freq, reset, 0); + + +//-----------------------`(os.)hsp_phasor`------------------------ +// Hardsyncing phasor with selectable phase to be used with a `rdtable`. +// +// #### Usage +// +// ``` +// hsp_phasor(tablesize,freq,reset,phase) +// ``` +// +// Where: +// +// * `tablesize`: the table size +// * `freq`: the frequency in Hz +// * `reset`: reset the oscillator to phase when equal to 1 +// * `phase`: phase between 0 and 1 +//--------------------------------------------------------- +declare hsp_phasor author "Christophe Lebreton, revised by Stéphane Letz"; + +hsp_phasor(tablesize, freq, reset, phase) = phasor_table(tablesize, freq, reset, phase); + + +//-----------------------`(os.)oscsin`------------------------ +// Sine wave oscillator. +// `oscsin` is a standard Faust function. +// +// #### Usage +// +// ``` +// oscsin(freq) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency in Hz +//------------------------------------------------------------ +oscsin(freq) = rdtable(tablesize, sinwaveform(tablesize), int(phasor(tablesize,freq))) +with { + tablesize = pl.tablesize; +}; + + +//-----------------------`(os.)hs_oscsin`------------------------ +// Sin lookup table with hardsyncing phase. +// +// #### Usage +// +// ``` +// hs_oscsin(freq,reset) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency in Hz +// * `reset`: reset the oscillator to 0 when equal to 1 +//--------------------------------------------------------- +declare hs_oscsin author "Mike Olsen"; + +hs_oscsin(freq,reset) = rdtable(tablesize, sinwaveform(tablesize), int(hs_phasor(tablesize,freq,reset))) +with { + tablesize = pl.tablesize; +}; + + +//-----------------------`(os.)osccos`------------------------ +// Cosine wave oscillator. +// +// #### Usage +// +// ``` +// osccos(freq) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency in Hz +//------------------------------------------------------------ +osccos(freq) = rdtable(tablesize, coswaveform(tablesize), int(phasor(tablesize,freq))) +with { + tablesize = pl.tablesize; +}; + + +//-----------------------`(os.)hs_osccos`------------------------ +// Cos lookup table with hardsyncing phase. +// +// #### Usage +// +// ``` +// hs_osccos(freq,reset) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency in Hz +// * `reset`: reset the oscillator to 0 when equal to 1 +//--------------------------------------------------------- +declare hs_osccos author "Stéphane Letz"; + +hs_osccos(freq,reset) = rdtable(tablesize, coswaveform(tablesize), int(hs_phasor(tablesize,freq,reset))) +with { + tablesize = pl.tablesize; +}; + + +//-----------------------`(os.)oscp`------------------------ +// A sine wave generator with controllable phase. +// +// #### Usage +// +// ``` +// oscp(freq,phase) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency in Hz +// * `phase`: the phase in radian +//------------------------------------------------------------ +oscp(freq,phase) = oscsin(freq) * cos(phase) + osccos(freq) * sin(phase); + + +//-----------------------`(os.)osci`------------------------ +// Interpolated phase sine wave oscillator. +// +// #### Usage +// +// ``` +// osci(freq) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency in Hz +//------------------------------------------------------------ +osci(freq) = s1 + d * (s2 - s1) +with { + tablesize = pl.tablesize; + i = int(phasor(tablesize,freq)); + d = ma.decimal(phasor(tablesize,freq)); + s1 = rdtable(tablesize+1,sinwaveform(tablesize),i); + s2 = rdtable(tablesize+1,sinwaveform(tablesize),i+1); +}; + + +//-----------------------`(os.)osc`------------------------ +// Default sine wave oscillator (same as [oscsin](#oscsin)). +// `osc` is a standard Faust function. +// +// #### Usage +// +// ``` +// osc(freq) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency in Hz +//------------------------------------------------------------ +osc = oscsin; + + +// end GRAME section +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2022 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +The MarkDown comments in this section are Copyright 2016-2017 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees) + +************************************************************************/ + +//===============================Low Frequency Oscillators=============================== +// Low Frequency Oscillators (LFOs) have prefix `lf_` +// (no aliasing suppression, since it is inaudible at LF). +// Use `sawN` and its derivatives for audio oscillators with suppressed aliasing. +//================================================================== + +//--------`(os.)lf_imptrain`---------- +// Unit-amplitude low-frequency impulse train. +// `lf_imptrain` is a standard Faust function. + +// #### Usage +// +// ``` +// lf_imptrain(freq) : _ +// ``` + +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +lf_imptrain(freq) = lf_sawpos(freq)<:-(mem)<0; // definition below + + +//--------`(os.)lf_pulsetrainpos`---------- +// Unit-amplitude nonnegative LF pulse train, duty cycle between 0 and 1. +// +// +// #### Usage +// +// ``` +// lf_pulsetrainpos(freq, duty) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// * `duty`: duty cycle between 0 and 1 +//------------------------------------------------------------ +lf_pulsetrainpos(freq,duty) = float(lf_sawpos(freq) <= duty); + +//pulsetrainpos = lf_pulsetrainpos; // for backward compatibility + + +//--------`(os.)lf_pulsetrain`---------- +// Unit-amplitude zero-mean LF pulse train, duty cycle between 0 and 1. +// +// #### Usage +// +// ``` +// lf_pulsetrain(freq,duty) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// * `duty`: duty cycle between 0 and 1 +//------------------------------------------------------------ +lf_pulsetrain(freq,duty) = 2.0*lf_pulsetrainpos(freq,duty) - 1.0; + + +//--------`(os.)lf_squarewavepos`---------- +// Positive LF square wave in [0,1] +// +// #### Usage +// +// ``` +// lf_squarewavepos(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +lf_squarewavepos(freq) = lf_pulsetrainpos(freq,0.5); +// squarewavepos = lf_squarewavepos; // for backward compatibility + + +//--------`(os.)lf_squarewave`---------- +// Zero-mean unit-amplitude LF square wave. +// `lf_squarewave` is a standard Faust function. +// +// #### Usage +// +// ``` +// lf_squarewave(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +lf_squarewave(freq) = 2.0*lf_squarewavepos(freq) - 1.0; +// squarewave = lf_squarewave; // for backward compatibility + + +//--------`(os.)lf_trianglepos`---------- +// Positive unit-amplitude LF positive triangle wave. +// +// #### Usage +// +// ``` +// lf_trianglepos(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +lf_trianglepos(freq) = 1.0-abs(saw1(freq)); // saw1 defined below + + +//----------`(os.)lf_triangle`---------- +// Positive unit-amplitude LF triangle wave. +// `lf_triangle` is a standard Faust function. +// +// #### Usage +// +// ``` +// lf_triangle(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +declare lf_triangle author "Bart Brouns"; +declare lf_triangle licence "STK-4.3"; + +lf_triangle(freq) = 2.0*lf_trianglepos(freq) - 1.0; + + +//================== Low Frequency Sawtooths ==================== +// Sawtooth waveform oscillators for virtual analog synthesis et al. +// The 'simple' versions (`lf_rawsaw`, `lf_sawpos` and `saw1`), are mere samplings of +// the ideal continuous-time ("analog") waveforms. While simple, the +// aliasing due to sampling is quite audible. The differentiated +// polynomial waveform family (`saw2`, `sawN`, and derived functions) +// do some extra processing to suppress aliasing (not audible for +// very low fundamental frequencies). According to Lehtonen et al. +// (JASA 2012), the aliasing of `saw2` should be inaudible at fundamental +// frequencies below 2 kHz or so, for a 44.1 kHz sampling rate and 60 dB SPL +// presentation level; fundamentals 415 and below required no aliasing +// suppression (i.e., `saw1` is ok). +//===================================================================== + +//-----------------`(os.)lf_rawsaw`-------------------- +// Simple sawtooth waveform oscillator between 0 and period in samples. +// +// #### Usage +// +// ``` +// lf_rawsaw(periodsamps) : _ +// ``` +// +// Where: +// +// * `periodsamps`: number of periods per samples +//--------------------------------------------------------- +lf_rawsaw(periodsamps) = (_,periodsamps : fmod) ~ +(1.0); + + +//-----------------`(os.)lf_sawpos`-------------------- +// Simple sawtooth waveform oscillator between 0 and 1. +// +// #### Usage +// +// ``` +// lf_sawpos(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +//--------------------------------------------------------- +declare lf_sawpos author "Bart Brouns, revised by Stéphane Letz"; +declare lf_sawpos licence "STK-4.3"; + +lf_sawpos(freq) = phasor_imp(freq, 0, 0); + + +//-----------------`(os.)lf_sawpos_phase`-------------------- +// Simple sawtooth waveform oscillator between 0 and 1 +// with phase control. +// +// #### Usage +// +// ``` +// lf_sawpos_phase(freq, phase) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// * `phase`: phase between 0 and 1 +//--------------------------------------------------------- +declare lf_sawpos_phase author "Bart Brouns, revised by Stéphane Letz"; +declare lf_sawpos_phase licence "STK-4.3"; + +// Using an initial '1' to reset to `phase` +lf_sawpos_phase(freq,phase) = phasor_imp(freq, (1-1'), phase); + + +//-----------------`(os.)lf_sawpos_reset`-------------------- +// Simple sawtooth waveform oscillator between 0 and 1 +// with reset. +// +// #### Usage +// +// ``` +// lf_sawpos_reset(freq,reset) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// * `reset`: reset the oscillator to 0 when equal to 1 +// +//--------------------------------------------------------- +declare lf_sawpos_reset author "Bart Brouns, revised by Stéphane Letz"; +declare lf_sawpos_reset licence "STK-4.3"; + +lf_sawpos_reset(freq,reset) = phasor_imp(freq, reset, 0); + + +//-----------------`(os.)lf_sawpos_phase_reset`-------------------- +// Simple sawtooth waveform oscillator between 0 and 1 +// with phase control and reset. +// +// #### Usage +// +// ``` +// lf_sawpos_phase_reset(freq,phase,reset) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// * `phase`: phase between 0 and 1 +// * `reset`: reset the oscillator to phase when equal to 1 +// +//--------------------------------------------------------- +declare lf_sawpos_phase_reset author "Bart Brouns, revised by Stéphane Letz"; +declare lf_sawpos_phase_reset licence "STK-4.3"; + +lf_sawpos_phase_reset(freq,phase,reset) = phasor_imp(freq, reset, phase); + + +//-----------------`(os.)lf_saw`-------------------- +// Simple sawtooth waveform oscillator between -1 and 1. +// `lf_saw` is a standard Faust function. +// +// #### Usage +// +// ``` +// lf_saw(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//--------------------------------------------------------- +declare saw1 author "Bart Brouns"; +declare saw1 licence "STK-4.3"; + +saw1(freq) = 2.0 * lf_sawpos(freq) - 1.0; +lf_saw(freq) = saw1(freq); + +//================== Alias-Suppressed Sawtooth ==================== +//-----------------`(os.)sawN`-------------------- +// Alias-Suppressed Sawtooth Audio-Frequency Oscillator using Nth-order polynomial transitions +// to reduce aliasing. +// +// `sawN(N,freq)`, `sawNp(N,freq,phase)`, `saw2dpw(freq)`, `saw2(freq)`, `saw3(freq)`, +// `saw4(freq)`, `sawtooth(freq)`, `saw2f2(freq)`, `saw2f4(freq)` +// +// #### Usage +// +// ``` +// sawN(N,freq) : _ // Nth-order aliasing-suppressed sawtooth using DPW method (see below) +// sawNp(N,freq,phase) : _ // sawN with phase offset feature +// saw2dpw(freq) : _ // saw2 using DPW +// saw2ptr(freq) : _ // saw2 using the faster, stateless PTR method +// saw2(freq) : _ // DPW method, but subject to change if a better method emerges +// saw3(freq) : _ // sawN(3) +// saw4(freq) : _ // sawN(4) +// sawtooth(freq) : _ // saw2 +// saw2f2(freq) : _ // saw2dpw with 2nd-order droop-correction filtering +// saw2f4(freq) : _ // saw2dpw with 4th-order droop-correction filtering +// ``` +// +// Where: +// +// * `N`: polynomial order, a constant numerical expression between 1 and 4 +// * `freq`: frequency in Hz +// * `phase`: phase between 0 and 1 +// +// #### Method +// Differentiated Polynomial Wave (DPW). +// +// ##### Reference +// "Alias-Suppressed Oscillators based on Differentiated Polynomial Waveforms", +// Vesa Valimaki, Juhan Nam, Julius Smith, and Jonathan Abel, +// IEEE Tr. Audio, Speech, and Language Processing (IEEE-ASLP), +// Vol. 18, no. 5, pp 786-798, May 2010. +// 10.1109/TASL.2009.2026507. +// +// #### Notes +// The polynomial order `N` is limited to 4 because noise has been +// observed at very low `freq` values. (LFO sawtooths should of course +// be generated using `lf_sawpos` instead.) +//----------------------------------------------------------------- +declare sawN author "Julius O. Smith III"; +declare sawN license "STK-4.3"; +// --- sawN for N = 1 to 4 --- +// Orders 5 and 6 have noise at low fundamentals: MAX_SAW_ORDER = 6; MAX_SAW_ORDER_NEXTPOW2 = 8; +MAX_SAW_ORDER = 4; +MAX_SAW_ORDER_NEXTPOW2 = 8; // par cannot handle the case of 0 elements +sawN(N,freq) = saw1l : poly(Nc) : D(Nc-1) : gate(Nc-1) +with { + Nc = max(1,min(N,MAX_SAW_ORDER)); + clippedFreq = max(20.0,abs(freq)); // use lf_sawpos(freq) for LFOs (freq < 20 Hz) + saw1l = 2*lf_sawpos(clippedFreq) - 1; // zero-mean, amplitude +/- 1 + poly(1,x) = x; + poly(2,x) = x*x; + poly(3,x) = x*x*x - x; + poly(4,x) = x*x*(x*x - 2.0); + poly(5,x) = x*(7.0/3 + x*x*(-10.0/3.0 + x*x)); + poly(6,x) = x*x*(7.0 + x*x*(-5.0 + x*x)); + p0n = float(ma.SR)/clippedFreq; // period in samples + diff1(x) = (x - x')/(2.0/p0n); + diff(N) = seq(n,N,diff1); // N diff1s in series + factorial(0) = 1; + factorial(i) = i * factorial(i-1); + D(0) = _; + D(i) = diff(i)/factorial(i+1); + gate(N) = *(1@(N)); // delayed step for blanking startup glitch +}; + +//------------------`(os.)sawNp`-------------------------------- +// Same as `(os.)sawN` but with a controllable waveform phase. +// +// #### Usage +// +// ``` +// sawNp(N,freq,phase) : _ +// ``` +// +// where +// +// * `N`: waveform interpolation polynomial order 1 to 4 (constant integer expression) +// * `freq`: frequency in Hz +// * `phase`: waveform phase as a fraction of one period (rounded to nearest sample) +// +// #### Implementation Notes +// +// The phase offset is implemented by delaying `sawN(N,freq)` by +// `round(phase*ma.SR/freq)` samples, for up to 8191 samples. +// The minimum sawtooth frequency that can be delayed a whole period +// is therefore `ma.SR/8191`, which is well below audibility for normal +// audio sampling rates. +// +//----------------------------------------------------------------- +declare sawNp author "Julius O. Smith III"; +declare sawNp license "STK-4.3"; +// --- sawNp for N = 1 to 4 --- +// Phase offset = delay (max 8191 samples is more than one period of audio): +sawNp(N,freq,phase) = sawN(N,freq) : @(max(0,min(8191,int(0.5+phase*ma.SR/freq)))); + +//------------------`(os.)saw2, (os.)saw3, (os.)saw4`-------------- +// Alias-Suppressed Sawtooth Audio-Frequency Oscillators of order 2, 3, 4. +// +// #### Usage +// +// ``` +// saw2(freq) : _ +// saw3(freq) : _ +// saw4(freq) : _ +// ``` +// +// where +// +// * `freq`: frequency in Hz +// +// ##### References +// See `sawN` above. +// +// #### Implementation Notes +// +// Presently, only `saw2` uses the PTR method, while `saw3` and `saw4` use DPW. +// This is because PTR has been implemented and tested for the 2nd-order case only. +// +//------------------------------------------------------------------ +saw2 = saw2ptr; // "faustlibraries choice" +saw3 = sawN(3); // only choice available right now +saw4 = sawN(4); // only choice available right now + +//---------------------------`(os.)saw2ptr`--------------------------- +// Alias-Suppressed Sawtooth Audio-Frequency Oscillator +// using Polynomial Transition Regions (PTR) for order 2. +// +// #### Usage +// +// ``` +// saw2ptr(freq) : _ +// ``` +// +// where +// +// * `freq`: frequency in Hz +// +// ##### Implementation +// +// Polynomial Transition Regions (PTR) method for aliasing suppression. +// +// ##### References +// +// * Kleimola, J.; Valimaki, V., "Reducing Aliasing from Synthetic Audio +// Signals Using Polynomial Transition Regions," in Signal Processing +// Letters, IEEE , vol.19, no.2, pp.67-70, Feb. 2012 +// * +// * +// +// ##### Notes +// +// Method PTR may be preferred because it requires less +// computation and is stateless which means that the frequency `freq` +// can be modulated arbitrarily fast over time without filtering +// artifacts. For this reason, `saw2` is presently defined as `saw2ptr`. +// +//-------------------------------------------------------- +declare saw2ptr author "Julius O. Smith III"; +declare saw2ptr license "STK-4.3"; +// specialized reimplementation: +saw2ptr(freq) = y with { // newer PTR version (stateless - freq can vary at any speed) + p0 = float(ma.SR)/float(max(ma.EPSILON,abs(freq))); // period in samples + t0 = 1.0/p0; // phase increment + p = ((_<:(-(1)<:_,_),_) <: selector1,selector2) ~(+(t0)):!,_; + selector1 = select2(<(0)); // for feedback + selector2 = select2(<(0), (_<:_,(*(1-p0):+(1)):+), _); // for output + y = 2*p-1; +}; + +//----------------------`(os.)saw2dpw`--------------------- +// Alias-Suppressed Sawtooth Audio-Frequency Oscillator +// using the Differentiated Polynomial Waveform (DWP) method. +// +// #### Usage +// +// ``` +// saw2dpw(freq) : _ +// ``` +// +// where +// +// * `freq`: frequency in Hz +// +// This is the original Faust `saw2` function using the DPW method. +// Since `saw2` is now defined as `saw2ptr`, the DPW version +// is now available as `saw2dwp`. +//-------------------------------------------------------- +declare saw2dpw author "Julius O. Smith III"; +declare saw2dpw license "STK-4.3"; +saw2dpw(freq) = saw1(freq) <: * <: -(mem) : *(0.25'*ma.SR/freq); + +//------------------`(os.)sawtooth`-------------------------------- +// Alias-suppressed aliasing-suppressed sawtooth oscillator, presently defined as `saw2`. +// `sawtooth` is a standard Faust function. +// +// #### Usage +// +// ``` +// sawtooth(freq) : _ +// ``` +// +// with +// +// * `freq`: frequency in Hz +//-------------------------------------------------------- +sawtooth = saw2; // default choice for sawtooth signal - see also sawN + +//------------------`(os.)saw2f2, (os.)saw2f4`-------------------------------- +// Alias-Suppressed Sawtooth Audio-Frequency Oscillator with Order 2 or 4 Droop Correction Filtering. +// +// #### Usage +// +// ``` +// saw2f2(freq) : _ +// saw2f4(freq) : _ +// ``` +// +// with +// +// * `freq`: frequency in Hz +// +// In return for aliasing suppression, there is some attenuation near half the sampling rate. +// This can be considered as beneficial, or it can be compensated with a high-frequency boost. +// The boost filter is second-order for `saw2f2` and fourth-order for `saw2f4`, and both are designed +// for the DWP case and therefore use `saw2dpw`. +// See Figure 4(b) in the DPW reference for a plot of the slight droop in the DPW case. +//-------------------------------------------------------- +declare saw2f2 author "Julius O. Smith III"; +declare saw2f2 license "STK-4.3"; +// --- Correction-filtered versions of saw2: saw2f2, saw2f4 ----- +saw2f2 = saw2dpw : cf2 with { + cf2 = fi.tf2(1.155704605878911, 0.745184288225518,0.040305967265900, + 0.823765146386639, 0.117420665547108); +}; +declare saw2f4 author "Julius O. Smith III"; +declare saw2f4 license "STK-4.3"; +saw2f4 = saw2dpw : cf4 with { + cf4 = fi.iir((1.155727435125014, 2.285861038554662, + 1.430915027294021, 0.290713280893317, 0.008306401748854), + (2.156834679164532, 1.559532244409321, 0.423036498118354, + 0.032080681130972)); +}; + +//=========Alias-Suppressed Pulse, Square, and Impulse Trains============ +// Alias-Suppressed Pulse, Square and Impulse Trains. +// +// `pulsetrainN`, `pulsetrain`, `squareN`, `square`, `imptrainN`, `imptrain`, +// `triangleN`, `triangle` +// +// All are zero-mean and meant to oscillate in the audio frequency range. +// Use simpler sample-rounded `lf_*` versions above for LFOs. +// +// #### Usage +// +// ``` +// pulsetrainN(N,freq,duty) : _ +// pulsetrain(freq, duty) : _ // = pulsetrainN(2) +// +// squareN(N,freq) : _ +// square : _ // = squareN(2) +// +// imptrainN(N,freq) : _ +// imptrain : _ // = imptrainN(2) +// +// triangleN(N,freq) : _ +// triangle : _ // = triangleN(2) +// ``` +// +// Where: +// +// * `N`: polynomial order, a constant numerical expression +// * `freq`: frequency in Hz +//==================================================================== + + +//------------------`(os.)impulse`-------------------------------- +// One-time impulse generated when the Faust process is started. +// `impulse` is a standard Faust function. +// +// #### Usage +// +// ``` +// impulse : _ +// ``` +//-------------------------------------------------------- +impulse = 1-1'; + + +//------------------`(os.)pulsetrainN`-------------------------------- +// Alias-suppressed pulse train oscillator. +// +// #### Usage +// +// ``` +// pulsetrainN(N,freq,duty) : _ +// ``` +// +// Where: +// +// * `N`: order, as a constant numerical expression +// * `freq`: frequency in Hz +// * `duty`: duty cycle between 0 and 1 + +//-------------------------------------------------------- +pulsetrainN(N,freq,duty) = diffdel(sawN(N,freqC),del) with { + // non-interpolated-delay version: diffdel(x,del) = x - x@int(del+0.5); + // linearly interpolated delay version (sounds good to me): + diffdel(x,del) = x-x@int(del)*(1-ma.frac(del))-x@(int(del)+1)*ma.frac(del); + // Third-order Lagrange interpolated-delay version (see filters.lib): + // diffdel(x,del) = x - fdelay3(DELPWR2,max(1,min(DELPWR2-2,ddel))); + DELPWR2 = 2048; // Needs to be a power of 2 when fdelay*() used above. + delmax = DELPWR2-1; // arbitrary upper limit on diff delay (duty=0.5) + SRmax = 96000.0; // assumed upper limit on sampling rate + fmin = SRmax / float(2.0*delmax); // 23.4 Hz (audio freqs only) + freqC = max(freq,fmin); // clip frequency at lower limit + period = (float(ma.SR) / freqC); // actual period + ddel = duty * period; // desired delay + del = max(0,min(delmax,ddel)); +}; + + +//------------------`(os.)pulsetrain`-------------------------------- +// Alias-suppressed pulse train oscillator. Based on `pulsetrainN(2)`. +// `pulsetrain` is a standard Faust function. +// +// #### Usage +// +// ``` +// pulsetrain(freq,duty) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// * `duty`: duty cycle between 0 and 1 +//-------------------------------------------------------- +pulsetrain = pulsetrainN(2); + + +//------------------`(os.)squareN`-------------------------------- +// Alias-suppressed square wave oscillator. +// +// #### Usage +// +// ``` +// squareN(N,freq) : _ +// ``` +// +// Where: +// +// * `N`: order, as a constant numerical expression +// * `freq`: frequency in Hz +//-------------------------------------------------------- +squareN(N,freq) = pulsetrainN(N,freq,0.5); + + +//------------------`(os.)square`-------------------------------- +// Alias-suppressed square wave oscillator. Based on `squareN(2)`. +// `square` is a standard Faust function. +// +// #### Usage +// +// ``` +// square(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//-------------------------------------------------------- +square = squareN(2); + + +//------------------`(os.)imptrainN`-------------------------------- +// Alias-suppressed impulse train generator. +// +// #### Usage +// +// ``` +// imptrainN(N,freq) : _ +// ``` +// +// Where: +// +// * `N`: order, as a constant numerical expression +// * `freq`: frequency in Hz +//-------------------------------------------------------- +imptrainN(N,freq) = impulse + 0.5*ma.diffn(sawN(N,freq)); + + +//------------------`(os.)imptrain`-------------------------------- +// Alias-suppressed impulse train generator. Based on `imptrainN(2)`. +// `imptrain` is a standard Faust function. +// +// #### Usage +// +// ``` +// imptrain(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//-------------------------------------------------------- +imptrain = imptrainN(2); // default based on saw2 + + +//------------------`(os.)triangleN`-------------------------------- +// Alias-suppressed triangle wave oscillator. +// +// #### Usage +// +// ``` +// triangleN(N,freq) : _ +// ``` +// +// Where: +// +// * `N`: order, as a constant numerical expression +// * `freq`: frequency in Hz +//-------------------------------------------------------- +triangleN(N,freq) = squareN(N,freq) : fi.pole(p) : *(gain) with { + gain = 4.0*freq/ma.SR; // for aproximate unit peak amplitude + p = 0.999; +}; + + +//------------------`(os.)triangle`-------------------------------- +// Alias-suppressed triangle wave oscillator. Based on `triangleN(2)`. +// `triangle` is a standard Faust function. +// +// #### Usage +// +// ``` +// triangle(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//-------------------------------------------------------- +triangle = triangleN(2); // default based on saw2 + + +//===============================Filter-Based Oscillators================================= +// Filter-Based Oscillators. +// +// #### Usage +// +// ``` +// osc[b|rq|rs|rc|s](freq), where freq = frequency in Hz. +// ``` +// +// #### References +// +// * +// * +//======================================================================================== + +//--------------------------`(os.)oscb`-------------------------------- +// Sinusoidal oscillator based on the biquad. +// +// #### Usage +// +// ``` +// oscb(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +oscb(f) = impulse : fi.tf2(1,0,0,a1,1) +with { + a1 = -2*cos(2*ma.PI*f/ma.SR); +}; + + +//--------------------------`(os.)oscrq`--------------------------- +// Sinusoidal (sine and cosine) oscillator based on 2D vector rotation, +// = undamped "coupled-form" resonator +// = lossless 2nd-order normalized ladder filter. +// +// #### Usage +// +// ``` +// oscrq(freq) : _,_ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +// #### Reference +// +// * +//------------------------------------------------------------ +oscrq(f) = impulse : fi.nlf2(f,1); // sine and cosine outputs + +//--------------------------`(os.)oscrs`--------------------------- +// Sinusoidal (sine) oscillator based on 2D vector rotation, +// = undamped "coupled-form" resonator +// = lossless 2nd-order normalized ladder filter. +// +// #### Usage +// +// ``` +// oscrs(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +// #### Reference +// +// * +//------------------------------------------------------------ +oscrs(f) = impulse : fi.nlf2(f,1) : _,!; // sine + +//--------------------------`(os.)oscrc`--------------------------- +// Sinusoidal (cosine) oscillator based on 2D vector rotation, +// = undamped "coupled-form" resonator +// = lossless 2nd-order normalized ladder filter. +// +// #### Usage +// +// ``` +// oscrc(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +// #### Reference +// +// * +//------------------------------------------------------------ +oscrc(f) = impulse : fi.nlf2(f,1) : !,_; // cosine + +oscrp(f,p) = oscrq(f) : *(cos(p)), *(sin(p)) : + ; // p=0 for sine, p=PI/2 for cosine, etc. + +oscr = oscrs; // default = sine (starts without a pop) + +//--------------------------`(os.)oscs`-------------------------------- +// Sinusoidal oscillator based on the state variable filter +// = undamped "modified-coupled-form" resonator +// = "magic circle" algorithm used in graphics. +// +// #### Usage +// +// ``` +// oscs(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +oscs(f) = (*(-1) : sint(wn) : sintp(wn,impulse)) ~ _ +with { + wn = 2*ma.PI*f/ma.SR; // approximate + // wn = 2*sin(PI*f/SR); // exact + sint(x) = *(x) : + ~ _ ; // frequency-scaled integrator + sintp(x,y) = *(x) : +(y): + ~ _; // same + state input +}; + +//-----------------`(os.)quadosc`-------------------- +// Sinusoidal oscillator based on QuadOsc by Martin Vicanek. +// +// #### Usage +// +// ``` +// quadosc(freq) : _ +// ``` +// +// where +// +// * `freq`: frequency in Hz +// +// #### Reference +// * +//------------------------------------------------------------ +// Authors: +// Dario Sanfilippo +// and Oleg Nesterov (jos ed.) +quadosc(f) = tick ~ (_,_) +with { + k1 = tan(f * ma.PI / ma.SR); + k2 = 2 * k1 / (1 + k1 * k1); + tick(u_0,v_0) = u_1,v_1 + with { + tmp = u_0 - k1 * v_0; + v_1 = v_0 + k2 * tmp; + u_1 = tmp - k1 * v_1 : select2(1',1); + }; +}; + + +//================ Waveguide-Resonator-Based Oscillators ================ +// Sinusoidal oscillator based on the waveguide resonator `wgr`. +//======================================================================= + +//-----------------`(os.)oscwc`-------------------- +// Sinusoidal oscillator based on the waveguide resonator `wgr`. Unit-amplitude +// cosine oscillator. +// +// #### Usage +// +// ``` +// oscwc(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +// #### Reference +// +// * +//------------------------------------------------------------ +oscwc(fr) = impulse : fi.wgr(fr,1) : _,!; // cosine (cheapest at 1 mpy/sample) + +//-----------------`(os.)oscws`-------------------- +// Sinusoidal oscillator based on the waveguide resonator `wgr`. Unit-amplitude +// sine oscillator. +// +// #### Usage +// +// ``` +// oscws(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +// #### Reference +// +// * +//------------------------------------------------------------ +oscws(fr) = impulse : fi.wgr(fr,1) : !,_; // sine (needs a 2nd scaling mpy) + +//-----------------`(os.)oscq`-------------------- +// Sinusoidal oscillator based on the waveguide resonator `wgr`. +// Unit-amplitude cosine and sine (quadrature) oscillator. +// +// #### Usage +// +// ``` +// oscq(freq) : _,_ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +// #### Reference +// +// * +//------------------------------------------------------------ +oscq(fr) = impulse : fi.wgr(fr,1); // phase quadrature outputs + +//-----------------`(os.)oscw`-------------------- +// Sinusoidal oscillator based on the waveguide resonator `wgr`. +// Unit-amplitude cosine oscillator (default). +// +// #### Usage +// +// ``` +// oscw(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +// +// #### Reference +// +// * +//------------------------------------------------------------ +oscw = oscwc; + +// end jos section +//######################################################################################## +/************************************************************************ +FAUST library file, further contributions section + +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ + +//===================== Casio CZ Oscillators ========================== +// Oscillators that mimic some of the Casio CZ oscillators. +// +// There are two sets: +// +// * a set with an index parameter +// +// * a set with a res parameter +// +// The "index oscillators" outputs a sine wave at index=0 and gets brighter with a higher index. +// There are two versions of the "index oscillators": +// +// * with P appended to the name: is phase aligned with `fund:sin` +// +// * without P appended to the name: has the phase of the original CZ oscillators +// +// The "res oscillators" have a resonant frequency. +// "res" is the frequency of resonance as a factor of the fundamental pitch. +//===================================================================== + +//----------`(os.)CZsaw`---------- +// Oscillator that mimics the Casio CZ saw oscillator. +// `CZsaw` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZsaw(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 to 1. 0 = sine-wave, 1 = saw-wave +//------------------------------------------------------------ +declare CZsaw author "Bart Brouns"; +declare CZsaw licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZsaw(fund, index) = CZ.sawChooseP(fund, index, 0); + +//----------`(os.)CZsawP`---------- +// Oscillator that mimics the Casio CZ saw oscillator, +// with it's phase aligned to `fund:sin`. +// `CZsawP` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZsawP(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 to 1. 0 = sine-wave, 1 = saw-wave +//------------------------------------------------------------ +declare CZsawP author "Bart Brouns"; +declare CZsawP licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZsawP(fund, index) = CZ.sawChooseP(fund, index, 1); + +//----------`(os.)CZsquare`---------- +// Oscillator that mimics the Casio CZ square oscillator +// `CZsquare` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZsquare(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 to 1. 0 = sine-wave, 1 = square-wave +//------------------------------------------------------------ +declare CZsquare author "Bart Brouns"; +declare CZsquare licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZsquare(fund, index) = CZ.squareChooseP(fund, index, 0); + +//----------`(os.)CZsquareP`---------- +// Oscillator that mimics the Casio CZ square oscillator, +// with it's phase aligned to `fund:sin`. +// `CZsquareP` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZsquareP(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 to 1. 0 = sine-wave, 1 = square-wave +//------------------------------------------------------------ +declare CZsquareP author "Bart Brouns"; +declare CZsquareP licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZsquareP(fund, index) = CZ.squareChooseP(fund, index, 1); + +//----------`(os.)CZpulse`---------- +// Oscillator that mimics the Casio CZ pulse oscillator. +// `CZpulse` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZpulse(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 gives a sine-wave, 1 is closer to a pulse +//------------------------------------------------------------ +declare CZpulse author "Bart Brouns"; +declare CZpulse licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZpulse(fund, index) = CZ.pulseChooseP(fund, index, 0); + +//----------`(os.)CZpulseP`---------- +// Oscillator that mimics the Casio CZ pulse oscillator, +// with it's phase aligned to `fund:sin`. +// `CZpulseP` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZpulseP(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 gives a sine-wave, 1 is closer to a pulse +//------------------------------------------------------------ +declare CZpulseP author "Bart Brouns"; +declare CZpulseP licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZpulseP(fund, index) = CZ.pulseChooseP(fund, index, 1); + +//----------`(os.)CZsinePulse`---------- +// Oscillator that mimics the Casio CZ sine/pulse oscillator. +// `CZsinePulse` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZsinePulse(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 gives a sine-wave, 1 is a sine minus a pulse +//------------------------------------------------------------ +declare CZsinePulse author "Bart Brouns"; +declare CZsinePulse licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZsinePulse(fund, index) = CZ.sinePulseChooseP(fund, index, 0); + +//----------`(os.)CZsinePulseP`---------- +// Oscillator that mimics the Casio CZ sine/pulse oscillator, +// with it's phase aligned to `fund:sin`. +// `CZsinePulseP` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZsinePulseP(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 gives a sine-wave, 1 is a sine minus a pulse +//------------------------------------------------------------ +declare CZsinePulseP author "Bart Brouns"; +declare CZsinePulseP licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZsinePulseP(fund, index) = CZ.sinePulseChooseP(fund, index, 1); + +//----------`(os.)CZhalfSine`---------- +// Oscillator that mimics the Casio CZ half sine oscillator. +// `CZhalfSine` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZhalfSine(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 gives a sine-wave, 1 is somewhere between a saw and a square +//------------------------------------------------------------ +declare CZhalfSine author "Bart Brouns"; +declare CZhalfSine licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZhalfSine(fund, index) = CZ.halfSineChooseP(fund, index, 0); + +//----------`(os.)CZhalfSineP`---------- +// Oscillator that mimics the Casio CZ half sine oscillator, +// with it's phase aligned to `fund:sin`. +// `CZhalfSineP` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZhalfSineP(fund,index) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `index`: the brightness of the oscillator, 0 gives a sine-wave, 1 is somewhere between a saw and a square +//------------------------------------------------------------ +declare CZhalfSineP author "Bart Brouns"; +declare CZhalfSineP licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZhalfSineP(fund, index) = CZ.halfSineChooseP(fund, index, 1); + +//----------`(os.)CZresSaw`---------- +// Oscillator that mimics the Casio CZ resonant sawtooth oscillator. +// `CZresSaw` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZresSaw(fund,res) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `res`: the frequency of resonance as a factor of the fundamental pitch. +//------------------------------------------------------------ +declare CZresSaw author "Bart Brouns"; +declare CZresSaw licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZresSaw(fund,res) = CZ.resSaw(fund,res); + +//----------`(os.)CZresTriangle`---------- +// Oscillator that mimics the Casio CZ resonant triangle oscillator. +// `CZresTriangle` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZresTriangle(fund,res) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `res`: the frequency of resonance as a factor of the fundamental pitch. +//------------------------------------------------------------ +declare CZresTriangle author "Bart Brouns"; +declare CZresTriangle licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZresTriangle(fund,res) = CZ.resTriangle(fund,res); + +//----------`(os.)CZresTrap`---------- +// Oscillator that mimics the Casio CZ resonant trapeze oscillator +// `CZresTrap` is a standard Faust function. +// +// #### Usage +// +// ``` +// CZresTrap(fund,res) : _ +// ``` +// +// Where: +// +// * `fund`: a saw-tooth waveform between 0 and 1 that the oscillator slaves to +// * `res`: the frequency of resonance as a factor of the fundamental pitch. +//------------------------------------------------------------ +declare CZresTrap author "Bart Brouns"; +declare CZresTrap licence "STK-4.3"; + +// CZ oscillators by Mike Moser-Booth: +// +// Ported from pd to Faust by Bart Brouns + +CZresTrap(fund, res) = CZ.resTrap(fund, res); + +CZ = environment { + + saw(fund, index) = sawChooseP(fund, index, 0); + sawP(fund, index) = sawChooseP(fund, index, 1); + sawChooseP(fund, index, p) = + (((FUND(fund,align,p)*((.5-INDEX)/INDEX)),(-1*FUND(fund,align,p)+1)*((.5-INDEX)/(1-INDEX))):min+FUND(fund,align,p))*2*ma.PI:cos + with { + INDEX = (.5-(index*.5)):max(0.01):min(0.5); + align = si.interpolate(index, 0.75, 0.5); + }; + + square(fund, index) = squareChooseP(fund, index, 0); + squareP(fund, index) = squareChooseP(fund, index, 1); + squareChooseP(fund, index, p) = (FUND(fund,align,p)>=0.5), (ma.decimal((FUND(fund,align,p)*2)+1)<:_-min(_,(-1*_+1)*((INDEX)/(1-INDEX)))) :+ *ma.PI:cos + with { + INDEX = (index:pow(0.25)):max(0):min(1); + align = si.interpolate(INDEX, -0.25, 0); + }; + + pulse(fund, index) = pulseChooseP(fund, index, 0); + pulseP(fund, index) = pulseChooseP(fund, index, 1); + pulseChooseP(fund, index, p) = ((FUND(fund,align,p)-min(FUND(fund,align,p),((-1*FUND(fund,align,p)+1)*(INDEX/(1-INDEX)))))*2*ma.PI):cos + with { + INDEX = index:min(0.99):max(0); + align = si.interpolate(index, -0.25, 0.0); + }; + + sinePulse(fund, index) = sinePulseChooseP(fund, index, 0); + sinePulseP(fund, index) = sinePulseChooseP(fund, index, 1); + sinePulseChooseP(fund, index, p) = (min(FUND(fund,align,p)*((0.5-INDEX)/INDEX),(-1*FUND(fund,align,p)+1)*((.5-INDEX)/(1-INDEX)))+FUND(fund,align,p))*4*ma.PI:cos + with { + INDEX = ((index*-0.49)+0.5); + align = si.interpolate(index, -0.125, -0.25); + }; + + halfSine(fund, index) = halfSineChooseP(fund, index, 0); + halfSineP(fund, index) = halfSineChooseP(fund, index, 1); + halfSineChooseP(fund, index, p) = (select2(FUND(fund,align,p)<.5, .5*(FUND(fund,align,p)-.5)/INDEX+.5, FUND(fund,align,p)):min(1))*2*ma.PI:cos + with { + INDEX = (.5-(index*0.5)):min(.5):max(.01); + align = si.interpolate(index:min(0.975), -0.25, -0.5); + }; + + FUND = + case { + (fund,align,0) => fund; + (fund,align,1) => (fund+align) : ma.frac; // align phase with fund + }; + resSaw(fund,res) = (((-1*(1-fund))*((cos((ma.decimal((max(1,res)*fund)+1))*2*ma.PI)*-.5)+.5))*2)+1; + resTriangle(fund,res) = select2(fund<.5, 2-(fund*2), fund*2)*INDEX*2-1 + with { + INDEX = ((fund*(res:max(1)))+1:ma.decimal)*2*ma.PI:cos*.5+.5; + }; + resTrap(fund, res) = (((1-fund)*2):min(1)*sin(ma.decimal(fund*(res:max(1)))*2*ma.PI)); +}; + +//===============================PolyBLEP-Based Oscillators================================= + +//----------`(os.)polyblep`---------- +// PolyBLEP residual function, used for smoothing steps in the audio signal. +// +// #### Usage +// +// ``` +// polyblep(Q,phase) : _ +// ``` +// +// Where: +// +// * `Q`: smoothing factor between 0 and 0.5. Determines how far from the ends of the phase interval the quadratic function is used. +// * `phase`: normalised phase (between 0 and 1) +//------------------------------------------------------------ +declare polyblep author "Jacek Wieczorek"; + +polyblep(Q, phase) = (0, L(phase / Q), R((phase - 1) / Q)) : select3(sel) +with { + sel = (phase < Q) + 2*(phase > 1 - Q); + L(x) = 2*x - x*x - 1; // Used near the left end of the interval + R(x) = 2*x + x*x + 1; // Used near the right end of the interval +}; + +//----------`(os.)polyblep_saw`---------- +// Sawtooth oscillator with suppressed aliasing (using `polyblep`). +// +// #### Usage +// +// ``` +// polyblep_saw(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +declare polyblep_saw author "Jacek Wieczorek"; + +polyblep_saw(freq) = naive - polyblep(Q , phase) +with { + phase = phasor(1, freq); + naive = 2 * phase - 1; + Q = freq / ma.SR; +}; + +//----------`(os.)polyblep_square`---------- +// Square wave oscillator with suppressed aliasing (using `polyblep`). +// +// #### Usage +// +// ``` +// polyblep_square(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +declare polyblep_square author "Jacek Wieczorek"; + +polyblep_square(freq) = naive - polyblep(Q, phase) + polyblep(Q, ma.modulo(phase + 0.5, 1)) +with { + phase = phasor(1, freq); + naive = 2 * (phase * 2 : int) - 1; + Q = freq / ma.SR; +}; + +//----------`(os.)polyblep_triangle`---------- +// Triangle wave oscillator with suppressed aliasing (using `polyblep`). +// +// #### Usage +// +// ``` +// polyblep_triangle(freq) : _ +// ``` +// +// Where: +// +// * `freq`: frequency in Hz +//------------------------------------------------------------ +declare polyblep_triangle author "Jacek Wieczorek"; + +polyblep_triangle(freq) = polyblep_square(freq) : fi.pole(0.999) : *(4 * freq / ma.SR); + +// end further contributions section +//######################################################################################## diff --git a/dist/examples/LIBRARIES/phaflangers.lib b/dist/examples/LIBRARIES/phaflangers.lib new file mode 100644 index 00000000..f3da4acc --- /dev/null +++ b/dist/examples/LIBRARIES/phaflangers.lib @@ -0,0 +1,235 @@ +//#################################### phaflangers.lib ######################################## +// A library of phasor and flanger effects. Its official prefix is `pf`. +// +// #### References +// * +//######################################################################################## + +ma = library("maths.lib"); +de = library("delays.lib"); +fi = library("filters.lib"); +os = library("oscillators.lib"); +pf = library("phaflangers.lib"); + +declare name "Faust Phaser and Flanger Library"; +declare version "0.1"; + +//######################################################################################## +/************************************************************************ +FAUST library file, JOS section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2017 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +All MarkDown comments in this section are Copyright 2016-2017 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees!) + +************************************************************************/ + +//=============================Functions Reference======================================== +//======================================================================================== + +//---------------`(pf.)flanger_mono`------------- +// Mono flanging effect. +// +// #### Usage: +// +// ``` +// _ : flanger_mono(dmax,curdel,depth,fb,invert) : _ +// ``` +// +// Where: +// +// * `dmax`: maximum delay-line length (power of 2) - 10 ms typical +// * `curdel`: current dynamic delay (not to exceed dmax) +// * `depth`: effect strength between 0 and 1 (1 typical) +// * `fb`: feedback gain between 0 and 1 (0 typical) +// * `invert`: 0 for normal, 1 to invert sign of flanging sum +// +// #### Reference +// +// +//------------------------------------------------------------ +flanger_mono(dmax,curdel,depth,fb,invert) + = _ <: _, (- : de.fdelay(dmax,curdel)) ~ *(fb) : _, + *(select2(invert,depth,0-depth)) + : + : *(0.5); + +//---------------`(pf.)flanger_stereo`------------- +// Stereo flanging effect. +// `flanger_stereo` is a standard Faust function. +// +// #### Usage: +// +// ``` +// _,_ : flanger_stereo(dmax,curdel1,curdel2,depth,fb,invert) : _,_ +// ``` +// +// Where: +// +// * `dmax`: maximum delay-line length (power of 2) - 10 ms typical +// * `curdel1`: current dynamic delay for the left channel (not to exceed dmax) +// * `curdel2`: current dynamic delay for the right channel (not to exceed dmax) +// * `depth`: effect strength between 0 and 1 (1 typical) +// * `fb`: feedback gain between 0 and 1 (0 typical) +// * `invert`: 0 for normal, 1 to invert sign of flanging sum +// +// #### Reference +// +// +//------------------------------------------------------------ +flanger_stereo(dmax,curdel1,curdel2,depth,fb,invert) + = flanger_mono(dmax,curdel1,depth,fb,invert), + flanger_mono(dmax,curdel2,depth,fb,invert); + + +vibrato2_mono(sections,phase01,fb,width,frqmin,fratio,frqmax,speed) = + (+ : seq(i,sections,ap2p(R,th(i)))) ~ *(fb) +with { + //tf2 = component("filters.lib").tf2; + // second-order resonant digital allpass given pole radius and angle: + ap2p(R,th) = fi.tf2(a2,a1,1,a1,a2) with { + a2 = R^2; + a1 = -2*R*cos(th); + }; + R = exp(-pi*width/ma.SR); + cososc = os.oscrc; // oscillators.lib + sinosc = os.oscrs; // oscillators.lib + osc = cososc(speed) * phase01 + sinosc(speed) * (1-phase01); + lfo = (1-osc)/2; // in [0,1] + pi = 4*atan(1); + thmin = 2*pi*frqmin/ma.SR; + thmax = 2*pi*frqmax/ma.SR; + th1 = thmin + (thmax-thmin)*lfo; + th(i) = (fratio^(i+1))*th1; +}; + + +//-------`(pf.)phaser2_mono`----------------- +// Mono phasing effect. +// +// #### Phaser +// +// ``` +// _ : phaser2_mono(Notches,phase,width,frqmin,fratio,frqmax,speed,depth,fb,invert) : _ +// ``` +// +// Where: +// +// * `Notches`: number of spectral notches (MACRO ARGUMENT - not a signal) +// * `phase`: phase of the oscillator (0-1) +// * `width`: approximate width of spectral notches in Hz +// * `frqmin`: approximate minimum frequency of first spectral notch in Hz +// * `fratio`: ratio of adjacent notch frequencies +// * `frqmax`: approximate maximum frequency of first spectral notch in Hz +// * `speed`: LFO frequency in Hz (rate of periodic notch sweep cycles) +// * `depth`: effect strength between 0 and 1 (1 typical) (aka "intensity") +// when depth=2, "vibrato mode" is obtained (pure allpass chain) +// * `fb`: feedback gain between -1 and 1 (0 typical) +// * `invert`: 0 for normal, 1 to invert sign of flanging sum +// +// Reference: +// +// * +// * +// * 'An Allpass Approach to Digital Phasing and Flanging', Julius O. Smith III, +// Proc. Int. Computer Music Conf. (ICMC-84), pp. 103-109, Paris, 1984. +// * CCRMA Tech. Report STAN-M-21: +//------------------------------------------------------------ +phaser2_mono(Notches,phase01,width,frqmin,fratio,frqmax,speed,depth,fb,invert) = + _ <: *(g1) + g2mi*vibrato2_mono(Notches,phase01,fb,width,frqmin,fratio,frqmax,speed) +with { // depth=0 => direct-signal only + g1 = 1-depth/2; // depth=1 => phaser mode (equal sum of direct and allpass-chain) + g2 = depth/2; // depth=2 => vibrato mode (allpass-chain signal only) + g2mi = select2(invert,g2,-g2); // inversion negates the allpass-chain signal +}; + + +//-------`(pf.)phaser2_stereo`------- +// Stereo phasing effect. +// `phaser2_stereo` is a standard Faust function. +// +// #### Phaser +// +// ``` +// _,_ : phaser2_stereo(Notches,width,frqmin,fratio,frqmax,speed,depth,fb,invert) : _,_ +// ``` +// +// Where: +// +// * `Notches`: number of spectral notches (MACRO ARGUMENT - not a signal) +// * `width`: approximate width of spectral notches in Hz +// * `frqmin`: approximate minimum frequency of first spectral notch in Hz +// * `fratio`: ratio of adjacent notch frequencies +// * `frqmax`: approximate maximum frequency of first spectral notch in Hz +// * `speed`: LFO frequency in Hz (rate of periodic notch sweep cycles) +// * `depth`: effect strength between 0 and 1 (1 typical) (aka "intensity") +// when depth=2, "vibrato mode" is obtained (pure allpass chain) +// * `fb`: feedback gain between -1 and 1 (0 typical) +// * `invert`: 0 for normal, 1 to invert sign of flanging sum +// +// Reference: +// +// * +// * +// * 'An Allpass Approach to Digital Phasing and Flanging', Julius O. Smith III, +// Proc. Int. Computer Music Conf. (ICMC-84), pp. 103-109, Paris, 1984. +// * CCRMA Tech. Report STAN-M-21: +//------------------------------------------------------------ +phaser2_stereo(Notches,width,frqmin,fratio,frqmax,speed,depth,fb,invert) + = phaser2_mono(Notches,0,width,frqmin,fratio,frqmax,speed,depth,fb,invert), + phaser2_mono(Notches,1,width,frqmin,fratio,frqmax,speed,depth,fb,invert); + +// end jos section +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +// TODO: Add GRAME functions here + +//######################################################################################## +/************************************************************************ +FAUST library file, further contributions section + +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ diff --git a/dist/examples/LIBRARIES/physmodels.lib b/dist/examples/LIBRARIES/physmodels.lib new file mode 100644 index 00000000..7e8d49b6 --- /dev/null +++ b/dist/examples/LIBRARIES/physmodels.lib @@ -0,0 +1,3990 @@ +//##################################### physmodels.lib ################################### +// Faust physical modeling library. Its official prefix is `pm`. +// +// This library provides an environment to facilitate physical modeling of musical +// instruments. It contains dozens of functions implementing low and high level +// elements going from a simple waveguide to fully operational models with +// built-in UI, etc. +// +// It is organized as follows: +// +// * [Global Variables](#global-variables): useful pre-defined variables for +// physical modeling (e.g., speed of sound, etc.). +// * [Conversion Tools](#conversion-tools-1): conversion functions specific +// to physical modeling (e.g., length to frequency, etc.). +// * [Bidirectional Utilities](#bidirectional-utilities): functions to create +// bidirectional block diagrams for physical modeling. +// * [Basic Elements](#basic-elements-1): waveguides, specific types of filters, etc. +// * [String Instruments](#string-instruments): various types of strings +// (e.g., steel, nylon, etc.), bridges, guitars, etc. +// * [Bowed String Instruments](#bowed-string-instruments): parts and models +// specific to bowed string instruments (e.g., bows, bridges, violins, etc.). +// * [Wind Instrument](#wind-instruments): parts and models specific to wind +// instruments (e.g., reeds, mouthpieces, flutes, clarinets, etc.). +// * [Exciters](#exciters): pluck generators, "blowers", etc. +// * [Modal Percussions](#modal-percussions): percussion instruments based on +// modal models. +// * [Vocal Synthesis](#vocal-synthesis): functions for various vocal synthesis +// techniques (e.g., fof, source/filter, etc.) and vocal synthesizers. +// * [Misc Functions](#misc-functions): any other functions that don't fit in +// the previous category (e.g., nonlinear filters, etc.). +// +// This library is part of the Faust Physical Modeling ToolKit. +// More information on how to use this library can be found on [this page](https://ccrma.stanford.edu/~rmichon/pmFaust). Tutorials on how to make +// physical models of musical instruments using Faust can be found +// [here](https://ccrma.stanford.edu/~rmichon/faustTutorials/#making-physical-models-of-musical-instruments-with-faust) as well. +// +// #### References +// * +//######################################################################################## +// Authors: Romain Michon, Pierre-Amaury Grumiaux, and Yann Orlarey + +import("stdfaust.lib"); + +declare name "Faust Physical Models Library"; +declare version "0.1"; + +/* +TODO: + - It'd be cool to have a version of the block diagram generator that automatically flips + things based on the use of chains, etc. + - When setting pole of filters by hand (e.g. smooth, should adjust pole in function of SR) + - Probably need a single resonator function / see how to integrate that with "mode" + - Need a non-linear function and see how this can be integrated with modal synthesis + - See how bowed modal models could be integrated to this + - Currently still missing keyboard instruments + - Currently still missing vocal synth: easy to fix (create a formant filter function) + - Real polyphonic instruments should be designated with some kind of prefix (e.g., + full) +*/ + +//=============================Global Variables=========================================== +// Useful pre-defined variables for physical modeling. +//======================================================================================== + +//--------------`(pm.)speedOfSound`---------- +// Speed of sound in meters per second (340m/s). +//-------------------------------------- +speedOfSound = 340; + +//--------------`(pm.)maxLength`---------- +// The default maximum length (3) in meters of strings and tubes used in this +// library. This variable should be overriden to allow longer strings or tubes. +//-------------------------------------- +maxLength = 3; + +//================================Conversion Tools======================================= +// Useful conversion tools for physical modeling. +//======================================================================================== + +//--------------`(pm.)f2l`---------- +// Frequency to length in meters. +// +// #### Usage +// +// ``` +// f2l(freq) : distanceInMeters +// ``` +// +// Where: +// +// * `freq`: the frequency +//------------------------------- +f2l(freq) = speedOfSound/freq; + +//--------------`(pm.)l2f`---------- +// Length in meters to frequency. +// +// #### Usage +// +// ``` +// l2f(length) : freq +// ``` +// +// Where: +// +// * `length`: length/distance in meters +//------------------------------- +l2f(length) = speedOfSound/length; + +//--------------`(pm.)l2s`---------- +// Length in meters to number of samples. +// +// #### Usage +// +// ``` +// l2s(l) : numberOfSamples +// ``` +// +// Where: +// +// * `l`: length in meters +//------------------------------- +l2s(l) = l*ma.SR/speedOfSound; + +//=============================Bidirectional Utilities==================================== +// Set of fundamental functions to create bi-directional block diagrams in Faust. +// These elements are used as the basis of this library to connect high level +// elements (e.g., mouthpieces, strings, bridge, instrument body, etc.). Each +// block has 3 inputs and 3 outputs. The first input/output carry left going +// waves, the second input/output carry right going waves, and the third +// input/output is used to carry any potential output signal to the end of the +// algorithm. +//======================================================================================== + +//--------------`(pm.)basicBlock`---------- +// Empty bidirectional block to be used with [`chain`](#chain): 3 signals ins +// and 3 signals out. +// +// #### Usage +// +// ``` +// chain(basicBlock : basicBlock : etc.) +// ``` +//------------------------------- +basicBlock = _,_,_; + +//-------`(pm.)chain`---------- +// Creates a chain of bidirectional blocks. +// Blocks must have 3 inputs and outputs. The first input/output carry left +// going waves, the second input/output carry right going waves, and the third +// input/output is used to carry any potential output signal to the end of the +// algorithm. The implied one sample delay created by the `~` operator is +// generalized to the left and right going waves. Thus, `n` blocks in `chain()` +// will add an `n` samples delay to both left and right going waves. +// +// #### Usage +// +// ``` +// leftGoingWaves,rightGoingWaves,mixedOutput : chain( A : B ) : leftGoingWaves,rightGoingWaves,mixedOutput +// with{ +// A = _,_,_; +// B = _,_,_; +// }; +// ``` +//----------------------------- +chain(A:As) = ((ro.crossnn(1),_',_ : _,A : ro.crossnn(1),_,_ : _,chain(As) : ro.crossnn(1),_,_)) ~ _ : !,_,_,_; +chain(A) = A; + +//-------`(pm.)inLeftWave`-------------- +// Adds a signal to left going waves anywhere in a [`chain`](#chain) of blocks. +// +// #### Usage +// +// ``` +// model(x) = chain(A : inLeftWave(x) : B) +// ``` +// +// Where `A` and `B` are bidirectional blocks and `x` is the signal added to left +// going waves in that chain. +//-------------------------------- +inLeftWave(x) = +(x),_,_; + +//-------`(pm.)inRightWave`-------------- +// Adds a signal to right going waves anywhere in a [`chain`](#chain) of blocks. +// +// #### Usage +// +// ``` +// model(x) = chain(A : inRightWave(x) : B) +// ``` +// +// Where `A` and `B` are bidirectional blocks and `x` is the signal added to right +// going waves in that chain. +//-------------------------------- +inRightWave(x) = _,+(x),_; + +//-------`(pm.)in`-------------- +// Adds a signal to left and right going waves anywhere in a [`chain`](#chain) +// of blocks. +// +// #### Usage +// +// ``` +// model(x) = chain(A : in(x) : B) +// ``` +// +// Where `A` and `B` are bidirectional blocks and `x` is the signal added to +// left and right going waves in that chain. +//-------------------------------- +in(x) = +(x),+(x),_; + +//-------`(pm.)outLeftWave`-------------- +// Sends the signal of left going waves to the output channel of the [`chain`](#chain). +// +// #### Usage +// +// ``` +// chain(A : outLeftWave : B) +// ``` +// +// Where `A` and `B` are bidirectional blocks. +//-------------------------------- +outLeftWave(x,y,s) = x,y,x+s; + +//-------`(pm.)outRightWave`-------------- +// Sends the signal of right going waves to the output channel of the [`chain`](#chain). +// +// #### Usage +// +// ``` +// chain(A : outRightWave : B) +// ``` +// +// Where `A` and `B` are bidirectional blocks. +//-------------------------------- +outRightWave(x,y,s) = x,y,y+s; + +//-------`(pm.)out`-------------- +// Sends the signal of right and left going waves to the output channel of the +// [`chain`](#chain). +// +// #### Usage +// +// ``` +// chain(A : out : B) +// ``` +// +// Where `A` and `B` are bidirectional blocks. +//-------------------------------- +out(x,y,s) = x,y,x+y+s; + +//-------`(pm.)terminations`-------------- +// Creates terminations on both sides of a [`chain`](#chain) without closing +// the inputs and outputs of the bidirectional signals chain. As for +// [`chain`](#chain), this function adds a 1 sample delay to the bidirectional +// signal, both ways. Of course, this function can be nested within a +// [`chain`](#chain). +// +// #### Usage +// +// ``` +// terminations(a,b,c) +// with{ +// a = *(-1); // left termination +// b = chain(D : E : F); // bidirectional chain of blocks (D, E, F, etc.) +// c = *(-1); // right termination +// }; +// ``` +//---------------------------------------- +terminations(a,b,c) = (_,ro.crossnn(1),_,_ : +,+,_ : b) ~ (a,c : ro.crossnn(1)); + +//-------`(pm.)lTermination`---------- +// Creates a termination on the left side of a [`chain`](#chain) without +// closing the inputs and outputs of the bidirectional signals chain. This +// function adds a 1 sample delay near the termination and can be nested +// within another [`chain`](#chain). +// +// #### Usage +// +// ``` +// lTerminations(a,b) +// with{ +// a = *(-1); // left termination +// b = chain(D : E : F); // bidirectional chain of blocks (D, E, F, etc.) +// }; +// ``` +//---------------------------------------- +lTermination(a,b) = (ro.crossnn(1),_,_ : _,+,_ : b) ~ a; + +//-------`(pm.)rTermination`---------- +// Creates a termination on the right side of a [`chain`](#chain) without +// closing the inputs and outputs of the bidirectional signals chain. This +// function adds a 1 sample delay near the termination and can be nested +// within another [`chain`](#chain). +// +// #### Usage +// +// ``` +// rTerminations(b,c) +// with{ +// b = chain(D : E : F); // bidirectional chain of blocks (D, E, F, etc.) +// c = *(-1); // right termination +// }; +// ``` +//---------------------------------------- +rTermination(b,c) = (_,_,_,_ : +,_,_ : b) ~ (!,c); + +//-------`(pm.)closeIns`---------- +// Closes the inputs of a bidirectional chain in all directions. +// +// #### Usage +// +// ``` +// closeIns : chain(...) : _,_,_ +// ``` +//---------------------------------------- +closeIns = 0,0,0; + +//-------`(pm.)closeOuts`---------- +// Closes the outputs of a bidirectional chain in all directions except for the +// main signal output (3d output). +// +// #### Usage +// +// ``` +// _,_,_ : chain(...) : _ +// ``` +//---------------------------------------- +closeOuts = !,!,_; + +//-------`(pm.)endChain`---------- +// Closes the inputs and outputs of a bidirectional chain in all directions +// except for the main signal output (3d output). +// +// #### Usage +// +// ``` +// endChain(chain(...)) : _ +// ``` +//---------------------------------------- +endChain(b) = closeIns : b : closeOuts; + + +//==================================Basic Elements======================================== +// Basic elements for physical modeling (e.g., waveguides, specific filters, +// etc.). +//======================================================================================== + +//-------`(pm.)waveguideN`---------- +// A series of waveguide functions based on various types of delays (see +// [`fdelay[n]`](#fdelayn)). +// +// #### List of functions +// +// * `waveguideUd`: unit delay waveguide +// * `waveguideFd`: fractional delay waveguide +// * `waveguideFd2`: second order fractional delay waveguide +// * `waveguideFd4`: fourth order fractional delay waveguide +// +// #### Usage +// +// ``` +// chain(A : waveguideUd(nMax,n) : B) +// ``` +// +// Where: +// +// * `nMax`: the maximum length of the delays in the waveguide +// * `n`: the length of the delay lines in samples. +//---------------------------------- +waveguideUd(nMax,n) = par(i,2,de.delay(nMax,n)),_; +waveguideFd(nMax,n) = par(i,2,de.fdelay(nMax,n)),_; +waveguideFd2(nMax,n) = par(i,2,de.fdelay2(nMax,n)),_; +waveguideFd4(nMax,n) = par(i,2,de.fdelay4(nMax,n)),_; + + +//-------`(pm.)waveguide`---------- +// Standard `pm.lib` waveguide (based on [`waveguideFd4`](#waveguiden)). +// +// #### Usage +// +// ``` +// chain(A : waveguide(nMax,n) : B) +// ``` +// +// Where: +// +// * `nMax`: the maximum length of the delays in the waveguide +// * `n`: the length of the delay lines in samples. +//---------------------------------- +waveguide(nMax,n) = waveguideFd4(nMax,n); + + +//-------`(pm.)bridgeFilter`---------- +// Generic two zeros bridge FIR filter (as implemented in the +// [STK](https://ccrma.stanford.edu/software/stk/)) that can be used to +// implement the reflectance violin, guitar, etc. bridges. +// +// #### Usage +// +// ``` +// _ : bridge(brightness,absorption) : _ +// ``` +// +// Where: +// +// * `brightness`: controls the damping of high frequencies (0-1) +// * `absorption`: controls the absorption of the brige and thus the t60 of +// the string plugged to it (0-1) (1 = 20 seconds) +//---------------------------------- +// TODO: perhaps, the coefs of this filter should be adapted in function of SR +bridgeFilter(brightness,absorption,x) = rho * (h0 * x' + h1*(x+x'')) +with{ + freq = 320; + t60 = (1-absorption)*20; + h0 = (1.0 + brightness)/2; + h1 = (1.0 - brightness)/4; + rho = pow(0.001,1.0/(freq*t60)); +}; + + +//-------`(pm.)modeFilter`---------- +// Resonant bandpass filter that can be used to implement a single resonance +// (mode). +// +// #### Usage +// +// ``` +// _ : modeFilter(freq,t60,gain) : _ +// ``` +// +// Where: +// +// * `freq`: mode frequency +// * `t60`: mode resonance duration (in seconds) +// * `gain`: mode gain (0-1) +//---------------------------------- +modeFilter(freq,t60,gain) = fi.tf2(b0,b1,b2,a1,a2)*gain +with{ + b0 = 1; + b1 = 0; + b2 = -1; + w = 2*ma.PI*freq/ma.SR; + r = pow(0.001,1/float(t60*ma.SR)); + a1 = -2*r*cos(w); + a2 = r^2; +}; + + +//================================String Instruments====================================== +// Low and high level string instruments parts. Most of the elements in +// this section can be used in a bidirectional chain. +//======================================================================================== + +//-------`(pm.)stringSegment`---------- +// A string segment without terminations (just a simple waveguide). +// +// #### Usage +// +// ``` +// chain(A : stringSegment(maxLength,length) : B) +// ``` +// +// Where: +// +// * `maxLength`: the maximum length of the string in meters (should be static) +// * `length`: the length of the string in meters +//---------------------------------- +stringSegment(maxLength,length) = waveguide(nMax,n) +with{ + nMax = maxLength : l2s; + n = length : l2s/2; +}; + + +//-------`(pm.)openString`---------- +// A bidirectional block implementing a basic "generic" string with a +// selectable excitation position. Lowpass filters are built-in and +// allow to simulate the effect of dispersion on the sound and thus +// to change the "stiffness" of the string. +// +// #### Usage +// +// ``` +// chain(... : openString(length,stiffness,pluckPosition,excitation) : ...) +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `stiffness`: the stiffness of the string (0-1) (1 for max stiffness) +// * `pluckPosition`: excitation position (0-1) (1 is bottom) +// * `excitation`: the excitation signal +//---------------------------------- +openString(length,stiffness,pluckPosition,excitation) = chain(stringSegment(maxStringLength,ntbd) : in(excitation) : dispersionFilters : stringSegment(maxStringLength,btbd)) +with{ + dispersionFilters = par(i,2,si.smooth(stiffness)),_; // one pole filters + maxStringLength = maxLength; + ntbd = length*pluckPosition; // length of the upper portion of the string + btbd = length*(1-pluckPosition); // length of the lower portion of the string +}; + + +//-------`(pm.)nylonString`---------- +// A bidirectional block implementing a basic nylon string with selectable +// excitation position. This element is based on [`openString`](#openstring) +// and has a fix stiffness corresponding to that of a nylon string. +// +// #### Usage +// +// ``` +// chain(... : nylonString(length,pluckPosition,excitation) : ...) +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: excitation position (0-1) (1 is bottom) +// * `excitation`: the excitation signal +//---------------------------------- +nylonString(length,pluckPosition,excitation) = +openString(length,stiffness,pluckPosition,excitation) +with{ + stiffness = 0.4; // empirically set but it sounds good ;) +}; + + +//-------`(pm.)steelString`---------- +// A bidirectional block implementing a basic steel string with selectable +// excitation position. This element is based on [`openString`](#openstring) +// and has a fix stiffness corresponding to that of a steel string. +// +// #### Usage +// +// ``` +// chain(... : steelString(length,pluckPosition,excitation) : ...) +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: excitation position (0-1) (1 is bottom) +// * `excitation`: the excitation signal +//---------------------------------- +steelString(length,pluckPosition,excitation) = +openString(length,stiffness,pluckPosition,excitation) +with{ + stiffness = 0.05; // empirically set but it sounds good ;) + // in fact, we could almost get rid of the filters in that case, + // but I think it's good to keep them for consistency +}; + + +//-------`(pm.)openStringPick`---------- +// A bidirectional block implementing a "generic" string with selectable +// excitation position. It also has a built-in pickup whose position is the +// same as the excitation position. Thus, moving the excitation position +// will also move the pickup. +// +// #### Usage +// +// ``` +// chain(... : openStringPick(length,stiffness,pluckPosition,excitation) : ...) +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `stiffness`: the stiffness of the string (0-1) (1 for max stiffness) +// * `pluckPosition`: excitation position (0-1) (1 is bottom) +// * `excitation`: the excitation signal +//---------------------------------- +openStringPick(length,stiffness,pluckPosition,excitation) = strChain +with{ + dispersionFilters = par(i,2,si.smooth(stiffness)),_; + maxStringLength = maxLength; + nti = length*pluckPosition; // length of the upper portion of the string + itb = length*(1-pluckPosition); // length of the lower portion of the string + strChain = chain(stringSegment(maxStringLength,nti) : in(excitation) : out : + dispersionFilters : stringSegment(maxStringLength,itb)); +}; + + +//-------`(pm.)openStringPickUp`---------- +// A bidirectional block implementing a "generic" string with selectable +// excitation position and stiffness. It also has a built-in pickup whose +// position can be independenly selected. The only constraint is that the +// pickup has to be placed after the excitation position. +// +// #### Usage +// +// ``` +// chain(... : openStringPickUp(length,stiffness,pluckPosition,excitation) : ...) +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `stiffness`: the stiffness of the string (0-1) (1 for max stiffness) +// * `pluckPosition`: pluck position between the top of the string and the +// pickup (0-1) (1 for same as pickup position) +// * `pickupPosition`: position of the pickup on the string (0-1) (1 is bottom) +// * `excitation`: the excitation signal +//---------------------------------- +openStringPickUp(length,stiffness,pluckPosition,pickupPosition,excitation) = strChain +with{ + dispersionFilters = par(i,2,si.smooth(stiffness)),_; + maxStringLength = maxLength; + nti = length*pluckPosition; // top to excitation length + nto = nti*pickupPosition; // nuts to pickup length + oti = nti*(1-pickupPosition); // pickup to excitation length + itb = length*(1-pluckPosition); // pickup to bottom length + strChain = chain(stringSegment(maxStringLength,nto) : out : + stringSegment(maxStringLength,oti) : in(excitation) : dispersionFilters : + stringSegment(maxStringLength,itb)); +}; + + +//-------`(pm.)openStringPickDown`---------- +// A bidirectional block implementing a "generic" string with selectable +// excitation position and stiffness. It also has a built-in pickup whose +// position can be independenly selected. The only constraint is that the +// pickup has to be placed before the excitation position. +// +// #### Usage +// +// ``` +// chain(... : openStringPickDown(length,stiffness,pluckPosition,excitation) : ...) +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `stiffness`: the stiffness of the string (0-1) (1 for max stiffness) +// * `pluckPosition`: pluck position on the string (0-1) (1 is bottom) +// * `pickupPosition`: position of the pickup between the top of the string +// and the excitation position (0-1) (1 is excitation position) +// * `excitation`: the excitation signal +//---------------------------------- +openStringPickDown(length,stiffness,pluckPosition,pickupPosition,excitation) = +strChain +with{ + dispersionFilters = par(i,2,si.smooth(stiffness)),_; + maxStringLength = maxLength; + nto = length*pickupPosition; // top to pickup length + nti = nto*pluckPosition; // top to excitation length + ito = nto*(1-pluckPosition); // excitation to pickup length + otb = length*(1-pickupPosition); // pickup to bottom length + strChain = chain(stringSegment(maxStringLength,nti) : in(excitation) : + stringSegment(maxStringLength,ito) : out : dispersionFilters : + stringSegment(maxStringLength,otb)); +}; + + +// TODO: eventually, we'd want to implement a generic function here that +// automatically switches the position of elements in the algorithm +// depending on the position of the pick. Even though this is currently +// possible, it will pose optimization issues (we'd want the new mute +// feature of Faust to be generalized in order to do that) + +//-------`(pm.)ksReflexionFilter`---------- +// The "typical" one-zero Karplus-strong feedforward reflexion filter. This +// filter will be typically used in a termination (see below). +// +// #### Usage +// +// ``` +// terminations(_,chain(...),ksReflexionFilter) +// ``` +//---------------------------------- +ksReflexionFilter = _ <: (_+_')/2; + + +//-------`(pm.)rStringRigidTermination`---------- +// Bidirectional block implementing a right rigid string termination (no damping, +// just phase inversion). +// +// #### Usage +// +// ``` +// chain(rStringRigidTermination : stringSegment : ...) +// ``` +//---------------------------------- +rStringRigidTermination = rTermination(basicBlock,*(-1)); + + +//-------`(pm.)lStringRigidTermination`---------- +// Bidirectional block implementing a left rigid string termination (no damping, +// just phase inversion). +// +// #### Usage +// +// ``` +// chain(... : stringSegment : lStringRigidTermination) +// ``` +//---------------------------------- +lStringRigidTermination = lTermination(*(-1),basicBlock); + + +//-------`(pm.)elecGuitarBridge`---------- +// Bidirectional block implementing a simple electric guitar bridge. This +// block is based on [`bridgeFilter`](#bridgeFilter). The bridge doesn't +// implement transmittance since it is not meant to be connected to a +// body (unlike acoustic guitar). It also partially sets the resonance +// duration of the string with the nuts used on the other side. +// +// #### Usage +// +// ``` +// chain(... : stringSegment : elecGuitarBridge) +// ``` +//---------------------------------- +elecGuitarBridge = rTermination(basicBlock,-bridgeFilter(0.8,0.6)); + + +//-------`(pm.)elecGuitarNuts`---------- +// Bidirectional block implementing a simple electric guitar nuts. This +// block is based on [`bridgeFilter`](#bridgeFilter) and does essentially +// the same thing as [`elecGuitarBridge`](#elecguitarbridge), but on the +// other side of the chain. It also partially sets the resonance duration of +// the string with the bridge used on the other side. +// +// #### Usage +// +// ``` +// chain(elecGuitarNuts : stringSegment : ...) +// ``` +//---------------------------------- +elecGuitarNuts = lTermination(-bridgeFilter(0.8,0.6),basicBlock); + + +//-------`(pm.)guitarBridge`---------- +// Bidirectional block implementing a simple acoustic guitar bridge. This +// bridge damps more hight frequencies than +// [`elecGuitarBridge`](#elecguitarbridge) and implements a transmittance +// filter. It also partially sets the resonance duration of the string with +// the nuts used on the other side. +// +// #### Usage +// +// ``` +// chain(... : stringSegment : guitarBridge) +// ``` +//---------------------------------- +guitarBridge = rTermination(basicBlock,reflectance) : _,transmittance,_ +with{ + reflectance = -bridgeFilter(0.4,0.5); + transmittance = _; // TODO +}; + + +//-------`(pm.)guitarNuts`---------- +// Bidirectional block implementing a simple acoustic guitar nuts. This +// nuts damps more hight frequencies than +// [`elecGuitarNuts`](#elecguitarnuts) and implements a transmittance +// filter. It also partially sets the resonance duration of the string with +// the bridge used on the other side. +// +// #### Usage +// +// ``` +// chain(guitarNuts : stringSegment : ...) +// ``` +//---------------------------------- +guitarNuts = lTermination(-bridgeFilter(0.4,0.5),basicBlock); + + +//-------`(pm.)idealString`---------- +// An "ideal" string with rigid terminations and where the plucking position +// and the pick-up position are the same. Since terminations are rigid, this +// string will ring forever. +// +// #### Usage +// +// ``` +// 1-1' : idealString(length,reflexion,xPosition,excitation) +// ``` +// +// With: +// * `length`: the length of the string in meters +// * `pluckPosition`: the plucking position (0.001-0.999) +// * `excitation`: the input signal for the excitation. +//---------------------------------------------------------- +idealString(length,pluckPosition,excitation) = wg +with{ + maxStringLength = maxLength; + lengthTuning = 0.08; // tuned "by hand" + tunedLength = length-lengthTuning; + nUp = tunedLength*pluckPosition; // upper string segment length + nDown = tunedLength*(1-pluckPosition); // lower string segment length + wg = chain(lStringRigidTermination : stringSegment(maxStringLength,nUp) : + in(excitation) : out : stringSegment(maxStringLength,nDown) : + rStringRigidTermination); // waveguide chain +}; + + +//-------`(pm.)ks`---------- +// A Karplus-Strong string (in that case, the string is implemented as a +// one dimension waveguide). +// +// #### Usage +// +// ``` +// ks(length,damping,excitation) : _ +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `damping`: string damping (0-1) +// * `excitation`: excitation signal +//---------------------------------- +ks(length,damping,excitation) = endChain(ksChain) +with{ + maxStringLength = maxLength; + lengthTuning = 0.05; // tuned "by hand" + tunedLength = length-lengthTuning; + refCoef = (1-damping)*0.2+0.8; + refFilter = ksReflexionFilter*refCoef; + ksChain = terminations(_,chain(in(excitation) : + stringSegment(maxStringLength,tunedLength) : out),refFilter); +}; + + +//-------`(pm.)ks_ui_MIDI`---------- +// Ready-to-use, MIDI-enabled Karplus-Strong string with buil-in UI. +// +// #### Usage +// +// ``` +// ks_ui_MIDI : _ +// ``` +//---------------------------------- +ks_ui_MIDI = gate : impulseExcitation*gain : ks( (freq : f2l), damping ) +with{ + f = hslider("v:karplus/h:[0]params/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:karplus/h:[0]params/[1]bend[style:knob][hidden:1][midi:pitchwheel]" + ,0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:karplus/h:[0]params/[2]gain[style:knob]",0.8,0,1,0.01); + s = hslider("v:karplus/h:[0]params/[3]sustain[hidden:1][midi:ctrl 64][style:knob]" + ,0,0,1,1); + damping = hslider("v:karplus/h:[0]params/[1]damping[midi:ctrl 1][style:knob]" + ,0.01,0,1,0.01) : si.smoo; + t = button("v:karplus/[1]gate"); + + gate = t+s : min(1); + freq = f*bend; +}; + + +//-------`(pm.)elecGuitarModel`---------- +// A simple electric guitar model (without audio effects, of course) with +// selectable pluck position. +// This model implements a single string. Additional strings should be created +// by making a polyphonic application out of this function. Pitch is changed by +// changing the length of the string and not through a finger model. +// +// #### Usage +// +// ``` +// elecGuitarModel(length,pluckPosition,mute,excitation) : _ +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `mute`: mute coefficient (1 for no mute and 0 for instant mute) +// * `excitation`: excitation signal +//---------------------------------- +elecGuitarModel(length,pluckPosition,mute,excitation) = endChain(egChain) +with{ + maxStringLength = maxLength; + lengthTuning = 0.11; // tuned "by hand" + stringL = length-lengthTuning; + muteBlock = *(mute),*(mute),_; + egChain = chain( + elecGuitarNuts : + openStringPick(stringL,0.05,pluckPosition,excitation) : + muteBlock : + elecGuitarBridge); +}; + + +//-------`(pm.)elecGuitar`---------- +// A simple electric guitar model with steel strings (based on +// [`elecGuitarModel`](#elecguitarmodel)) implementing an excitation +// model. +// This model implements a single string. Additional strings should be created +// by making a polyphonic application out of this function. +// +// #### Usage +// +// ``` +// elecGuitar(length,pluckPosition,trigger) : _ +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `mute`: mute coefficient (1 for no mute and 0 for instant mute) +// * `gain`: gain of the pluck (0-1) +// * `trigger`: trigger signal (1 for on, 0 for off) +//---------------------------------- +elecGuitar(stringLength,pluckPosition,mute,gain,trigger) = +pluckString(stringLength,1,1,1,gain,trigger) : +elecGuitarModel(stringLength,pluckPosition,mute); + + +//-------`(pm.)elecGuitar_ui_MIDI`---------- +// Ready-to-use MIDI-enabled electric guitar physical model with built-in UI. +// +// #### Usage +// +// ``` +// elecGuitar_ui_MIDI : _ +// ``` +//---------------------------------- +elecGuitar_ui_MIDI = elecGuitar(stringLength,pluckPosition,1,gain,gate)*outGain +with{ + f = hslider("v:elecGuitar/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:elecGuitar/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel][style:knob]" + ,0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:elecGuitar/h:[0]midi/[2]gain[style:knob]",0.8,0,1,0.01); + s = hslider("v:elecGuitar/h:[0]midi/[3]sustain[hidden:1] + [midi:ctrl 64][style:knob]",0,0,1,1); + pluckPosition = hslider("v:elecGuitar/[1]pluckPosition[midi:ctrl 1]",0.8,0,1,0.01) : si.smoo; + outGain = hslider("v:elecGuitar/[2]outGain",0.5,0,1,0.01); + t = button("v:elecGuitar/[3]gate"); + gate = t+s : min(1); + freq = f*bend; + stringLength = freq : f2l; +}; + + +//-------`(pm.)guitarBody`---------- +// WARNING: not implemented yet! +// Bidirectional block implementing a simple acoustic guitar body. +// +// #### Usage +// +// ``` +// chain(... : guitarBody) +// ``` +//---------------------------------- +// TODO: not implemented yet +guitarBody = reflectance,transmittance,_ +with{ + transmittance = _; + reflectance = _; +}; + + +//-------`(pm.)guitarModel`---------- +// A simple acoustic guitar model with steel strings and selectable excitation +// position. This model implements a single string. Additional strings should be created +// by making a polyphonic application out of this function. Pitch is changed by +// changing the length of the string and not through a finger model. +// WARNING: this function doesn't currently implement a body (just strings and +// bridge). +// +// #### Usage +// +// ``` +// guitarModel(length,pluckPosition,excitation) : _ +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `excitation`: excitation signal +//---------------------------------- +guitarModel(length,pluckPosition,excitation) = endChain(egChain) +with{ + maxStringLength = maxLength; + lengthTuning = 0.1; // tuned "by hand" + stringL = length-lengthTuning; + egChain = chain(guitarNuts : steelString(stringL,pluckPosition,excitation) : + guitarBridge : guitarBody : out); +}; + + +//-------`(pm.)guitar`---------- +// A simple acoustic guitar model with steel strings (based on +// [`guitarModel`](#guitarmodel)) implementing an excitation model. +// This model implements a single string. Additional strings should be created +// by making a polyphonic application out of this function. +// +// #### Usage +// +// ``` +// guitar(length,pluckPosition,trigger) : _ +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `gain`: gain of the excitation +// * `trigger`: trigger signal (1 for on, 0 for off) +//---------------------------------- +guitar(stringLength,pluckPosition,gain,trigger) = +pluckString(stringLength,1,1.5,1,gain,trigger) : guitarModel(stringLength, pluckPosition); + + +//-------`(pm.)guitar_ui_MIDI`---------- +// Ready-to-use MIDI-enabled steel strings acoustic guitar physical model with +// built-in UI. +// +// #### Usage +// +// ``` +// guitar_ui_MIDI : _ +// ``` +//---------------------------------- +guitar_ui_MIDI = guitar(stringLength,pluckPosition,gain,gate)*outGain +with{ + f = hslider("v:guitar/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:guitar/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:guitar/h:[0]midi/[2]gain[style:knob]",0.8,0,1,0.01); + s = hslider("v:guitar/h:[0]midi/[3]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + pluckPosition = hslider("v:guitar/pluckPosition[midi:ctrl 1]" + ,0.8,0,1,0.01) : si.smoo; + outGain = hslider("v:guitar/outGain",0.5,0,1,0.01); + t = button("v:guitar/[4]gate"); + gate = t+s : min(1); + freq = f*bend; + stringLength = freq : f2l; +}; + + +//-------`(pm.)nylonGuitarModel`---------- +// A simple acoustic guitar model with nylon strings and selectable excitation +// position. This model implements a single string. Additional strings should be created +// by making a polyphonic application out of this function. Pitch is changed by +// changing the length of the string and not through a finger model. +// WARNING: this function doesn't currently implement a body (just strings and +// bridge). +// +// #### Usage +// +// ``` +// nylonGuitarModel(length,pluckPosition,excitation) : _ +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `excitation`: excitation signal +//---------------------------------- +nylonGuitarModel(length,pluckPosition,excitation) = endChain(egChain) +with{ + maxStringLength = maxLength; // meters + lengthTuning = 0.11; + stringL = length-lengthTuning; + egChain = chain(guitarNuts : nylonString(stringL,pluckPosition,excitation) : + guitarBridge : guitarBody : out); +}; + + +//-------`(pm.)nylonGuitar`---------- +// A simple acoustic guitar model with nylon strings (based on +// [`nylonGuitarModel`](#nylonguitarmodel)) implementing an excitation model. +// This model implements a single string. Additional strings should be created +// by making a polyphonic application out of this function. +// +// #### Usage +// +// ``` +// nylonGuitar(length,pluckPosition,trigger) : _ +// ``` +// +// Where: +// +// * `length`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `gain`: gain of the excitation (0-1) +// * `trigger`: trigger signal (1 for on, 0 for off) +//---------------------------------- +nylonGuitar(stringLength,pluckPosition,gain,trigger) = +pluckString(stringLength,1,1.5,1,gain,trigger) : nylonGuitarModel(stringLength, pluckPosition); + + +//-------`(pm.)nylonGuitar_ui_MIDI`---------- +// Ready-to-use MIDI-enabled nylon strings acoustic guitar physical model with +// built-in UI. +// +// #### Usage +// +// ``` +// nylonGuitar_ui_MIDI : _ +// ``` +//---------------------------------- +nylonGuitar_ui_MIDI = nylonGuitar(stringLength,pluckPosition,gain,gate)*outGain +with{ + f = hslider("v:nylonGuitar/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:nylonGuitar/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:nylonGuitar/h:[0]midi/[2]gain[style:knob]",0.8,0,1,0.01); + s = hslider("v:nylonGuitar/h:[0]midi/[3]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + pluckPosition = hslider("v:nylonGuitar/pluckPosition[midi:ctrl 1]" + ,0.8,0,1,0.01) : si.smoo; + outGain = hslider("v:nylonGuitar/outGain",0.5,0,1,0.01); + t = button("v:nylonGuitar/[4]gate"); + gate = t+s : min(1); + freq = f*bend; + stringLength = freq : f2l; +}; + + +//-------`(pm.)modeInterpRes`---------- +// Modular string instrument resonator based on IR measurements made on 3D +// printed models. The 2D space allowing for the control of the shape and the +// scale of the model is enabled by interpolating between modes parameters. +// More information about this technique/project can be found here: +// . +// +// #### Usage +// +// ``` +// _ : modeInterpRes(nModes,x,y) : _ +// ``` +// +// Where: +// +// * `nModes`: number of modeled modes (40 max) +// * `x`: shape of the resonator (0: square, 1: square with rounded corners, 2: round) +// * `y`: scale of the resonator (0: small, 1: medium, 2: large) +//---------------------------------- +modeInterpRes(nModes,x,y) = _ <: par(i,min(40,nModes),modeFilter(modeFreq(i),modeT60(i),modeGain(i))) :> /(nModes) +with{ + // modes parameters + roundBigCenterFreq(i) = ba.take(i+1,(286.134404,476.384455,602.872587,831.823345,862.773611,1024.985313,1209.932428,1515.548598,1777.819591,2001.806241,2674.135433,3154.282144,3329.555657,3431.385589,3673.656995,4228.801853,4389.842060,4552.745406,4766.151594,4854.354993,4970.516137,5064.203325,5200.399916,5347.650831,5459.807495,5630.144253,5870.258034,6121.961406,6244.522341,6677.052569,7233.100711,7520.031251,7677.902736,7805.138717,9918.905945,10418.988301,11296.101954,11432.719867,13422.238365,13679.232778)); + roundBigCenterGain(i) = ba.take(i+1,(1.000000,0.609711,0.222375,0.025505,0.026108,0.026840,0.605767,0.368186,0.093526,0.016656,0.159600,0.013836,0.044000,0.023103,0.107971,0.013696,0.043615,0.039848,0.041903,0.043671,0.055018,0.041730,0.062832,0.030464,0.028049,0.012880,0.047154,0.084707,0.050532,0.032735,0.031938,0.023554,0.017534,0.017268,0.026202,0.013725,0.015611,0.021294,0.011486,0.011875)); + roundBigCenterT60(i) = ba.take(i+1,(0.283544,0.076723,0.287423,0.058391,0.075172,0.120794,0.131540,0.081173,0.088549,0.034991,0.060237,0.014153,0.074709,0.068893,0.033354,0.032013,0.019088,0.020992,0.026703,0.018040,0.015815,0.016671,0.028732,0.017929,0.021520,0.024622,0.022706,0.023138,0.027323,0.020556,0.024577,0.023669,0.024714,0.024420,0.017733,0.017881,0.018715,0.017737,0.015660,0.016464)); + roundMidCenterFreq(i) = ba.take(i+1,(380.910663,615.862831,933.855656,1128.769825,1231.353452,1404.948092,1764.641239,2095.586536,2451.220548,2566.435588,2781.467120,2946.757398,3522.047891,3748.375254,3892.352583,4340.896246,4454.851770,4629.302932,4806.417393,5024.545475,5604.684752,5671.112515,6533.147087,6751.949816,6862.781990,6951.226279,7180.863112,7901.631311,8074.662174,8979.395914,10075.249374,10521.350963,11964.859921,14227.213322,15501.455250,15587.852956,16290.138756,16418.172746,16663.266694,17991.614994)); + roundMidCenterGain(i) = ba.take(i+1,(1.000000,0.437495,0.110598,0.025858,0.010841,0.022400,0.245241,0.187990,0.029650,0.058174,0.007035,0.013188,0.009767,0.059284,0.160848,0.007463,0.016816,0.008689,0.031644,0.045608,0.019773,0.018546,0.013495,0.018482,0.020130,0.015417,0.031109,0.007624,0.008526,0.032539,0.009846,0.007605,0.019866,0.007583,0.008991,0.009194,0.010128,0.008557,0.009333,0.007494)); + roundMidCenterT60(i) = ba.take(i+1,(0.193654,0.076056,0.197517,0.019475,0.043087,0.063829,0.074308,0.059791,0.082616,0.081949,0.042855,0.036140,0.068564,0.041711,0.043799,0.025988,0.057494,0.028353,0.018586,0.018651,0.025380,0.021250,0.019217,0.016326,0.019469,0.020754,0.019487,0.019590,0.011348,0.015969,0.015674,0.016305,0.026772,0.010597,0.009926,0.007595,0.008676,0.008274,0.011471,0.012424)); + roundSmallCenterFreq(i) = ba.take(i+1,(511.119501,860.897453,977.675690,1245.454667,1408.823199,1604.478891,1825.857776,1960.985105,2340.204377,2594.337460,2700.041698,3277.766643,3388.510632,3505.100505,4151.457765,4257.308449,4425.319123,4526.878869,4629.688075,4819.012204,5493.628166,6323.383769,6514.513248,6709.979636,6823.104590,7009.748398,7198.916858,9019.248381,9492.252653,9706.451249,9858.889433,10080.422278,10252.000811,10389.864946,12327.892342,12465.475093,13491.187794,15072.291233,15176.746743,20143.302052)); + roundSmallCenterGain(i) = ba.take(i+1,(1.000000,0.686570,0.362616,0.178685,0.113981,0.158727,0.024067,0.023659,0.085113,0.192224,0.174412,0.160279,0.042275,0.042204,0.027219,0.040505,0.064866,0.069074,0.029473,0.033054,0.055311,0.073694,0.071341,0.068366,0.026735,0.037359,0.026008,0.025958,0.025327,0.052859,0.082911,0.038156,0.046079,0.034839,0.022738,0.024480,0.158056,0.026848,0.028009,0.031387)); + roundSmallCenterT60(i) = ba.take(i+1,(0.200041,0.030199,0.050855,0.020135,0.020101,0.026910,0.043249,0.040814,0.058128,0.047490,0.051189,0.069063,0.047344,0.049448,0.024720,0.027275,0.028407,0.030171,0.026606,0.030289,0.040772,0.023856,0.020889,0.032859,0.027543,0.026427,0.032154,0.020576,0.032990,0.019344,0.019827,0.018571,0.017213,0.019002,0.020440,0.021329,0.023027,0.018833,0.018344,0.018811)); + semBigCenterFreq(i) = ba.take(i+1,(318.812824,545.646717,727.103717,813.406232,938.026296,1067.472803,1239.311077,1478.409235,1567.366603,1840.215865,2162.299536,2302.660906,2394.006715,2499.397129,2724.662564,2876.713036,3051.447083,3219.116214,3378.667296,3507.736722,3687.907343,3827.904993,4039.858029,4208.742422,4385.651803,4574.818448,4744.136436,4866.893882,5090.532579,5200.283111,5448.339367,5751.719886,6040.059676,6500.665192,6780.883377,6878.732474,7127.463954,7701.025454,10337.623684,17411.019601)); + semBigCenterGain(i) = ba.take(i+1,(1.000000,0.386065,0.297923,0.235171,0.346593,0.219093,0.050655,0.310031,0.175387,0.180464,0.064716,0.070721,0.027399,0.076973,0.086367,0.024188,0.100553,0.028776,0.027974,0.040200,0.031680,0.021694,0.035362,0.031821,0.027726,0.037219,0.026308,0.016164,0.022938,0.046669,0.031128,0.027430,0.032404,0.018356,0.026887,0.041003,0.012779,0.028785,0.013346,0.017281)); + semBigCenterT60(i) = ba.take(i+1,(0.195061,0.269748,0.108389,0.132557,0.127125,0.113759,0.159514,0.058527,0.067333,0.071996,0.067001,0.054194,0.052818,0.050935,0.045373,0.051611,0.051410,0.061272,0.050844,0.029415,0.021966,0.023483,0.022866,0.023418,0.033572,0.026764,0.017334,0.021394,0.025984,0.026146,0.018801,0.018242,0.022440,0.020939,0.011937,0.011739,0.020314,0.013848,0.016504,0.085830)); + semMidCenterFreq(i) = ba.take(i+1,(316.511541,548.598445,682.927606,764.088220,1145.795222,1280.068992,1524.562996,1677.146625,2083.900770,2285.783756,2452.226740,2779.274140,3196.405966,3569.262928,3798.251779,4071.264178,4413.799330,4550.364404,4966.398087,5156.799448,5363.124121,5611.038360,5995.650074,6162.624225,6583.973014,7029.525719,7207.893991,7706.775019,7844.032020,10298.804956,10564.531850,11615.688447,12056.168362,12661.205157,12876.405687,13082.890228,13851.437211,14452.383106,15683.910228,16667.950883)); + semMidCenterGain(i) = ba.take(i+1,(0.999641,0.798181,0.200080,0.280473,0.042761,0.079955,0.286673,0.162652,1.000000,0.309945,0.097527,0.023964,0.124529,0.155314,0.075600,0.178980,0.089168,0.134962,0.120730,0.036885,0.024020,0.102628,0.085255,0.059439,0.023339,0.027443,0.141618,0.044053,0.024269,0.046682,0.034465,0.068930,0.070502,0.025912,0.076088,0.024972,0.038501,0.051135,0.027801,0.022469)); + semMidCenterT60(i) = ba.take(i+1,(0.210670,0.062329,0.097470,0.136802,0.077790,0.025877,0.054632,0.060485,0.061625,0.061352,0.060614,0.030867,0.039440,0.030054,0.037956,0.030948,0.046137,0.045345,0.025326,0.025515,0.022514,0.043142,0.018663,0.015057,0.052844,0.016478,0.025993,0.017880,0.014006,0.022971,0.017720,0.032173,0.015391,0.009217,0.028936,0.011895,0.012607,0.018141,0.018341,0.018180)); + semSmallCenterFreq(i) = ba.take(i+1,(440.578370,637.619026,828.182637,978.279267,1088.401911,1321.315700,1648.932125,1817.216790,1938.686740,2173.897496,2450.967026,2582.312643,2748.003128,2858.292897,2973.003533,3235.482621,3348.561906,3496.046199,3706.507771,3934.307821,4418.408376,5239.069796,5428.018005,5771.733971,6106.378549,6304.512786,6788.234913,6905.001294,7054.694449,7227.988097,7348.344488,8450.449049,9000.316477,10930.327581,11271.451255,11418.301881,13448.385700,13938.733921,14334.394664,17413.449273)); + semSmallCenterGain(i) = ba.take(i+1,(1.000000,0.297197,0.715097,0.178811,0.229363,0.183731,0.107685,0.120764,0.060436,0.503361,0.352264,0.056432,0.042926,0.090906,0.224894,0.128151,0.257120,0.076416,0.096971,0.078669,0.065573,0.057421,0.085378,0.085397,0.050578,0.046534,0.213480,0.090142,0.078632,0.089706,0.276299,0.061182,0.038941,0.045447,0.043447,0.051347,0.055647,0.071836,0.040813,0.066853)); + semSmallCenterT60(i) = ba.take(i+1,(0.136710,0.070656,0.049965,0.034104,0.023973,0.032990,0.049605,0.026798,0.024777,0.040671,0.039262,0.035240,0.019214,0.053001,0.045917,0.045864,0.048770,0.040981,0.020747,0.022565,0.031089,0.026788,0.013828,0.023917,0.022485,0.035319,0.017955,0.014831,0.018902,0.014661,0.032984,0.027729,0.025067,0.021211,0.016910,0.027488,0.013164,0.012325,0.019985,0.079428)); + squareBigCenterFreq(i) = ba.take(i+1,(222.231629,336.343611,555.041069,772.219662,911.261442,1096.774273,1203.102824,1404.011001,1540.420421,1628.944840,1994.925663,2197.106949,2533.354244,2672.470165,2821.185962,2967.436266,3342.189608,3479.723368,3631.705350,3806.882908,3910.078404,4173.779128,4292.901543,4519.288440,4631.053559,4855.405142,5079.828139,5182.392108,5328.291818,5636.817979,5983.629129,6104.013800,6184.547942,6602.614840,6718.247643,6835.844044,6882.254514,7220.774814,7283.263950,7407.672066)); + squareBigCenterGain(i) = ba.take(i+1,(0.581227,1.000000,0.167366,0.663184,0.127173,0.141424,0.232076,0.043454,0.168681,0.244908,0.193343,0.147543,0.062214,0.112585,0.383899,0.053139,0.104651,0.093521,0.029220,0.027646,0.020979,0.031887,0.052610,0.045000,0.023542,0.049426,0.029063,0.049062,0.015097,0.030925,0.032215,0.032146,0.050862,0.016861,0.019228,0.021428,0.021039,0.016988,0.017971,0.033065)); + squareBigCenterT60(i) = ba.take(i+1,(0.417113,0.247980,0.103791,0.131234,0.194764,0.130569,0.119615,0.103862,0.102785,0.079975,0.068871,0.120830,0.066401,0.064964,0.037272,0.057999,0.038435,0.036927,0.036970,0.069147,0.036096,0.049136,0.046268,0.029452,0.025066,0.020942,0.040527,0.027374,0.030986,0.019875,0.028632,0.032344,0.033709,0.024938,0.063833,0.032297,0.028473,0.025768,0.024877,0.026385)); + squareMidCenterFreq(i) = ba.take(i+1,(306.243391,426.381556,523.626577,637.813655,855.576390,992.200454,1098.863347,1226.922784,1545.950522,1704.776255,1839.163057,1983.832482,2190.814571,2445.409860,2672.907579,2782.642755,2983.850376,3268.313978,3458.038380,3590.850048,3783.143602,4123.002328,4250.310528,4408.442518,4531.916055,4865.211680,5248.660726,5387.011592,5780.593786,5880.954673,6095.291499,6432.605387,6596.403501,6820.917687,6907.055108,7030.829711,7337.883035,7602.739152,7926.836412,12248.346109)); + squareMidCenterGain(i) = ba.take(i+1,(1.000000,0.292592,0.554710,0.359595,0.041223,0.283249,0.182057,0.078666,0.898203,0.105021,0.037156,0.128493,0.302569,0.134081,0.090181,0.116704,0.041711,0.268207,0.079651,0.034128,0.296838,0.051959,0.124454,0.077586,0.084915,0.126202,0.019697,0.017643,0.077301,0.068367,0.023764,0.015924,0.022163,0.017954,0.029917,0.021449,0.019083,0.026076,0.017965,0.017018)); + squareMidCenterT60(i) = ba.take(i+1,(0.236061,0.179001,0.084440,0.165197,0.083836,0.055543,0.067029,0.054547,0.046195,0.055390,0.052760,0.079021,0.073765,0.059744,0.071780,0.050510,0.036326,0.036162,0.039268,0.031777,0.037990,0.072567,0.045824,0.026516,0.027684,0.034229,0.040867,0.037800,0.026894,0.023151,0.023381,0.021277,0.023057,0.020207,0.019672,0.016358,0.024757,0.017036,0.016600,0.010195)); + squareSmallCenterFreq(i) = ba.take(i+1,(375.008194,527.945584,775.002560,981.584262,1125.203834,1287.701398,1394.790058,1577.138666,1727.825366,1860.700270,1950.809059,2020.169063,2185.798879,2382.343983,2587.140759,2792.652735,2970.443881,3047.515682,3332.695227,3416.636119,3513.876416,3994.492272,4128.261485,4247.828681,4425.131019,4686.893838,4731.141754,5553.904972,5702.206389,6415.071752,6552.422900,6785.461423,6990.104471,7256.116515,7884.508530,8787.479467,10529.849261,10641.861836,12075.018006,17405.170359)); + squareSmallCenterGain(i) = ba.take(i+1,(0.991070,1.000000,0.515946,0.549911,0.115279,0.157813,0.463743,0.206985,0.131491,0.244054,0.160114,0.116274,0.161678,0.048839,0.071332,0.072482,0.097678,0.083415,0.057484,0.059259,0.034662,0.064479,0.061452,0.110522,0.045770,0.053318,0.051225,0.034998,0.051538,0.081127,0.039422,0.226011,0.053013,0.052620,0.041956,0.058147,0.061262,0.046118,0.038256,0.124151)); + squareSmallCenterT60(i) = ba.take(i+1,(0.102256,0.088069,0.026433,0.131998,0.050149,0.052897,0.066531,0.060621,0.045315,0.047413,0.058375,0.059098,0.029950,0.018537,0.024086,0.032984,0.036868,0.032205,0.023710,0.023430,0.015516,0.022773,0.025265,0.028872,0.019743,0.036565,0.032704,0.025234,0.028383,0.018356,0.018609,0.017534,0.018699,0.015762,0.022800,0.013151,0.012300,0.018114,0.013192,0.085670)); + + // computing modes freq in function of x and y + modeFreq(i) = zxd + (zxu-zxd)*select2(y<1,(y-1),y) + with{ + zx0 = squareSmallCenterFreq(i) + (semSmallCenterFreq(i)-squareSmallCenterFreq(i))*x; + zx1 = semSmallCenterFreq(i) + (roundSmallCenterFreq(i)-semSmallCenterFreq(i))*(x-1); + zx2 = squareMidCenterFreq(i) + (semMidCenterFreq(i)-squareMidCenterFreq(i))*x; + zx3 = semMidCenterFreq(i) + (roundMidCenterFreq(i)-semMidCenterFreq(i))*(x-1); + zx4 = squareBigCenterFreq(i) + (semBigCenterFreq(i)-squareBigCenterFreq(i))*x; + zx5 = semBigCenterFreq(i) + (roundBigCenterFreq(i)-semBigCenterFreq(i))*(x-1); + zxd = select2(y<1,select2(x<1,zx3,zx2),select2(x<1,zx1,zx0)); + zxu = select2(y<1,select2(x<1,zx5,zx4),select2(x<1,zx3,zx2)); + }; + + // computing modes gain in function of x and y + modeGain(i) = zxd + (zxu-zxd)*select2(y<1,(y-1),y) + with{ + zx0 = squareSmallCenterGain(i) + (semSmallCenterGain(i)-squareSmallCenterGain(i))*x; + zx1 = semSmallCenterGain(i) + (roundSmallCenterGain(i)-semSmallCenterGain(i))*(x-1); + zx2 = squareMidCenterGain(i) + (semMidCenterGain(i)-squareMidCenterGain(i))*x; + zx3 = semMidCenterGain(i) + (roundMidCenterGain(i)-semMidCenterGain(i))*(x-1); + zx4 = squareBigCenterGain(i) + (semBigCenterGain(i)-squareBigCenterGain(i))*x; + zx5 = semBigCenterGain(i) + (roundBigCenterGain(i)-semBigCenterGain(i))*(x-1); + zxd = select2(y<1,select2(x<1,zx3,zx2),select2(x<1,zx1,zx0)); + zxu = select2(y<1,select2(x<1,zx5,zx4),select2(x<1,zx3,zx2)); + }; + + // computing modes T60 in function of x and y + modeT60(i) = zxd + (zxu-zxd)*select2(y<1,(y-1),y) //: min(0.1) + with{ + zx0 = squareSmallCenterT60(i) + (semSmallCenterT60(i)-squareSmallCenterT60(i))*x; + zx1 = semSmallCenterT60(i) + (roundSmallCenterT60(i)-semSmallCenterT60(i))*(x-1); + zx2 = squareMidCenterT60(i) + (semMidCenterT60(i)-squareMidCenterT60(i))*x; + zx3 = semMidCenterT60(i) + (roundMidCenterT60(i)-semMidCenterT60(i))*(x-1); + zx4 = squareBigCenterT60(i) + (semBigCenterT60(i)-squareBigCenterT60(i))*x; + zx5 = semBigCenterT60(i) + (roundBigCenterT60(i)-semBigCenterT60(i))*(x-1); + zxd = select2(y<1,select2(x<1,zx3,zx2),select2(x<1,zx1,zx0)); + zxu = select2(y<1,select2(x<1,zx5,zx4),select2(x<1,zx3,zx2)); + }; +}; + + +//-------`(pm.)modularInterpBody`---------- +// Bidirectional block implementing a modular string instrument resonator +// (see [`modeInterpRes`](#pm.modeinterpres)). +// +// #### Usage +// +// ``` +// chain(... : modularInterpBody(nModes,shape,scale) : ...) +// ``` +// +// Where: +// +// * `nModes`: number of modeled modes (40 max) +// * `shape`: shape of the resonator (0: square, 1: square with rounded corners, 2: round) +// * `scale`: scale of the resonator (0: small, 1: medium, 2: large) +//---------------------------------- +modularInterpBody(nModes,shape,scale) = _,modeInterpRes(nModes,shape,scale),_; + + +//-------`(pm.)modularInterpStringModel`---------- +// String instrument model with a modular body (see +// [`modeInterpRes`](#pm.modeinterpres) and +// ). +// +// #### Usage +// +// ``` +// modularInterpStringModel(length,pluckPosition,shape,scale,bodyExcitation,stringExcitation) : _ +// ``` +// +// Where: +// +// * `stringLength`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `shape`: shape of the resonator (0: square, 1: square with rounded corners, 2: round) +// * `scale`: scale of the resonator (0: small, 1: medium, 2: large) +// * `bodyExcitation`: excitation signal for the body +// * `stringExcitation`: excitation signal for the string +//---------------------------------- +modularInterpStringModel(stringLength,pluckPosition,shape,scale,bodyExcitation,stringExcitation) = endChain(egChain)*0.5 +with{ + maxStringLength = maxLength; + lengthTuning = 0.1; // tuned "by hand" + stringL = stringLength-lengthTuning; + nBodyModes = 40; + egChain = chain(guitarNuts : steelString(stringL,pluckPosition,stringExcitation) : + guitarBridge : inRightWave(bodyExcitation) : modularInterpBody(nBodyModes,shape,scale) : out); +}; + + +//-------`(pm.)modularInterpInstr`---------- +// String instrument with a modular body (see +// [`modeInterpRes`](#pm.modeinterpres) and +// ). +// +// #### Usage +// +// ``` +// modularInterpInstr(stringLength,pluckPosition,shape,scale,gain,tapBody,triggerString) : _ +// ``` +// +// Where: +// +// * `stringLength`: the length of the string in meters +// * `pluckPosition`: pluck position (0-1) (1 is on the bridge) +// * `shape`: shape of the resonator (0: square, 1: square with rounded corners, 2: round) +// * `scale`: scale of the resonator (0: small, 1: medium, 2: large) +// * `gain`: of the string excitation +// * `tapBody`: send an impulse in the body of the instrument where the string is connected (1 for on, 0 for off) +// * `triggerString`: trigger signal for the string (1 for on, 0 for off) +//---------------------------------- +modularInterpInstr(stringLength,pluckPosition,shape,scale,gain,tapBody,triggerString) = +(tapBody : ba.impulsify), pluckString(stringLength,1,1,1,gain,triggerString) : +modularInterpStringModel(stringLength,pluckPosition,shape,scale); + + +//-------`(pm.)modularInterpInstr_ui_MIDI`---------- +// Ready-to-use MIDI-enabled string instrument with a modular body (see +// [`modeInterpRes`](#pm.modeinterpres) and +// ) +// with built-in UI. +// +// #### Usage +// +// ``` +// modularInterpInstr_ui_MIDI : _ +// ``` +//---------------------------------- +modularInterpInstr_ui_MIDI = modularInterpInstr(stringLength,pluckPosition,shape,scale,gain,tapBody,gate)*outGain +with{ + f = hslider("v:modularInterpInstr/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:modularInterpInstr/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:modularInterpInstr/h:[0]midi/[2]gain[style:knob]",0.8,0,1,0.01); + s = hslider("v:modularInterpInstr/h:[0]midi/[3]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + shape = hslider("v:modularInterpInstr/h:[1]body/[0]shape[style:knob]",0,0,1,0.01)*2; + scale = hslider("v:modularInterpInstr/h:[1]body/[1]scale[style:knob]",0,0,1,0.011)*2; + tapBody = button("v:modularInterpInstr/h:[1]body/[2]tapBody"); + pluckPosition = hslider("v:modularInterpInstr/[2]pluckPosition[midi:ctrl 1]" + ,0.8,0,1,0.01) : si.smoo; + outGain = hslider("v:modularInterpInstr/[3]outGain",0.5,0,1,0.01); + t = button("v:modularInterpInstr/[4]gate"); + gate = t+s : min(1); + freq = f*bend; + stringLength = freq : f2l; +}; + + +//=============================Bowed String Instruments=================================== +// Low and high level basic string instruments parts. Most of the elements in +// this section can be used in a bidirectional chain. +//======================================================================================== + +//-------`(pm.)bowTable`---------- +// Extremely basic bow table that can be used to implement a wide range of +// bow types for many different bowed string instruments (violin, cello, etc.). +// +// #### Usage +// +// ``` +// excitation : bowTable(offeset,slope) : _ +// ``` +// +// Where: +// +// * `excitation`: an excitation signal +// * `offset`: table offset +// * `slope`: table slope +//---------------------------------- +bowTable(offset,slope) = pow(abs(sample) + 0.75, -4) : min(1) +with{ + sample = +(offset)*slope; +}; + + +//-------`(pm.)violinBowTable`---------- +// Violin bow table based on [`bowTable`](#bowtable). +// +// #### Usage +// +// ``` +// bowVelocity : violinBowTable(bowPressure) : _ +// ``` +// +// Where: +// +// * `bowVelocity`: velocity of the bow/excitation signal (0-1) +// * `bowPressure`: bow pressure on the string (0-1) +//---------------------------------- +violinBowTable(bowPressure) = bowTable(0,tableSlope) +with{ + tableSlope = 5 - (4*bowPressure); +}; + + +//-------`(pm.)bowInteraction`---------- +// Bidirectional block implementing the interaction of a bow in a +// [`chain`](#chain). +// +// #### Usage +// +// ``` +// chain(... : stringSegment : bowInteraction(bowTable) : stringSegment : ...) +// ``` +// +// Where: +// +// * `bowTable`: the bow table +//---------------------------------- +bowInteraction(b) = (_,_ <: b,_,_ :> _,_),_; + + +//-------`(pm.)violinBow`---------- +// Bidirectional block implementing a violin bow and its interaction with +// a string. +// +// #### Usage +// +// ``` +// chain(... : stringSegment : violinBow(bowPressure,bowVelocity) : stringSegment : ...) +// ``` +// +// Where: +// +// * `bowVelocity`: velocity of the bow / excitation signal (0-1) +// * `bowPressure`: bow pressure on the string (0-1) +//---------------------------------- +violinBow(bowPressure,bowVelocity) = bowInteraction(bowSystem) +with{ + bowSystem = + : bowVelocity-_ <: *(violinBowTable(bowPressure)) <: _,_; +}; + + +//-------`(pm.)violinBowedString`---------- +// Violin bowed string bidirectional block with controllable bow position. +// Terminations are not implemented in this model. +// +// #### Usage +// +// ``` +// chain(nuts : violinBowedString(stringLength,bowPressure,bowVelocity,bowPosition) : bridge) +// ``` +// +// Where: +// +// * `stringLength`: the length of the string in meters +// * `bowVelocity`: velocity of the bow / excitation signal (0-1) +// * `bowPressure`: bow pressure on the string (0-1) +// * `bowPosition`: the position of the bow on the string (0-1) +//---------------------------------- +violinBowedString(stringLength,bowPressure,bowVelocity,bowPosition) = + chain( + stringSegment(maxStringLength,ntbd) : + violinBow(bowPressure,bowVelocity) : + stringSegment(maxStringLength,btbd) + ) + with{ + maxStringLength = maxLength; + ntbd = stringLength*bowPosition; // upper portion of the string length + btbd = stringLength*(1-bowPosition); // lower portion of the string length + }; + + +//-------`(pm.)violinNuts`---------- +// Bidirectional block implementing simple violin nuts. This function is +// based on [`bridgeFilter`](#bridgefilter). +// +// #### Usage +// +// ``` +// chain(violinNuts : stringSegment : ...) +// ``` +//---------------------------------- +violinNuts = lTermination(-bridgeFilter(0.6,0.1),basicBlock); + + +//-------`(pm.)violinBridge`---------- +// Bidirectional block implementing a simple violin bridge. This function is +// based on [`bridgeFilter`](#bridgefilter). +// +// #### Usage +// +// ``` +// chain(... : stringSegment : violinBridge +// ``` +//---------------------------------- +// TODO: +// * reflectance is not implemented yet +violinBridge = rTermination(basicBlock,reflectance) : _,transmittance,_ +with{ + reflectance = -bridgeFilter(0.2,0.9); + transmittance = _; +}; + + +//-------`(pm.)violinBody`---------- +// Bidirectional block implementing a simple violin body (just a simple +// resonant lowpass filter). +// +// #### Usage +// +// ``` +// chain(... : stringSegment : violinBridge : violinBody) +// ``` +//---------------------------------- +// TODO: +// * reflectance is not implemented yet +violinBody = reflectance,transmittance,_ +with{ + transmittance = fi.resonbp(500,2,1); + reflectance = _; +}; + + +//-------`(pm.)violinModel`---------- +// Ready-to-use simple violin physical model. This model implements a single +// string. Additional strings should be created +// by making a polyphonic application out of this function. Pitch is changed +// by changing the length of the string (and not through a finger model). +// +// #### Usage +// +// ``` +// violinModel(stringLength,bowPressure,bowVelocity,bridgeReflexion, +// bridgeAbsorption,bowPosition) : _ +// ``` +// +// Where: +// +// * `stringLength`: the length of the string in meters +// * `bowVelocity`: velocity of the bow / excitation signal (0-1) +// * `bowPressure`: bow pressure on the string (0-1)) +// * `bowPosition`: the position of the bow on the string (0-1) +//---------------------------------- +violinModel(stringLength,bowPressure,bowVelocity,bowPosition) = + endChain(modelChain) +with{ + stringTuning = 0.08; + stringL = stringLength-stringTuning; + modelChain = chain( + violinNuts : + violinBowedString(stringL,bowPressure,bowVelocity,bowPosition) : + violinBridge : + violinBody : + out + ); +}; + + +//-------`(pm.)violin_ui`---------- +// Ready-to-use violin physical model with built-in UI. +// +// #### Usage +// +// ``` +// violinModel_ui : _ +// ``` +//---------------------------------- +violin_ui = violinModel(stringLength,bowPress,bowVel,bowPos)*outGain +with{ + stringLength = hslider("v:violin/v:[0]string/[0]length",0.75,0,2,0.01) : si.smoo; + bowVel = hslider("v:violin/v:[1]bow/[0]velocity",0,0,1,0.01) : si.smoo; + bowPress = hslider("v:violin/v:[1]bow/[1]pressure",0.5,0,1,0.01) : si.smoo; + bowPos = hslider("v:violin/v:[1]bow/[2]position",0.7,0,1,0.01) : si.smoo; + outGain = hslider("v:violin/outGain",0.5,0,1,0.01); +}; + + +//-------`(pm.)violin_ui_MIDI`---------- +// Ready-to-use MIDI-enabled violin physical model with built-in UI. +// +// #### Usage +// +// ``` +// violin_ui_MIDI : _ +// ``` +//---------------------------------- +violin_ui_MIDI = violinModel(stringLength,bowPress,bowVel,bowPos)*outGain +with{ + f = hslider("v:violin/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:violin/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:violin/h:[0]midi/[2]gain[style:knob] + ",0.6,0,1,0.01); + envAttack = hslider("v:violin/h:[0]midi/[3]envAttack[style:knob] + ",1,0,30,0.01)*0.001; + s = hslider("v:violin/h:[0]midi/[4]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + bowPress = hslider("v:violin/h:[1]bow/[0]pressure[style:knob] + [midi:ctrl 1]",0.5,0,1,0.01) : si.smoo; + bowPos = hslider("v:violin/h:[1]bow/[1]position[style:knob] + ",0.7,0,1,0.01) : si.smoo; + vibratoFreq = hslider("v:violin/h:[2]otherParams/[0]vibratoFrequency + [style:knob]",6,1,10,0.01); + vibratoGain = hslider("v:violin/h:[2]otherParams/[1]vibratoGain + [style:knob]",0.5,0,1,0.01)*0.01; + outGain = hslider("v:violin/h:[2]otherParams/[2]outGain[style:knob] + ",0.5,0,1,0.01); + t = button("v:violin/[3]gate"); + + gate = t+s : min(1); + vibrato = 1+os.osc(vibratoFreq)*vibratoGain*envelope; + freq = f*bend*vibrato; + envelope = gate*gain : si.smooth(ba.tau2pole(envAttack)); + + stringLength = freq : f2l; + bowVel = envelope; +}; + + +//=================================Wind Instruments======================================= +// Low and high level basic wind instruments parts. Most of the elements in +// this section can be used in a bidirectional chain. +//======================================================================================== + +//-------`(pm.)openTube`---------- +// A tube segment without terminations (same as [`stringSegment`](#stringsegment)). +// +// #### Usage +// +// ``` +// chain(A : openTube(maxLength,length) : B) +// ``` +// +// Where: +// +// * `maxLength`: the maximum length of the tube in meters (should be static) +// * `length`: the length of the tube in meters +//---------------------------------- +openTube = stringSegment; + + +//-------`(pm.)reedTable`---------- +// Extremely basic reed table that can be used to implement a wide range of +// single reed types for many different instruments (saxophone, clarinet, etc.). +// +// #### Usage +// +// ``` +// excitation : reedTable(offeset,slope) : _ +// ``` +// +// Where: +// +// * `excitation`: an excitation signal +// * `offset`: table offset +// * `slope`: table slope +//---------------------------------- +reedTable(offset,slope) = reedTable : min(1) : max(-1) +with { + reedTable = *(slope) + offset; +}; + + +//-------`(pm.)fluteJetTable`---------- +// Extremely basic flute jet table. +// +// #### Usage +// +// ``` +// excitation : fluteJetTable : _ +// ``` +// +// Where: +// +// * `excitation`: an excitation signal +//---------------------------------- +fluteJetTable = _ <: *(* : -(1)) : clipping +with{ + clipping = min(1) : max(-1); +}; + + +//-------`(pm.)brassLipsTable`---------- +// Simple brass lips/mouthpiece table. Since this implementation is very basic +// and that the lips and tube of the instrument are coupled to each other, the +// length of that tube must be provided here. +// +// #### Usage +// +// ``` +// excitation : brassLipsTable(tubeLength,lipsTension) : _ +// ``` +// +// Where: +// +// * `excitation`: an excitation signal (can be DC) +// * `tubeLength`: length in meters of the tube connected to the mouthpiece +// * `lipsTension`: tension of the lips (0-1) (default: 0.5) +//---------------------------------- +brassLipsTable(tubeLength,lipsTension) = *(0.03) : lipFilter <: * : clipping +with{ + clipping = min(1) : max(-1); + freq = (tubeLength : l2f)*pow(4,(2*lipsTension)-1); + filterR = 0.997; + a1 = -2*filterR*cos(ma.PI*2*freq/ma.SR); + lipFilter = fi.tf2(1,0,0,a1,pow(filterR,2)); // resonance with same freq as tube +}; + + +//-------`(pm.)clarinetReed`---------- +// Clarinet reed based on [`reedTable`](#reedtable) with controllable +// stiffness. +// +// #### Usage +// +// ``` +// excitation : clarinetReed(stiffness) : _ +// ``` +// +// Where: +// +// * `excitation`: an excitation signal +// * `stiffness`: reed stiffness (0-1) +//---------------------------------- +clarinetReed(stiffness) = reedTable(0.7,tableSlope) +with{ + tableSlope = -0.44 + 0.26*stiffness; +}; + + +//-------`(pm.)clarinetMouthPiece`---------- +// Bidirectional block implementing a clarinet mouthpiece as well as the various +// interactions happening with traveling waves. This element is ready to be +// plugged to a tube... +// +// #### Usage +// +// ``` +// chain(clarinetMouthPiece(reedStiffness,pressure) : tube : etc.) +// ``` +// +// Where: +// +// * `pressure`: the pressure of the air flow (DC) created by the virtual performer (0-1). +// This can also be any kind of signal that will directly injected in the mouthpiece +// (e.g., breath noise, etc.). +// * `reedStiffness`: reed stiffness (0-1) +//---------------------------------- +clarinetMouthPiece(reedStiffness,pressure) = lTermination(reedInteraction,in(pressure)) +with{ + reedInteraction = *(-1) <: *(clarinetReed(reedStiffness)); +}; + + +//-------`(pm.)brassLips`---------- +// Bidirectional block implementing a brass mouthpiece as well as the various +// interactions happening with traveling waves. This element is ready to be +// plugged to a tube... +// +// #### Usage +// +// ``` +// chain(brassLips(tubeLength,lipsTension,pressure) : tube : etc.) +// ``` +// +// Where: +// +// * `tubeLength`: length in meters of the tube connected to the mouthpiece +// * `lipsTension`: tension of the lips (0-1) (default: 0.5) +// * `pressure`: the pressure of the air flow (DC) created by the virtual performer (0-1). +// This can also be any kind of signal that will directly injected in the mouthpiece +// (e.g., breath noise, etc.). +//---------------------------------- +brassLips(tubeLength,lipsTension,pressure) = lTermination(mpInteraction,basicBlock) +with{ + absorption = *(0.85); // absorption coefficient + p = pressure*0.3; // scaling pressure + mpInteraction = absorption <: + (p-_ : brassLipsTable(tubeLength,lipsTension) <: *(p),1-_),_ : _,* : + : fi.dcblocker; +}; + + +//-------`(pm.)fluteEmbouchure`---------- +// Bidirectional block implementing a flute embouchure as well as the various +// interactions happening with traveling waves. This element is ready to be +// plugged between tubes segments... +// +// #### Usage +// +// ``` +// chain(... : tube : fluteEmbouchure(pressure) : tube : etc.) +// ``` +// +// Where: +// +// * `pressure`: the pressure of the air flow (DC) created by the virtual +// performer (0-1). +// This can also be any kind of signal that will directly injected in the +// mouthpiece (e.g., breath noise, etc.). +//---------------------------------- +fluteEmbouchure(pressure) = +(_ <: _,_),_,_ : _,*(0.5)+(pressure-_*0.5 : fluteJetTable),_; + + +//-------`(pm.)wBell`---------- +// Generic wind instrument bell bidirectional block that should be placed at +// the end of a [`chain`](#chain). +// +// #### Usage +// +// ``` +// chain(... : wBell(opening)) +// ``` +// +// Where: +// +// * `opening`: the "opening" of bell (0-1) +//---------------------------------- +wBell(opening) = rTermination(basicBlock,si.smooth(opening)); + + +//-------`(pm.)fluteHead`---------- +// Simple flute head implementing waves reflexion. +// +// #### Usage +// +// ``` +// chain(fluteHead : tube : ...) +// ``` +//---------------------------------- +fluteHead = lTermination(*(absorption),basicBlock) +with{ + absorption = 0.95; // same as for foot +}; + + +//-------`(pm.)fluteFoot`---------- +// Simple flute foot implementing waves reflexion and dispersion. +// +// #### Usage +// +// ``` +// chain(... : tube : fluteFoot) +// ``` +//---------------------------------- +fluteFoot = rTermination(basicBlock,*(absorption) : dispersion) +with{ + dispersion = si.smooth(0.7); // just a simple lowpass + absorption = 0.95; // same as for head +}; + + +//-------`(pm.)clarinetModel`---------- +// A simple clarinet physical model without tone holes (pitch is changed by +// changing the length of the tube of the instrument). +// +// #### Usage +// +// ``` +// clarinetModel(length,pressure,reedStiffness,bellOpening) : _ +// ``` +// +// Where: +// +// * `tubeLength`: the length of the tube in meters +// * `pressure`: the pressure of the air flow created by the virtual performer (0-1). +// This can also be any kind of signal that will directly injected in the mouthpiece +// (e.g., breath noise, etc.). +// * `reedStiffness`: reed stiffness (0-1) +// * `bellOpening`: the opening of bell (0-1) +//---------------------------------- +clarinetModel(tubeLength,pressure,reedStiffness,bellOpening) = endChain(modelChain) +with{ + lengthTuning = 0.05; // empirical adjustment of the tuning of the tube + maxTubeLength = maxLength; + tunedLength = tubeLength/2-lengthTuning; // not really sure why we had to shift octave here + modelChain = + chain( + clarinetMouthPiece(reedStiffness,pressure) : + openTube(maxTubeLength,tunedLength) : + wBell(bellOpening) : out + ); +}; + + +//-------`(pm.)clarinetModel_ui`---------- +// Same as [`clarinetModel`](#clarinetModel) but with a built-in UI. This function +// doesn't implement a virtual "blower", thus `pressure` remains an argument here. +// +// #### Usage +// +// ``` +// clarinetModel_ui(pressure) : _ +// ``` +// +// Where: +// +// * `pressure`: the pressure of the air flow created by the virtual performer (0-1). +// This can also be any kind of signal that will be directly injected in the mouthpiece +// (e.g., breath noise, etc.). +//---------------------------------- +clarinetModel_ui(pressure) = clarinetModel(tubeLength,pressure,reedStiffness,bellOpening)*outGain +with{ + tubeLength = hslider("v:clarinetModel/[0]tubeLength",0.8,0.01,3,0.01) : si.smoo; + reedStiffness = hslider("v:clarinetModel/[1]reedStiffness",0.5,0,1,0.01); + bellOpening = hslider("v:clarinetModel/[2]bellOpening",0.5,0,1,0.01); + outGain = hslider("v:clarinetModel/[3]outGain",0.5,0,1,0.01); +}; + + +//-------`(pm.)clarinet_ui`---------- +// Ready-to-use clarinet physical model with built-in UI based on +// [`clarinetModel`](#clarinetmodel). +// +// #### Usage +// +// ``` +// clarinet_ui : _ +// ``` +//---------------------------------- +clarinet_ui = hgroup("clarinet",blower_ui : clarinetModel_ui); + + +//-------`(pm.)clarinet_ui_MIDI`---------- +// Ready-to-use MIDI compliant clarinet physical model with built-in UI. +// +// #### Usage +// +// ``` +// clarinet_ui_MIDI : _ +// ``` +//---------------------------------- +clarinet_ui_MIDI = +clarinetModel(tubeLength,blow,reedStiffness,bellOpening)*outGain +with{ + f = hslider("v:clarinet/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:clarinet/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:clarinet/h:[0]midi/[2]gain[style:knob] + ",0.6,0,1,0.01); + envAttack = hslider("v:clarinet/h:[0]midi/[3]envAttack[style:knob] + ",1,0,30,0.01)*0.001; + s = hslider("v:clarinet/h:[0]midi/[4]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + reedStiffness = hslider("v:clarinet/h:[1]otherParams/[0]reedStiffness + [midi:ctrl 1][style:knob]",0.5,0,1,0.01); + bellOpening = hslider("v:clarinet/h:[1]otherParams/[1]bellOpening + [midi:ctrl 3][style:knob]",0.5,0,1,0.01); + vibratoFreq = hslider("v:clarinet/h:[1]otherParams/[2]vibratoFreq + [style:knob]",5,1,10,0.01); + vibratoGain = hslider("v:clarinet/h:[1]otherParams/[3]vibratoGain + [style:knob]",0.25,0,1,0.01)*0.01; + outGain = hslider("v:clarinet/h:[1]otherParams/[4]outGain[style:knob] + ",0.5,0,1,0.01); + t = button("v:clarinet/[2]gate"); + + gate = t+s : min(1); + vibrato = 1+os.osc(vibratoFreq)*vibratoGain*envelope; + freq = f*bend*vibrato; + envelope = gate*gain : si.smooth(ba.tau2pole(envAttack)); + + tubeLength = freq : f2l; + pressure = envelope; // TODO: double vibrato here!! + blow = blower(pressure,0.05,2000,vibratoFreq,vibratoGain); +}; + + +//-------`(pm.)brassModel`---------- +// A simple generic brass instrument physical model without pistons +// (pitch is changed by changing the length of the tube of the instrument). +// This model is kind of hard to control and might not sound very good if +// bad parameters are given to it... +// +// #### Usage +// +// ``` +// brassModel(tubeLength,lipsTension,mute,pressure) : _ +// ``` +// +// Where: +// +// * `tubeLength`: the length of the tube in meters +// * `lipsTension`: tension of the lips (0-1) (default: 0.5) +// * `mute`: mute opening at the end of the instrument (0-1) (default: 0.5) +// * `pressure`: the pressure of the air flow created by the virtual performer (0-1). +// This can also be any kind of signal that will directly injected in the mouthpiece +// (e.g., breath noise, etc.). +//---------------------------------- +brassModel(tubeLength,lipsTension,mute,pressure) = endChain(brassChain) +with{ + maxTubeLength = maxLength; + lengthTuning = 0; // Not that important for that one because of lips tension + tunedLength = tubeLength + lengthTuning; + brassChain = chain(brassLips(tunedLength,lipsTension,pressure) : openTube(maxTubeLength,tunedLength) : wBell(mute) : out); +}; + + +//-------`(pm.)brassModel_ui`---------- +// Same as [`brassModel`](#brassModel) but with a built-in UI. This function +// doesn't implement a virtual "blower", thus `pressure` remains an argument here. +// +// #### Usage +// +// ``` +// brassModel_ui(pressure) : _ +// ``` +// +// Where: +// +// * `pressure`: the pressure of the air flow created by the virtual performer (0-1). +// This can also be any kind of signal that will be directly injected in the mouthpiece +// (e.g., breath noise, etc.). +//---------------------------------- +brassModel_ui(pressure) = brassModel(tubeLength,lipsTension,mute,pressure) +with{ + tubeLength = hslider("v:brassModel/[1]tubeLength",0.5,0.01,2.5,0.01) : si.smoo; + lipsTension = hslider("v:brassModel/[2]lipsTension",0.5,0,1,0.01) : si.smoo; + mute = hslider("v:brassModel/[3]mute",0.5,0,1,0.01) : si.smoo; +}; + + +//-------`(pm.)brass_ui`---------- +// Ready-to-use brass instrument physical model with built-in UI based on +// [`brassModel`](#brassmodel). +// +// #### Usage +// +// ``` +// brass_ui : _ +// ``` +//---------------------------------- +brass_ui = hgroup("brass",blower_ui : brassModel_ui); + + +//-------`(pm.)brass_ui_MIDI`---------- +// Ready-to-use MIDI-controllable brass instrument physical model with built-in UI. +// +// #### Usage +// +// ``` +// brass_ui_MIDI : _ +// ``` +//---------------------------------- +brass_ui_MIDI = brassModel(tubeLength,lipsTension,mute,pressure)*outGain +with{ + f = hslider("v:brass/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:brass/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:brass/h:[0]midi/[2]gain[style:knob] + ",0.5,0,1,0.01); + envAttack = hslider("v:brass/h:[0]midi/[3]envAttack[style:knob] + ",1,0,30,0.01)*0.001; + s = hslider("v:brass/h:[0]midi/[4]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + lipsTension = hslider("v:brass/h:[1]otherParams/[0]lipsTension[style:knob] + [midi:ctrl 1]",0.5,0,1,0.01) : si.smoo; + mute = hslider("v:brass/h:[1]otherParams/[1]mute[style:knob] + ",0.5,0,1,0.01) : si.smoo; + vibratoFreq = hslider("v:brass/h:[1]otherParams/[2]vibratoFreq[style:knob] + ",5,1,10,0.01); + vibratoGain = hslider("v:brass/h:[1]otherParams/[3]vibratoGain[style:knob] + ",0.5,0,1,0.01)*0.04; + outGain = hslider("v:brass/h:[1]otherParams/[4]outGain[style:knob] + ",0.5,0,1,0.01); + t = button("v:brass/[2]gate"); + + gate = t+s : min(1); + vibrato = 1+os.osc(vibratoFreq)*vibratoGain*envelope; + freq = f*bend; + envelope = gate*gain : si.smooth(ba.tau2pole(envAttack)); + + tubeLength = freq : f2l; + pressure = envelope*vibrato; +}; + + +//-------`(pm.)fluteModel`---------- +// A simple generic flute instrument physical model without tone holes +// (pitch is changed by changing the length of the tube of the instrument). +// +// #### Usage +// +// ``` +// fluteModel(tubeLength,mouthPosition,pressure) : _ +// ``` +// +// Where: +// +// * `tubeLength`: the length of the tube in meters +// * `mouthPosition`: position of the mouth on the embouchure (0-1) (default: 0.5) +// * `pressure`: the pressure of the air flow created by the virtual performer (0-1). +// This can also be any kind of signal that will directly injected in the mouthpiece +// (e.g., breath noise, etc.). +//---------------------------------- +// TODO: this model is out of tune and we're not really sure why +fluteModel(tubeLength,mouthPosition,pressure) = endChain(fluteChain) : fi.dcblocker +with{ + maxTubeLength = maxLength; + tubeTuning = 0.27; // set "by hand" + tLength = tubeLength+tubeTuning; // global tube length + embouchurePos = 0.27 + (mouthPosition-0.5)*0.4; // position of the embouchure on the tube + tted = tLength*embouchurePos; // head to embouchure distance + eted = tLength*(1-embouchurePos); // embouchure to foot distance + fluteChain = chain(fluteHead : openTube(maxTubeLength,tted) : fluteEmbouchure(pressure) : openTube(maxTubeLength,eted) : fluteFoot : out); +}; + + +//-------`(pm.)fluteModel_ui`---------- +// Same as [`fluteModel`](#fluteModel) but with a built-in UI. This function +// doesn't implement a virtual "blower", thus `pressure` remains an argument here. +// +// #### Usage +// +// ``` +// fluteModel_ui(pressure) : _ +// ``` +// +// Where: +// +// * `pressure`: the pressure of the air flow created by the virtual performer (0-1). +// This can also be any kind of signal that will be directly injected in the mouthpiece +// (e.g., breath noise, etc.). +//---------------------------------- +fluteModel_ui(pressure) = +fluteModel(tubeLength,mouthPosition,pressure)*outGain +with{ + tubeLength = hslider("v:fluteModel/[0]tubeLength",0.8,0.01,3,0.01) : si.smoo; + mouthPosition = hslider("v:fluteModel/[1]mouthPosition",0.5,0,1,0.01) : si.smoo; + outGain = hslider("v:fluteModel/[2]outGain",0.5,0,1,0.01); +}; + + +//-------`(pm.)flute_ui`---------- +// Ready-to-use flute physical model with built-in UI based on +// [`fluteModel`](#flutemodel). +// +// #### Usage +// +// ``` +// flute_ui : _ +// ``` +//---------------------------------- +flute_ui = hgroup("flute",blower_ui : fluteModel_ui); + + +//-------`(pm.)flute_ui_MIDI`---------- +// Ready-to-use MIDI-controllable flute physical model with built-in UI. +// +// #### Usage +// +// ``` +// flute_ui_MIDI : _ +// ``` +//---------------------------------- +flute_ui_MIDI = fluteModel(tubeLength,mouthPosition,blow)*outGain +with{ + f = hslider("v:flute/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:flute/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:flute/h:[0]midi/[2]gain[style:knob] + ",0.9,0,1,0.01); + envAttack = hslider("v:flute/h:[0]midi/[3]envAttack[style:knob] + ",1,0,30,0.01)*0.001; + s = hslider("v:flute/h:[0]midi/[4]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + mouthPosition = hslider("v:flute/h:[1]otherParams/[0]mouthPosition + [style:knob][midi:ctrl 1]",0.5,0,1,0.01) + : si.smoo; + vibratoFreq = hslider("v:flute/h:[1]otherParams/[1]vibratoFreq[style:knob] + ",5,1,10,0.01); + vibratoGain = hslider("v:flute/h:[1]otherParams/[2]vibratoGain[style:knob] + ",0.5,0,1,0.01)*0.04; + outGain = hslider("v:flute/h:[1]otherParams/[3]outGain[style:knob] + ",0.5,0,1,0.01); + t = button("v:flute/[2]gate"); + + gate = t+s : min(1); + freq = f*bend; + envelope = gate*gain : si.smooth(ba.tau2pole(envAttack)); + + tubeLength = freq : f2l; + pressure = envelope; + blow = blower(pressure,0.05,2000,vibratoFreq,vibratoGain); +}; + + +//=====================================Exciters=========================================== +// Various kind of excitation signal generators. +//======================================================================================== + +//-------`(pm.)impulseExcitation`-------------- +// Creates an impulse excitation of one sample. +// +// #### Usage +// +// ``` +// gate = button('gate'); +// impulseExcitation(gate) : chain; +// ``` +// +// Where: +// +// * `gate`: a gate button +//-------------------------------------- +impulseExcitation(trigger) = trigger : ba.impulsify; + + +//-------`(pm.)strikeModel`-------------- +// Creates a filtered noise excitation. +// +// #### Usage +// +// ``` +// gate = button('gate'); +// strikeModel(LPcutoff,HPcutoff,sharpness,gain,gate) : chain; +// ``` +// +// Where: +// +// * `HPcutoff`: highpass cutoff frequency +// * `LPcutoff`: lowpass cutoff frequency +// * `sharpness`: sharpness of the attack and release (0-1) +// * `gain`: gain of the excitation +// * `gate`: a gate button/trigger signal (0/1) +//-------------------------------------- +strikeModel(HPcutoff,LPcutoff,sharpness,gain,trigger) = +no.noise : fi.highpass(2,HPcutoff) : fi.lowpass(2,LPcutoff) : +*(en.ar(att,rel,trigger))*gain +with{ + att = 0.002*sharpness; + rel = att; +}; + + +//-------`(pm.)strike`-------------- +// Strikes generator with controllable excitation position. +// +// #### Usage +// +// ``` +// gate = button('gate'); +// strike(exPos,sharpness,gain,gate) : chain; +// ``` +// +// Where: +// +// * `exPos`: excitation position wiht 0: for max low freqs and 1: for max high +// freqs. So, on membrane for example, 0 would be the middle and 1 the edge +// * `sharpness`: sharpness of the attack and release (0-1) +// * `gain`: gain of the excitation +// * `gate`: a gate button/trigger signal (0/1) +//-------------------------------------- +strike(exPos,sharpness,gain,trigger) = strikeModel(HPcutoff,LPcutoff,sharpness,gain,trigger) +with{ + HPcutoff = 40+exPos*500; + LPcutoff = 500+exPos*15000; +}; + + +//-------`(pm.)pluckString`-------------- +// Creates a plucking excitation signal. +// +// #### Usage +// +// ``` +// trigger = button('gate'); +// pluckString(stringLength,cutoff,maxFreq,sharpness,trigger) +// ``` +// +// Where: +// +// * `stringLength`: length of the string to pluck +// * `cutoff`: cutoff ratio (1 for default) +// * `maxFreq`: max frequency ratio (1 for default) +// * `sharpness`: sharpness of the attack and release (1 for default) +// * `gain`: gain of the excitation (0-1) +// * `trigger`: trigger signal (1 for on, 0 for off) +//-------------------------------------- +pluckString(stringLength,cutoff,maxFreq,sharpness,gain,trigger) = +no.noise : fi.lowpass(2,cutoffreq) : *(en.ar(att,rel,trigger))*gain +with{ + freq = stringLength : l2f; + maxF = 2000*maxFreq; + att = 0.002*sharpness*pow((1 - freq/maxF),2); + rel = att; + cutoffreq = freq*5*cutoff; +}; + + +//-------`(pm.)blower`-------------- +// A virtual blower creating a DC signal with some breath noise in it. +// +// #### Usage +// +// ``` +// blower(pressure,breathGain,breathCutoff) : _ +// ``` +// +// Where: +// +// * `pressure`: pressure (0-1) +// * `breathGain`: breath noise gain (0-1) (recommended: 0.005) +// * `breathCutoff`: breath cuttoff frequency (Hz) (recommended: 2000) +//-------------------------------------- +blower(pressure,breathGain,breathCutoff,vibratoFreq,vibratoGain) = pressure + vibrato + breathNoise +with{ + vibrato = os.osc(vibratoFreq)*vibratoGain; + breathNoise = no.noise : fi.lowpass(2,breathCutoff) : *(pressure*breathGain); +}; + + +//-------`(pm.)blower_ui`-------------- +// Same as [`blower`](#blower) but with a built-in UI. +// +// #### Usage +// +// ``` +// blower : somethingToBeBlown +// ``` +//-------------------------------------- +blower_ui = blower(pressure,breathGain,breathCutoff,vibratoFreq,vibratoGain) +with{ + pressure = hslider("v:blower/[0]pressure",0,0,1,0.01) : si.smoo; + breathGain = hslider("v:blower/[1]breathGain",0.1,0,1,0.01)*0.05; + breathCutoff = hslider("v:blower/[2]breathCutoff",2000,20,20000,0.1); + vibratoFreq = hslider("v:blower/[3]vibratoFreq",5,0.1,10,0.1); + vibratoGain = hslider("v:blower/[4]vibratoGain",0.25,0,1,0.01)*0.03; +}; + + +//============================Modal Percussions=========================================== +// High and low level functions for modal synthesis of percussion instruments. +//======================================================================================== + +//-------`(pm.)djembeModel`---------- +// Dirt-simple djembe modal physical model. Mode parameters are empirically +// calculated and don't correspond to any measurements or 3D model. They +// kind of sound good though :). +// +// #### Usage +// +// ``` +// excitation : djembeModel(freq) +// ``` +// +// Where: +// +// * `excitation`: excitation signal +// * `freq`: fundamental frequency of the bar +//---------------------------------- +djembeModel(freq) = _ <: par(i,nModes,modeFilter(modeFreqs(i),modeT60s(i),modeGains(i))) :> /(nModes) +with{ + nModes = 20; + theta = 0; // angle + modeFreqs(i) = freq + 200*i; + modeT60s(i) = (nModes-i)*0.03; + modeGains(i) = cos((i+1)*theta)/float(i+1)*(1/(i+1)); +}; + + +//-------`(pm.)djembe`---------- +// Dirt-simple djembe modal physical model. Mode parameters are empirically +// calculated and don't correspond to any measurements or 3D model. They +// kind of sound good though :). +// +// This model also implements a virtual "exciter". +// +// #### Usage +// +// ``` +// djembe(freq,strikePosition,strikeSharpness,gain,trigger) +// ``` +// +// Where: +// +// * `freq`: fundamental frequency of the model +// * `strikePosition`: strike position (0 for the middle of the membrane and +// 1 for the edge) +// * `strikeSharpness`: sharpness of the strike (0-1, default: 0.5) +// * `gain`: gain of the strike +// * `trigger`: trigger signal (0: off, 1: on) +//---------------------------------- +djembe(freq,strikePosition,strikeSharpness,gain,trigger) = +strike(strikePosition,strikeSharpness,gain,trigger) : djembeModel(freq); + +//-------`(pm.)djembe_ui_MIDI`---------- +// Simple MIDI controllable djembe physical model with built-in UI. +// +// #### Usage +// +// ``` +// djembe_ui_MIDI : _ +// ``` +//---------------------------------- +djembe_ui_MIDI = +djembe(freq,strikePosition,strikeSharpness,gain,gate)*outGain +with{ + freq = hslider("v:djembe/h:[0]midi/[0]freq[style:knob]",60,50,100,0.01); + gain = hslider("v:djembe/h:[0]midi/[2]gain[style:knob]",1,0,1,0.01); + strikePosition = hslider("v:djembe/h:[1]otherParams/[0]strikePosition + [midi:ctrl 1][style:knob]",0.5,0,1,0.01); + strikeSharpness = hslider("v:djembe/h:[1]otherParams/[1]strikeSharpness[style:knob]",0.5,0.01,5,0.01); + outGain = hslider("v:djembe/h:[1]otherParams/[2]outGain + [style:knob]",1,0,1,0.01); + gate = button("v:djembe/[3]gate"); +}; + + +//-------`(pm.)marimbaBarModel`---------- +// Generic marimba tone bar modal model. +// +// This model was generated using +// `mesh2faust` from a 3D CAD model of a marimba tone bar +// (`libraries/modalmodels/marimbaBar`). The corresponding CAD model is that +// of a C2 tone bar (original fundamental frequency: ~65Hz). While +// `marimbaBarModel` allows to translate the harmonic content of the generated +// sound by providing a frequency (`freq`), mode transposition has limits and +// the model will sound less and less like a marimba tone bar as it +// diverges from C2. To make an accurate model of a marimba, we'd want to have +// an independent model for each bar... +// +// This model contains 5 excitation positions going linearly from the center +// bottom to the center top of the bar. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// #### Usage +// +// ``` +// excitation : marimbaBarModel(freq,exPos,t60,t60DecayRatio,t60DecaySlope) +// ``` +// +// Where: +// +// * `excitation`: excitation signal +// * `freq`: fundamental frequency of the bar +// * `exPos`: excitation position (0-4) +// * `t60`: T60 in seconds (recommended value: 0.1) +// * `t60DecayRatio`: T60 decay ratio (recommended value: 1) +// * `t60DecaySlope`: T60 decay slope (recommended value: 5) +//---------------------------------- +marimbaBarModel(freq,exPos,t60,t60DecayRatio,t60DecaySlope) = _ <: par(i,nModes,modeFilter(modesFreqs(i),modesT60s(i),modesGains(int(exPos),i))) :> /(nModes) +with{ + nModes = 50; + nExPos = 5; + modesFreqRatios(n) = ba.take(n+1,(1,3.31356,3.83469,8.06313,9.44778,14.1169,18.384,21.0102,26.1775,28.9944,37.0728,37.8703,40.0634,47.6439,51.019,52.43,58.286,63.5486,65.3628,66.9587,74.5301,78.692,80.8375,89.978,92.9661,95.1914,97.4807,110.62,112.069,113.826,119.356,127.045,129.982,132.259,133.477,144.549,149.438,152.033,153.166,155.597,158.183,168.105,171.863,174.464,178.937,181.482,185.398,190.369,192.19,195.505)); + modesFreqs(i) = freq*modesFreqRatios(i); + modesGains(p,n) = waveform{1,0.776725,0.625723,0.855223,0.760159,0.698373,0.768011,0.641127,0.244034,0.707754,0.634013,0.247527,0.660849,0.450396,0.567783,0.106361,0.716814,0.66392,0.291208,0.310599,0.801495,0.635292,0.307435,0.874124,0.497668,0.487088,0.459115,0.733455,0.541818,0.441318,0.31392,0.40309,0.685353,0.60314,0.400552,0.453511,0.634386,0.291547,0.131605,0.368507,0.839907,0.60216,0.288296,0.57967,0.0242493,0.262746,0.368588,0.890284,0.408963,0.556072,0.884427,0.83211,0.612015,0.757176,0.919477,1,0.827963,0.89241,0.0357408,0.480789,0.752872,0.0546301,0.235937,0.362938,0.444472,0.101751,0.703418,0.453136,0.316629,0.490394,0.982508,0.551622,0.602009,0.666957,0.77683,0.905662,0.0987197,0.402968,0.829452,0.307645,0.64048,0.983971,0.584205,0.650365,0.334447,0.58357,0.540191,0.672534,0.245712,0.687298,0.883058,0.79295,0.600619,0.572682,0.122612,0.388248,0.290658,0.380255,0.290967,0.567819,0.0737721,0.42099,0.0786578,0.393995,0.268983,0.260614,0.494086,0.238026,0.0987824,0.277879,0.440563,0.0770212,0.450591,0.128137,0.0368275,0.128699,0.329605,0.374512,0.36359,0.272594,0.379052,0.305241,0.0741129,0.345728,0.29935,0.221284,0.0261391,0.293202,0.361885,0.11433,0.239005,0.434156,0.329583,0.21946,0.284175,0.198555,0.431976,0.302985,1,0.146221,0.140701,0.264243,0.185997,0.426322,0.30478,0.34399,0.19543,0.386955,0.1876,0.172812,0.0434115,0.303761,0.069454,0.453943,0.832451,0.317817,0.940601,1,0.180658,0.737921,0.832297,0.402352,0.126786,0.594398,0.485455,0.32447,0.365102,0.777922,0.588272,0.401353,0.610735,0.158693,0.0746072,0.825099,0.925459,0.65377,0.260792,0.719384,0.559908,0.37259,0.360035,0.622939,0.210271,0.444595,0.311286,0.464309,0.557231,0.52408,0.0701056,0.320749,0.19446,0.727609,0.522062,0.394004,0.235035,0.395646,0.494796,0.517318,0.109752,0.692849,0.00632009,0.0207583,0.00306107,0.0637191,0.081661,0.03511,0.127814,0.202294,0.0764145,0.263127,0.400199,0.267278,0.633385,1,0.739902,0.413763,0.41811,0.612715,0.672374,0.339674,0.21172,0.459645,0.1025,0.32589,0.148154,0.265442,0.0974305,0.286438,0.275213,0.109111,0.575089,0.370283,0.29411,0.259826,0.0648719,0.583418,0.282663,0.182004,0.117421,0.417727,0.16965,0.24853,0.122819,0.185486,0.0433618,0.373849,0.252768,0.195103,0.0927835,0.166543},int(p*nModes+n) : rdtable : select2(modesFreqs(n)<(ma.SR/2-1),0); + modesT60s(i) = t60*pow(1-(modesFreqRatios(i)/195.955)*t60DecayRatio,t60DecaySlope); +}; + + +//-------`(pm.)marimbaResTube`---------- +// Simple marimba resonance tube. +// +// #### Usage +// +// ``` +// marimbaResTube(tubeLength,excitation) +// ``` +// +// Where: +// +// * `tubeLength`: the length of the tube in meters +// * `excitation`: the excitation signal (audio in) +//---------------------------------- +marimbaResTube(tubeLength,excitation) = endChain(tubeChain) +with{ + maxTubeLength = maxLength; + lengthTuning = 0.04; + tunedLength = tubeLength-lengthTuning; + endTubeReflexion = si.smooth(0.95)*0.99; + tubeChain = + chain( + in(excitation) : + terminations(endTubeReflexion, + openTube(maxTubeLength,tunedLength), + endTubeReflexion) : + out + ); +}; + + +//-------`(pm.)marimbaModel`---------- +// Simple marimba physical model implementing a single tone bar connected to +// tube. This model is scalable and can be adapted to any size of bar/tube +// (see [`marimbaBarModel`](#marimbabarmodel) to know more about the +// limitations of this type of system). +// +// #### Usage +// +// ``` +// excitation : marimbaModel(freq,exPos) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency of the bar/tube couple +// * `exPos`: excitation position (0-4) +//---------------------------------- +marimbaModel(freq,exPos) = +marimbaBarModel(freq,exPos,maxT60,T60Decay,T60Slope) : marimbaResTube(resTubeLength) +with{ + resTubeLength = freq : f2l; + maxT60 = 0.1; + T60Decay = 1; + T60Slope = 5; +}; + + +//-------`(pm.)marimba`---------- +// Simple marimba physical model implementing a single tone bar connected to +// tube. This model is scalable and can be adapted to any size of bar/tube +// (see [`marimbaBarModel`](#marimbabarmodel) to know more about the +// limitations of this type of system). +// +// This function also implement a virtual exciter to drive the model. +// +// #### Usage +// +// ``` +// excitation : marimba(freq,strikePosition,strikeCutoff,strikeSharpness,gain,trigger) : _ +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `freq`: the frequency of the bar/tube couple +// * `strikePosition`: strike position (0-4) +// * `strikeCutoff`: cuttoff frequency of the strike genarator (recommended: ~7000Hz) +// * `strikeSharpness`: sharpness of the strike (recommended: ~0.25) +// * `gain`: gain of the strike (0-1) +// * `trigger` signal (0: off, 1: on) +//---------------------------------- +marimba(freq,strikePosition,strikeCutoff,strikeSharpness,gain,trigger) = +strikeModel(10,strikeCutoff,strikeSharpness,gain,trigger) : +marimbaModel(freq,strikePosition); + + +//-------`(pm.)marimba_ui_MIDI`---------- +// Simple MIDI controllable marimba physical model with built-in UI +// implementing a single tone bar connected to +// tube. This model is scalable and can be adapted to any size of bar/tube +// (see [`marimbaBarModel`](#marimbabarmodel) to know more about the +// limitations of this type of system). +// +// #### Usage +// +// ``` +// marimba_ui_MIDI : _ +// ``` +//---------------------------------- +marimba_ui_MIDI = +marimba(freq,strikePosition,strikeCutoff,strikeSharpness,gain,gate)*outGain +with{ + freq = hslider("v:marimba/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + gain = hslider("v:marimba/h:[0]midi/[2]gain[style:knob]",1,0,1,0.01); + strikePosition = nentry("v:marimba/h:[1]otherParams/[0]strikePosition + [midi:ctrl 1]",0,0,4,1); + strikeCutoff = hslider("v:marimba/h:[1]otherParams/[1]strikeCutOff + [midi:ctrl 1][style:knob]",6500,20,20000,1); + strikeSharpness = hslider("v:marimba/h:[1]otherParams/[2]strikeSharpness + [style:knob]",0.5,0.01,5,0.01); + outGain = hslider("v:marimba/h:[1]otherParams/[2]outGain + [style:knob]",0.8,0,1,0.01); + gate = button("v:marimba/[3]gate"); +}; + + +//-------`(pm.)churchBellModel`---------- +// Generic church bell modal model generated by `mesh2faust` from +// `libraries/modalmodels/churchBell`. +// +// Modeled after T. Rossing and R. Perrin, Vibrations of Bells, Applied +// Acoustics 2, 1987. +// +// Model height is 301 mm. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// #### Usage +// +// ``` +// excitation : churchBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `nModes`: number of synthesized modes (max: 50) +// * `exPos`: excitation position (0-6) +// * `t60`: T60 in seconds (recommended value: 0.1) +// * `t60DecayRatio`: T60 decay ratio (recommended value: 1) +// * `t60DecaySlope`: T60 decay slope (recommended value: 5) +//---------------------------------- +churchBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) = _ <: par(i,nModes,modeFilter(modesFreqs(i),modesT60s(i),modesGains(int(exPos),i))) :> /(nModes) +with{ + nExPos = 7; + modesFreqs(n) = ba.take(n+1,(451.918,455,864.643,871.402,1072.47,1073.98,1292.23,1292.48,1504.6,1532.41,1646.2,1647,1677.83,1678.13,1866.63,1882.08,1985.2,1989.87,2114.93,2356.81,2444.32,2446.22,2528.77,2530.92,2668.86,2669.63,2738.06,2749.03,2750.53,2753.11,2827.19,2842.32,2992.56,2996.84,3172.61,3330.79,3390.33,3403.1,3516.43,3538.54,3582.79,3583.82,3730.04,3739.35,3758.66,3903.78,3942.59,3981.74,3983.25,4033.97)); + modesGains(p,n) = waveform{0.525285,0.814174,0.483261,0.296745,0.975056,0.472244,0.409501,0.425364,0.687559,0.288381,0.309285,0.123054,0.286333,0.576706,0.908322,0.626974,0.0801852,0.309835,0.45143,0.132845,0.470635,0.417008,0.265112,0.0752802,0.46347,0.47181,0.275324,0.547027,0.512519,0.394078,0.595404,0.941306,0.392501,0.381435,0.391232,0.118924,0.339495,0.101421,0.241755,0.0873255,0.378944,0.637705,0.171946,0.149859,0.23329,0.54181,1,0.115554,0.244172,0.574329,0.606171,0.938397,0.392555,0.277359,0.86857,0.432489,0.408856,0.407932,0.299815,0.256659,0.549572,0.406347,0.312331,0.627578,0.670167,0.524648,0.406926,0.637524,0.555837,1,0.818979,0.705347,0.678141,0.427382,0.674404,0.636105,0.643635,0.699136,0.836201,0.613085,0.319019,0.725259,0.545519,0.479861,0.49836,0.488654,0.861672,0.314287,0.671052,0.531905,0.421781,0.815066,0.772032,0.488722,0.0896674,0.291286,0.65873,0.635632,0.679357,0.459497,0.36024,0.582289,0.650605,0.49095,0.38191,0.157261,0.479624,0.477491,0.174435,0.013094,0.879113,0.608069,0.268877,0.604479,0.24513,0.170507,0.292888,0.545849,0.476646,0.922316,0.669192,0.578094,0.578797,0.311396,0.60121,0.549955,1,0.66573,0.980115,0.537848,0.0740531,0.252472,0.25575,0.223974,0.0865103,0.138209,0.198623,0.0453034,0.432453,0.292407,0.39441,0.857659,0.271668,0.201545,0.583994,0.0602378,0.190618,0.849505,0.975542,0.17314,0.206472,0.344793,0.761011,0.558125,0.117245,0.0338485,0.337597,0.336646,0.174253,0.23017,0.934873,0.593647,0.393225,0.683704,0.0566093,0.0405012,0.148972,0.338722,0.283419,0.394007,0.237475,0.269964,0.428313,0.177499,0.462585,0.443963,0.981793,0.408239,0.676527,0.402865,0.0163303,0.0515114,0.34139,0.311135,0.613276,0.805884,0.95329,0.406091,0.578705,0.386785,0.434103,0.77526,1,0.635909,0.782052,0.0137183,0.0387725,0.618964,0.857071,0.131522,0.184988,0.299495,0.789212,0.603114,0.0704989,0.0129339,0.252481,0.254121,0.189206,0.357713,0.950308,0.552573,0.466454,0.77736,0.0307886,0.0251943,0.378886,0.740187,0.247637,0.235201,0.493045,0.51785,0.883954,0.429473,0.409433,0.415266,0.940198,0.282334,0.43789,0.375385,0.0157366,0.0171763,0.485555,0.461015,0.858958,0.907991,0.935191,0.37551,1,0.585493,0.269981,0.423053,0.666067,0.43509,0.790252,0.00889586,0.0208844,0.449735,0.790808,0.159856,0.089599,0.161546,0.528168,0.380642,0.0206276,0.00726426,0.0315352,0.0315841,0.197649,0.475057,0.517232,0.360922,0.421204,0.63134,0.00952139,0.016105,0.499615,0.922958,0.214983,0.0655141,0.50397,0.514848,1,0.483619,0.254027,0.228372,0.436105,0.233125,0.152242,0.279513,0.00906739,0.0132332,0.451257,0.388566,0.737226,0.479378,0.233037,0.103767,0.845609,0.644127,0.261359,0.371457,0.527229,0.381373,0.334492,0.00833749,0.00861982,0.255919,0.254197,0.0872333,0.0461512,0.113018,0.345986,0.236344,0.01078,0.00816506,0.405181,0.38718,0.343681,0.816493,0.259082,0.211906,0.432455,0.696886,0.00576224,0.013131,0.455969,0.811609,0.426544,0.128489,0.215937,0.233934,0.72307,0.351623,0.394231,0.323766,0.168803,0.276932,0.264684,0.227703,0.00680935,0.0170703,0.603018,0.476461,0.585925,0.71696,1,0.576527,0.475524,0.447322,0.356902,0.597573,0.697246,0.505333,0.285421,0.0147193,0.0141618,0.136188,0.0336537,0.216437},int(p*nModes+n) : rdtable; + modesT60s(i) = t60*pow(1-(modesFreqs(i)/4035.44)*t60DecayRatio,t60DecaySlope); +}; + + +//-------`(pm.)churchBell`---------- +// Generic church bell modal model. +// +// Modeled after T. Rossing and R. Perrin, Vibrations of Bells, Applied +// Acoustics 2, 1987. +// +// Model height is 301 mm. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// This function also implement a virtual exciter to drive the model. +// +// #### Usage +// +// ``` +// excitation : churchBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) : _ +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `strikePosition`: strike position (0-6) +// * `strikeCutoff`: cuttoff frequency of the strike genarator (recommended: ~7000Hz) +// * `strikeSharpness`: sharpness of the strike (recommended: ~0.25) +// * `gain`: gain of the strike (0-1) +// * `trigger` signal (0: off, 1: on) +//---------------------------------- +churchBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) = +strikeModel(10,strikeCutoff,strikeSharpness,gain,trigger) : +churchBellModel(50,strikePosition,30,1,2.5); + + +//-------`(pm.)churchBell_ui`---------- +// Church bell physical model based on [`churchBell`](#churchbell) with +// built-in UI. +// +// #### Usage +// +// ``` +// churchBell_ui : _ +// ``` +//---------------------------------- +churchBell_ui = +churchBell(strikePosition,strikeCutoff,strikeSharpness,gain,gate) +with{ + strikePosition = nentry("v:churchBell/[0]strikePosition", + 0,0,4,1); + strikeCutoff = hslider("v:churchBell/[1]strikeCutOff", + 6500,20,20000,1); + strikeSharpness = hslider("v:churchBell/[2]strikeSharpness", + 0.5,0.01,5,0.01); + gain = hslider("v:churchBell/[3]gain",1,0,1,0.01); + gate = button("v:churchBell/[4]gate"); +}; + + +//-------`(pm.)englishBellModel`---------- +// English church bell modal model generated by `mesh2faust` from +// `libraries/modalmodels/englishBell`. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 1 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// #### Usage +// +// ``` +// excitation : englishBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `nModes`: number of synthesized modes (max: 50) +// * `exPos`: excitation position (0-6) +// * `t60`: T60 in seconds (recommended value: 0.1) +// * `t60DecayRatio`: T60 decay ratio (recommended value: 1) +// * `t60DecaySlope`: T60 decay slope (recommended value: 5) +//---------------------------------- +englishBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) = _ <: par(i,nModes,modeFilter(modesFreqs(i),modesT60s(i),modesGains(int(exPos),i))) :> /(nModes) +with{ + nExPos = 7; + modesFreqs(n) = ba.take(n+1,(259.429,261.855,493.331,494.472,603.048,604.742,724.566,724.777,786.985,931.893,932.846,943.429,946.533,947.109,952.782,1024.24,1034.86,1211.59,1212.21,1236.28,1340.21,1341.15,1452.63,1453.38,1453.77,1457.45,1459.23,1460.7,1482.81,1483.04,1519.55,1547.27,1565.95,1576.95,1697.47,1826.61,1892.56,1896.09,1899.86,1908.29,2003.95,2005.07,2005.89,2005.99,2067.42,2082.42,2086.81,2120.56,2129.79,2133.23)); + modesGains(p,n) = waveform{0.694274,0.471698,0.17239,0.585446,0.397986,0.919579,0.531947,0.100205,0.639469,0.672209,0.144345,0.416595,0.124108,0.380591,0.256578,0.646031,0.8522,0.0224376,0.382762,0.143925,0.368691,0.430556,0.32318,0.142956,0.274521,0.713824,0.442794,0.352473,0.247756,0.415152,1,0.401869,0.197981,0.27951,0.210249,0.36974,0.369227,0.155769,0.272368,0.335712,0.31645,0.714103,0.285781,0.22006,0.827704,0.206342,0.180177,0.311478,0.197607,0.575475,0.473311,0.587232,0.50288,0.337308,0.304514,0.429039,0.351522,0.341373,0.175081,0.561748,0.439172,0.323164,0.540518,0.536523,0.0743865,0.213417,0.358012,0.474494,0.310274,0.839413,0.241372,0.202343,0.480634,0.995685,0.37374,0.133998,0.520674,0.207514,1,0.101239,0.279536,0.185985,0.436293,0.62411,0.334519,0.283585,0.179317,0.353847,0.449545,0.574128,0.135172,0.538275,0.476424,0.832903,0.164198,0.188562,0.135978,0.390128,0.131045,0.312065,0.142139,0.0255901,0.266947,0.371607,0.0168435,0.0249468,0.508917,0.35441,0.283348,0.628155,0.292478,0.35835,0.342569,0.441237,0.886699,0.0174698,0.00641843,0.55532,0.880129,0.0306909,0.290081,0.248816,0.981736,0.324624,0.213676,0.432885,0.0981559,0.444149,0.395554,0.525069,0.0771308,0.0488804,0.591321,0.108044,0.443802,0.740318,0.599438,0.293093,1,0.141662,0.910031,0.226126,0.299702,0.341472,0.0568061,0.222494,0.918718,0.199478,0.21662,0.107759,0.692324,0.556336,0.281718,0.430832,0.341656,0.608095,0.342129,0.311312,0.229953,0.695087,0.0761489,0.349818,0.361706,0.577611,0.147797,0.327376,0.465715,0.342902,0.521381,0.836828,0.241112,0.284394,0.539316,0.143408,0.51702,1,0.236336,0.480333,0.676744,0.807582,0.468621,0.236953,0.411604,0.579251,0.425098,0.37599,0.461176,0.27653,0.462368,0.613004,0.666849,0.954715,0.161507,0.170433,0.290461,0.117303,0.365133,0.233794,0.194568,0.338874,0.523381,0.39835,0.447839,0.652891,0.15708,0.340354,0.44217,0.338764,0.184397,0.771607,0.160502,0.324487,0.477499,0.831519,0.0168764,0.154264,0.201865,0.237786,0.390066,0.880164,0.284234,0.162837,0.437557,0.227846,0.39934,1,0.158107,0.396903,0.513029,0.676457,0.204282,0.0895575,0.55541,0.732486,0.125062,0.171229,0.081646,0.0541394,0.39616,0.454288,0.466863,0.928842,0.155393,0.26285,0.113453,0.133163,0.302021,0.612616,0.228392,0.195617,0.287236,0.198762,0.499884,0.809139,0.00929925,0.0840299,0.286446,0.182112,0.186044,0.754138,0.279556,0.266948,0.494291,1,0.321284,0.0230981,0.0375537,0.262531,0.602204,0.489925,0.633077,0.407409,0.422256,0.0910641,0.357935,0.550179,0.106192,0.132366,0.376231,0.351151,0.0420302,0.0372183,0.696335,0.840821,0.855235,0.249248,0.860011,0.340481,0.28558,0.363039,0.324122,0.515699,0.228131,0.172592,0.0188723,0.168243,0.995105,0.741759,0.107093,0.070349,0.136636,0.0780455,0.315748,0.502201,0.0190422,0.033914,0.225724,0.160236,0.184101,0.564203,0.247317,0.284225,0.327153,0.651443,0.593471,0.0163899,0.0141048,0.52113,1,0.105109,0.530936,0.363724,0.924809,0.25041,0.69288,0.414122,0.0793658,0.347813,0.441731,0.476428,0.0808834,0.0581638,0.557239,0.556515,0.746084,0.582228,0.177231,0.158425,0.850903,0.755271,0.673614,0.31706,0.0515386,0.201898,0.0577938,0.232031,0.734988,0.141594,0.267062,0.145807},int(p*nModes+n) : rdtable; + modesT60s(i) = t60*pow(1-(modesFreqs(i)/2137.04)*t60DecayRatio,t60DecaySlope); +}; + + +//-------`(pm.)englishBell`---------- +// English church bell modal model. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 1 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// This function also implement a virtual exciter to drive the model. +// +// #### Usage +// +// ``` +// excitation : englishBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) : _ +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `strikePosition`: strike position (0-6) +// * `strikeCutoff`: cuttoff frequency of the strike genarator (recommended: ~7000Hz) +// * `strikeSharpness`: sharpness of the strike (recommended: ~0.25) +// * `gain`: gain of the strike (0-1) +// * `trigger` signal (0: off, 1: on) +//---------------------------------- +englishBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) = +strikeModel(10,strikeCutoff,strikeSharpness,gain,trigger) : +englishBellModel(50,strikePosition,30,1,3); + + +//-------`(pm.)englishBell_ui`---------- +// English church bell physical model based on [`englishBell`](#englishbell) with +// built-in UI. +// +// #### Usage +// +// ``` +// englishBell_ui : _ +// ``` +//---------------------------------- +englishBell_ui = +englishBell(strikePosition,strikeCutoff,strikeSharpness,gain,gate) +with{ + strikePosition = nentry("v:englishBell/[0]strikePosition",0,0,6,1); + strikeCutoff = hslider("v:englishBell/[1]strikeCutOff",6500,20,20000,1); + strikeSharpness = hslider("v:englishBell/[2]strikeSharpness",0.5,0.01,5,0.01); + gain = hslider("v:englishBell/[3]gain",1,0,1,0.01); + gate = button("v:englishBell/[4]gate"); +}; + + +//-------`(pm.)frenchBellModel`---------- +// French church bell modal model generated by `mesh2faust` from +// `libraries/modalmodels/frenchBell`. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 1 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// #### Usage +// +// ``` +// excitation : frenchBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `nModes`: number of synthesized modes (max: 50) +// * `exPos`: excitation position (0-6) +// * `t60`: T60 in seconds (recommended value: 0.1) +// * `t60DecayRatio`: T60 decay ratio (recommended value: 1) +// * `t60DecaySlope`: T60 decay slope (recommended value: 5) +//---------------------------------- +frenchBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) = _ <: par(i,nModes,modeFilter(modesFreqs(i),modesT60s(i),modesGains(int(exPos),i))) :> /(nModes) +with{ + nExPos = 7; + modesFreqs(n) = ba.take(n+1,(439.077,440.305,606.452,611.776,709.617,709.877,856.966,899.051,1064.37,1064.75,1073.03,1074.43,1076.58,1145.42,1148.9,1197.09,1199.91,1387.7,1400.16,1402.37,1512.06,1513.06,1592.47,1593.35,1663.45,1666.47,1691.32,1693.77,1804.83,1808.84,1820.07,1847.14,1910.73,1927.7,2035.07,2038.73,2054.66,2055.67,2078.69,2091.76,2115.78,2127.01,2209.86,2214.05,2296.15,2298.08,2298.97,2307.62,2404.44,2408.99)); + modesGains(p,n) = waveform{0.97289,0.542393,0.495832,0.897966,0.552367,0.557895,0.614213,0.353694,0.436039,0.441024,0.674913,0.566754,0.755008,0.69903,0.164398,0.91004,0.628373,0.201718,0.429517,0.503715,0.871174,0.106886,0.761173,0.673602,0.291937,0.58859,0.31528,0.413081,0.274464,0.494062,0.696121,0.61201,0.382757,0.995113,0.228806,0.198449,0.595847,0.306263,0.252397,0.0883567,0.236086,1,0.245278,0.379388,0.198824,0.548892,0.492764,0.420871,0.794637,0.605634,1,0.604159,0.399841,0.799347,0.507187,0.50981,0.477383,0.310226,0.426976,0.437623,0.735712,0.630728,0.625785,0.651168,0.277738,0.850858,0.578079,0.645354,0.3837,0.370598,0.782542,0.181325,0.614391,0.740684,0.342441,0.586186,0.286909,0.405197,0.259215,0.566983,0.748219,0.655898,0.36826,0.940814,0.336157,0.413702,0.561557,0.402176,0.117698,0.329369,0.254571,0.870706,0.260981,0.274122,0.206247,0.6453,0.400758,0.363622,0.636834,0.584566,0.975603,0.616937,0.295401,0.650447,0.464221,0.465057,0.312467,0.238358,0.383695,0.399674,0.753912,0.662012,0.504268,0.599248,0.378665,0.725363,0.493214,1,0.332836,0.265889,0.674073,0.320401,0.440018,0.769782,0.316419,0.529968,0.380509,0.578676,0.249013,0.591384,0.761717,0.687057,0.324437,0.818864,0.505369,0.672485,0.461783,0.426198,0.0678875,0.435329,0.347955,0.708394,0.293322,0.328986,0.258254,0.893512,0.320131,0.433554,0.459302,0.542213,0.817241,0.51623,0.205302,0.467354,0.388683,0.388216,0.171262,0.150865,0.29172,0.311414,0.658876,0.570647,0.383619,0.502455,0.364114,0.532313,0.352989,1,0.261984,0.219591,0.544031,0.337199,0.279173,0.668303,0.208439,0.39923,0.418674,0.648618,0.234133,0.504729,0.645347,0.572851,0.232828,0.614292,0.485272,0.666264,0.31657,0.320355,0.191421,0.340131,0.342069,0.538371,0.281131,0.393115,0.251394,0.890725,0.310644,0.5037,0.29909,0.442478,0.733128,0.455217,0.199322,0.315699,0.375856,0.37649,0.029145,0.0200283,0.279578,0.3168,0.655957,0.546843,0.349666,0.470249,0.353765,0.286794,0.180185,1,0.210831,0.280133,0.535853,0.376488,0.15367,0.634745,0.0510449,0.485575,0.593111,0.917884,0.380477,0.422925,0.599373,0.311421,0.135654,0.359954,0.295748,0.474439,0.353339,0.116743,0.454313,0.112858,0.35931,0.483897,0.301608,0.577342,0.262663,0.794986,0.54958,0.808086,0.152511,0.439591,0.535941,0.308018,0.419837,0.579191,0.250428,0.25212,0.10286,0.288332,0.599679,0.665108,0.636285,0.495234,0.251613,0.208527,0.0939072,0.458415,0.318952,0.23535,0.215189,0.313412,0.0472787,0.0386893,0.0863359,0.222346,0.361511,0.997037,0.238509,0.38214,1,0.203554,0.472087,0.509015,0.206371,0.441013,0.794008,0.971623,0.796384,0.55043,0.68778,0.554298,0.0436545,0.0595577,0.214685,0.58147,0.27732,0.368466,0.121382,0.152739,0.0782244,0.190497,0.316269,0.180456,0.405196,0.518716,0.159365,0.165808,0.194372,0.614764,0.553415,0.644794,0.44178,0.44149,0.221588,1,0.579371,0.606339,0.529167,0.0214475,0.417046,0.663152,0.894841,0.475752,0.168289,0.46859,0.304604,0.666369,0.308337,0.295091,0.768945,0.350911,0.49068,0.516584,0.400117,0.820687,0.545486,0.709357,0.509759,0.472006,0.152455,0.981265,0.459134,0.698666,0.247154,0.623253,0.255508,0.830815,0.088709,0.126082,0.0770623,0.263328},int(p*nModes+n) : rdtable; + modesT60s(i) = t60*pow(1-(modesFreqs(i)/2555.3)*t60DecayRatio,t60DecaySlope); +}; + + +//-------`(pm.)frenchBell`---------- +// French church bell modal model. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 1 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// This function also implement a virtual exciter to drive the model. +// +// #### Usage +// +// ``` +// excitation : frenchBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) : _ +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `strikePosition`: strike position (0-6) +// * `strikeCutoff`: cuttoff frequency of the strike genarator (recommended: ~7000Hz) +// * `strikeSharpness`: sharpness of the strike (recommended: ~0.25) +// * `gain`: gain of the strike (0-1) +// * `trigger` signal (0: off, 1: on) +//---------------------------------- +frenchBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) = +strikeModel(10,strikeCutoff,strikeSharpness,gain,trigger) : +frenchBellModel(50,strikePosition,30,1,3); + + +//-------`(pm.)frenchBell_ui`---------- +// French church bell physical model based on [`frenchBell`](#frenchbell) with +// built-in UI. +// +// #### Usage +// +// ``` +// frenchBell_ui : _ +// ``` +//---------------------------------- +frenchBell_ui = +frenchBell(strikePosition,strikeCutoff,strikeSharpness,gain,gate) +with{ + strikePosition = nentry("v:frenchBell/[0]strikePosition",0,0,6,1); + strikeCutoff = hslider("v:frenchBell/[1]strikeCutOff",6500,20,20000,1); + strikeSharpness = hslider("v:frenchBell/[2]strikeSharpness",0.5,0.01,5,0.01); + gain = hslider("v:frenchBell/[3]gain",1,0,1,0.01); + gate = button("v:frenchBell/[4]gate"); +}; + + +//-------`(pm.)germanBellModel`---------- +// German church bell modal model generated by `mesh2faust` from +// `libraries/modalmodels/germanBell`. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 1 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// #### Usage +// +// ``` +// excitation : germanBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `nModes`: number of synthesized modes (max: 50) +// * `exPos`: excitation position (0-6) +// * `t60`: T60 in seconds (recommended value: 0.1) +// * `t60DecayRatio`: T60 decay ratio (recommended value: 1) +// * `t60DecaySlope`: T60 decay slope (recommended value: 5) +//---------------------------------- +germanBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) = _ <: par(i,nModes,modeFilter(modesFreqs(i),modesT60s(i),modesGains(int(exPos),i))) :> /(nModes) +with{ + nExPos = 7; + modesFreqs(n) = ba.take(n+1,(238.909,240.235,406.25,408.214,561.105,562.923,749.632,749.88,781.389,800.68,801.547,884.486,942.52,942.715,958.571,960.581,1016.87,1018.29,1022.29,1206.2,1206.87,1213.93,1222.77,1231.68,1345.65,1355.18,1356.55,1357.3,1389.29,1391.11,1420.17,1424.05,1424.31,1426.54,1582.3,1631.07,1638.15,1720.28,1726.7,1803.79,1827.08,1829.44,1922.87,1926.94,1940.96,1944.47,1948.2,1969.86,1992.24,2011.85)); + modesGains(p,n) = waveform{0.761411,0.797803,0.586057,0.225039,0.926354,0.813875,0.529871,0.158915,0.662516,0.30841,0.0454785,0.556082,0.784713,0.213035,0.956227,0.795165,0.313508,0.158531,0.301586,0.16832,0.281267,0.154237,0.217235,0.247239,0.522688,0.170303,0.320614,0.154857,0.414941,0.788364,0.713299,0.381592,0.707011,1,0.0106946,0.359763,0.0746156,0.431124,0.118053,0.52729,0.255303,0.646855,0.201145,0.919908,0.359389,0.253494,0.865695,0.0829263,0.222589,0.0415736,0.735774,0.769678,0.381416,0.197543,0.682389,0.614766,0.249525,0.289883,0.300319,0.443691,0.275272,0.370218,0.74879,0.161247,0.634353,0.498498,0.221988,0.350637,0.436817,0.436463,0.52508,0.842646,0.195324,0.224755,0.545681,0.353778,0.269044,0.327814,0.448952,0.852305,0.380503,1,0.458063,0.565058,0.354635,0.659529,0.449485,0.802014,0.283446,0.521563,0.374639,0.652112,0.181042,0.468394,0.430116,0.157207,0.414995,0.292737,0.487785,0.47768,0.481445,0.556988,0.561132,0.378265,0.291462,0.32325,0.482602,0.328248,0.196792,0.712254,0.389806,0.307751,0.792876,0.199098,0.288838,0.146811,0.0178444,0.394017,0.588212,0.489226,0.701486,0.940303,0.213191,0.0778845,0.474463,0.609972,0.16338,0.408376,0.330864,0.88999,0.0798101,1,0.167172,0.208727,0.227549,0.825903,0.531897,0.580946,0.215339,0.247319,0.268148,0.504088,0.160955,0.170316,0.230769,0.151191,0.0825031,0.141328,0.288079,0.499676,0.420355,0.487764,0.75371,0.492248,0.181364,0.20594,0.52497,0.325641,0.236827,0.931842,0.472981,0.312162,0.901032,0.270478,0.167112,0.0709698,0.166004,0.290745,0.425893,0.403633,0.581772,0.855694,0.0325587,0.0568359,0.241923,0.79931,0.181962,0.530283,0.41561,1,0.0291501,0.831155,0.119755,0.102188,0.132037,0.76603,0.442221,0.1749,0.142175,0.0140794,0.4375,0.85186,0.196836,0.0907522,0.551673,0.256528,0.0424377,0.490363,0.108178,0.503276,0.226584,0.312758,0.824079,0.48412,0.0347338,0.0619428,0.255097,0.145273,0.190359,0.995297,0.50342,0.217575,0.793975,0.357179,0.0409728,0.0187931,0.414458,0.15844,0.346233,0.0771673,0.175111,0.380567,0.497409,0.316164,0.488669,1,0.420657,0.442333,0.24706,0.796407,0.0104146,0.227079,0.10684,0.0289873,0.76757,0.0643122,0.0423098,0.715522,0.472117,0.392577,0.660433,0.803575,0.188653,0.0191653,0.873212,0.448719,0.0147128,0.618967,0.30718,0.345899,0.131394,0.193225,0.715283,0.40562,0.040637,0.0503336,0.0544331,0.0452023,0.152302,0.894549,0.443343,0.172071,0.647667,0.328993,0.0416014,0.0229488,0.551071,0.423544,0.862362,0.363526,0.769929,0.123452,0.710702,0.394895,0.556638,1,0.450925,0.422849,0.092187,0.413892,0.00995372,0.321146,0.160624,0.0300681,0.915385,0.4755,0.506951,0.387549,0.275591,0.468281,0.184776,0.186837,0.188195,0.0202785,0.697136,0.408862,0.0116935,0.349823,0.202301,0.461379,0.0559023,0.0582571,0.260608,0.181875,0.0271739,0.0249578,0.685089,0.470384,0.283194,0.33105,0.138349,0.338068,0.481992,0.178242,0.0155942,0.0110435,0.783771,0.442707,0.616478,0.381542,0.510892,0.045985,0.303119,0.0731909,0.547715,0.348941,0.149981,0.302158,0.284482,0.398177,0.00413049,0.180739,0.062839,0.0133459,0.347088,0.57637,0.240764,0.978481,0.452755,0.529742,0.340471,0.662282,0.444305,0.0429901,1,0.36194,0.0183372,0.626893,0.55285,0.384936},int(p*nModes+n) : rdtable; + modesT60s(i) = t60*pow(1-(modesFreqs(i)/2016.94)*t60DecayRatio,t60DecaySlope); +}; + + +//-------`(pm.)germanBell`---------- +// German church bell modal model. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 1 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// This function also implement a virtual exciter to drive the model. +// +// #### Usage +// +// ``` +// excitation : germanBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) : _ +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `strikePosition`: strike position (0-6) +// * `strikeCutoff`: cuttoff frequency of the strike genarator (recommended: ~7000Hz) +// * `strikeSharpness`: sharpness of the strike (recommended: ~0.25) +// * `gain`: gain of the strike (0-1) +// * `trigger` signal (0: off, 1: on) +//---------------------------------- +germanBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) = +strikeModel(10,strikeCutoff,strikeSharpness,gain,trigger) : +germanBellModel(50,strikePosition,30,1,2.5); + + +//-------`(pm.)germanBell_ui`---------- +// German church bell physical model based on [`germanBell`](#germanbell) with +// built-in UI. +// +// #### Usage +// +// ``` +// germanBell_ui : _ +// ``` +//---------------------------------- +germanBell_ui = +germanBell(strikePosition,strikeCutoff,strikeSharpness,gain,gate) +with{ + strikePosition = nentry("v:germanBell/[0]strikePosition",0,0,6,1); + strikeCutoff = hslider("v:germanBell/[1]strikeCutOff",6500,20,20000,1); + strikeSharpness = hslider("v:germanBell/[2]strikeSharpness",0.5,0.01,5,0.01); + gain = hslider("v:germanBell/[3]gain",1,0,1,0.01); + gate = button("v:germanBell/[4]gate"); +}; + + +//-------`(pm.)russianBellModel`---------- +// Russian church bell modal model generated by `mesh2faust` from +// `libraries/modalmodels/russianBell`. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 2 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// #### Usage +// +// ``` +// excitation : russianBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `nModes`: number of synthesized modes (max: 50) +// * `exPos`: excitation position (0-6) +// * `t60`: T60 in seconds (recommended value: 0.1) +// * `t60DecayRatio`: T60 decay ratio (recommended value: 1) +// * `t60DecaySlope`: T60 decay slope (recommended value: 5) +//---------------------------------- +russianBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) = _ <: par(i,nModes,modeFilter(modesFreqs(i),modesT60s(i),modesGains(int(exPos),i))) :> /(nModes) +with{ + nExPos = 7; + modesFreqs(n) = ba.take(n+1,(136.491,136.992,258.958,260.419,316.489,318.411,393.852,393.949,454.677,467.493,503.594,503.637,530.46,531.046,541.16,546.158,578.335,579.863,660.026,708.34,716.915,717.23,775.839,776.066,783.356,783.464,788.826,789.463,800.348,806.758,876.788,880.414,887.297,888.222,916.815,919.711,937.686,984.606,1057.2,1058.45,1065.48,1082.27,1083.93,1086.55,1086.77,1108.2,1116.17,1149,1150.54,1199.54)); + modesGains(p,n) = waveform{0.925507,0.59752,0.0965671,0.45412,0.989773,0.593498,0.512541,0.124241,0.705411,0.292396,0.673399,0.302181,0.026234,0.286249,0.556267,1,0.250426,0.107711,0.427299,0.336295,0.616257,0.21442,0.0845294,0.231363,0.522724,0.559114,0.34847,0.854197,0.835576,0.735036,0.288494,0.117122,0.409686,0.363575,0.484943,0.170862,0.420531,0.164793,0.233847,0.861232,0.214037,0.283462,0.173153,0.876122,0.607809,0.294745,0.143142,0.332009,0.491878,0.626104,0.962027,0.584298,0.213653,0.420452,0.812329,0.545172,0.380744,0.331536,0.386801,0.248909,0.688756,0.313904,0.377894,0.595846,0.412274,0.739626,0.541148,0.393005,0.656637,0.847672,0.930653,0.288289,0.404938,0.657989,0.763949,0.574085,0.282241,1,0.429131,0.572049,0.734868,0.577477,0.520789,0.355593,0.890067,0.272391,0.448223,0.423969,0.392237,0.856091,0.0583794,0.784967,0.359527,0.576567,0.201513,0.642013,0.419308,0.340667,0.42319,0.860812,0.69402,0.423568,0.376987,0.568453,0.502302,0.280716,0.464041,0.395601,0.19985,0.0950398,0.64279,0.228326,0.484911,0.842353,0.161404,0.403432,0.655549,0.409098,0.699392,0.87605,1,0.185606,0.414255,0.695205,0.732612,0.478298,0.24947,0.927739,0.213135,0.227382,0.976352,0.642745,0.376311,0.260674,0.811034,0.264631,0.239979,0.261897,0.191642,0.78167,0.390679,0.382437,0.206714,0.22472,0.0676332,0.502611,0.301455,0.241029,0.224505,0.721193,0.436348,0.254062,0.480496,0.772371,0.210681,0.103415,0.485338,0.378334,0.228484,0.114877,0.68676,0.296942,0.50742,0.99747,0.0377103,0.132212,0.319547,0.192032,0.520574,0.585844,0.419362,0.0847317,0.134544,0.194762,0.616689,0.39736,0.298809,0.914746,0.0513371,0.0543569,0.989159,0.602892,0.145582,0.102149,0.129022,0.116485,0.279988,0.39427,0.290139,1,0.708655,0.780555,0.387526,0.0395217,0.00964067,0.24368,0.0740625,0.619315,0.447395,0.292497,0.295458,0.163748,0.521375,0.864533,0.0773408,0.0334231,0.345121,0.27886,0.223876,0.307756,0.763106,0.424707,0.487201,0.968962,0.00911747,0.0324653,0.334275,0.166787,0.312498,0.264262,0.35488,0.37559,0.261094,0.565006,0.474935,0.31352,0.251249,0.735352,0.0189072,0.0153634,0.786225,0.503299,0.369038,0.250765,0.673019,0.387573,0.742025,0.749056,0.261714,0.751868,0.771816,1,0.459484,0.0124402,0.0105394,0.964109,0.457052,0.532316,0.407128,0.697241,0.1522,0.0895893,0.406175,0.65104,0.0233951,0.010107,0.0722347,0.066634,0.195489,0.41674,0.654451,0.382782,0.305396,0.631501,0.00162802,0.0140906,0.762915,0.410245,0.189436,0.0604462,0.624941,0.439781,0.516273,0.896678,0.273298,0.202868,0.0996022,0.257657,0.0174508,0.0157859,0.429433,0.202184,0.443111,0.343811,0.447562,0.268694,0.753551,0.529426,0.0772973,0.097696,0.446414,0.261678,0.169035,0.0116219,0.0207399,1,0.488856,0.413029,0.252661,0.148369,0.0919644,0.0330634,0.268764,0.441849,0.0139873,0.0108584,0.657799,0.488248,0.375433,0.958179,0.761492,0.40949,0.151709,0.314931,0.0036118,0.013307,1,0.605343,0.550506,0.363516,0.255278,0.137537,0.448881,0.867615,0.483247,0.308622,0.348444,0.534835,0.0157716,0.0128965,0.147608,0.0762611,0.762224,0.511585,0.985863,0.540227,0.691691,0.905296,0.397521,0.69794,0.423289,0.924613,0.491559,0.00567911,0.0106002,0.647916,0.324182,0.579449,0.451936,0.877897},int(p*nModes+n) : rdtable; + modesT60s(i) = t60*pow(1-(modesFreqs(i)/1201.01)*t60DecayRatio,t60DecaySlope); +}; + + +//-------`(pm.)russianBell`---------- +// Russian church bell modal model. +// +// Modeled after D.Bartocha and Baron, Influence of Tin Bronze Melting and +// Pouring Parameters on Its Properties and Bell' Tone, Archives of Foundry +// Engineering, 2016. +// +// Model height is 2 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// This function also implement a virtual exciter to drive the model. +// +// #### Usage +// +// ``` +// excitation : russianBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) : _ +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `strikePosition`: strike position (0-6) +// * `strikeCutoff`: cuttoff frequency of the strike genarator (recommended: ~7000Hz) +// * `strikeSharpness`: sharpness of the strike (recommended: ~0.25) +// * `gain`: gain of the strike (0-1) +// * `trigger` signal (0: off, 1: on) +//---------------------------------- +russianBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) = +strikeModel(10,strikeCutoff,strikeSharpness,gain,trigger) : +russianBellModel(50,strikePosition,30,1,3); + + +//-------`(pm.)russianBell_ui`---------- +// Russian church bell physical model based on [`russianBell`](#russianbell) with +// built-in UI. +// +// #### Usage +// +// ``` +// russianBell_ui : _ +// ``` +//---------------------------------- +russianBell_ui = +russianBell(strikePosition,strikeCutoff,strikeSharpness,gain,gate) +with{ + strikePosition = nentry("v:russianBell/[0]strikePosition",0,0,6,1); + strikeCutoff = hslider("v:russianBell/[1]strikeCutOff",6500,20,20000,1); + strikeSharpness = hslider("v:russianBell/[2]strikeSharpness",0.5,0.01,5,0.01); + gain = hslider("v:russianBell/[3]gain",1,0,1,0.01); + gate = button("v:russianBell/[4]gate"); +}; + +//-------`(pm.)standardBellModel`---------- +// Standard church bell modal model generated by `mesh2faust` from +// `libraries/modalmodels/standardBell`. +// +// Modeled after T. Rossing and R. Perrin, Vibrations of Bells, Applied +// Acoustics 2, 1987. +// +// Model height is 1.8 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// #### Usage +// +// ``` +// excitation : standardBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `nModes`: number of synthesized modes (max: 50) +// * `exPos`: excitation position (0-6) +// * `t60`: T60 in seconds (recommended value: 0.1) +// * `t60DecayRatio`: T60 decay ratio (recommended value: 1) +// * `t60DecaySlope`: T60 decay slope (recommended value: 5) +//---------------------------------- +standardBellModel(nModes,exPos,t60,t60DecayRatio,t60DecaySlope) = _ <: par(i,nModes,modeFilter(modesFreqs(i),modesT60s(i),modesGains(int(exPos),i))) :> /(nModes) +with{ + nExPos = 7; + modesFreqs(n) = ba.take(n+1,(490.25,493.646,924.838,927.779,1181.21,1186.94,1348.84,1349.5,1560.33,1635.97,1706.73,1712.89,1745.05,1745.25,2005.51,2025.47,2053.88,2142.37,2151.4,2408.16,2534.11,2536.42,2623.3,2628.4,2711.57,2712.46,2823.23,2827.22,2863.42,2874.19,2923,2925.69,3032.52,3042.15,3208.57,3392.52,3485.92,3493.65,3539.8,3550.56,3678.71,3719.04,3722.59,3786.28,3789.38,3993.59,3998.43,4123.41,4164.83,4187.98)); + modesGains(p,n) = waveform{0.691911,0.622333,0.548651,0.463306,0.826946,0.749513,0.2242,0.642678,0.760442,0.326054,0.276463,0.359344,0.18258,0.686765,0.457159,0.839015,0.845338,0.372377,0.306417,0.147381,0.359707,0.653537,0.27553,0.401233,0.435417,0.251481,0.190062,0.773372,0.315014,0.228812,0.521512,0.411542,0.720762,1,0.286502,0.338938,0.119995,0.432289,0.409677,0.156272,0.298871,0.250786,0.640776,0.209431,0.17001,0.390014,0.301698,0.799413,0.980581,0.385,0.82544,0.818894,0.349616,0.235396,0.783164,0.821914,0.28411,0.430286,0.507671,0.326254,0.260488,0.273364,0.20518,0.714852,0.47995,0.803637,0.683943,0.355371,0.406924,0.656257,0.423025,0.413515,0.38636,0.384787,0.389448,0.813367,0.234988,1,0.311268,0.350245,0.403856,0.646143,0.500485,0.833553,0.431768,0.467064,0.298979,0.487413,0.514907,0.369383,0.106197,0.494224,0.816079,0.535807,0.379873,0.380201,0.606306,0.516117,0.748449,0.556948,0.587066,0.584423,0.394866,0.341121,0.433458,0.455987,0.361237,0.42939,0.122969,0.133175,0.505176,0.513985,0.0554619,0.604942,0.372074,0.381126,0.314354,0.499636,0.518711,0.923792,0.259544,0.576517,0.553915,0.585444,0.245369,1,0.117757,0.977318,0.652862,0.509314,0.14855,0.506402,0.180059,0.356005,0.38681,0.279354,0.205792,0.551055,0.689107,0.445724,0.306857,0.324747,0.603621,0.394466,0.288613,0.264697,0.60612,0.20274,0.267271,0.925656,0.439228,0.425884,0.626633,0.547204,0.230022,0.225654,0.392697,0.493474,0.149857,0.0604048,0.693889,0.740271,0.175485,0.704998,0.329732,0.153026,0.125744,0.286995,0.278878,0.812372,0.0562174,0.241479,0.294525,0.358834,0.171047,0.847604,0.17228,0.97521,0.892073,0.613987,0.0659213,0.301583,0.0610847,0.125438,0.145151,0.180086,0.124231,0.260161,0.337573,0.203743,0.655798,0.425893,0.902347,0.500686,0.311173,0.215561,0.349591,0.0854218,0.0805062,1,0.338652,0.295396,0.698314,0.664972,0.118983,0.0881905,0.31158,0.391136,0.151915,0.239504,0.685742,0.884332,0.288516,0.768688,0.274851,0.0490311,0.0357865,0.293303,0.249461,0.493771,0.340984,0.467623,0.216631,0.255235,0.0988695,0.46198,0.147247,0.640196,1,0.551938,0.0453732,0.189907,0.0197542,0.0309217,0.769837,0.360418,0.384041,0.867434,0.398948,0.171848,0.748652,0.301957,0.860611,0.958674,0.54903,0.272753,0.372753,0.0180728,0.0292353,0.8502,0.224583,0.214805,0.670319,0.586433,0.0435142,0.0388574,0.144811,0.157061,0.155569,0.418334,0.673656,0.749573,0.337354,0.747254,0.255997,0.0239656,0.0310719,0.721087,0.700616,0.199051,0.511844,0.849485,0.700682,0.778658,0.171289,0.261973,0.129228,0.328597,0.781821,0.583813,0.0806713,0.416876,0.0118202,0.00868563,1,0.461884,0.186882,0.641364,0.994705,0.501902,0.566449,0.0678845,0.139737,0.462582,0.318656,0.233947,0.495941,0.0314028,0.0146478,0.70432,0.124953,0.132549,0.457126,0.378636,0.0169362,0.0195494,0.204155,0.294401,0.271367,0.730857,0.459322,0.433078,0.325171,0.734536,0.416205,0.012873,0.0388489,0.821567,0.863683,0.0920531,0.393972,0.539544,0.832052,0.842732,0.241144,0.479558,0.283092,0.477845,0.385473,0.436587,0.144308,0.642395,0.0215791,0.00779029,0.563714,0.838279,0.410004,0.829086,1,0.630598,0.0233729,0.496217,0.711042,0.914266,0.695042,0.331894,0.898442,0.028568,0.0174966,0.482846},int(p*nModes+n) : rdtable; + modesT60s(i) = t60*pow(1-(modesFreqs(i)/4191.95)*t60DecayRatio,t60DecaySlope); +}; + + +//-------`(pm.)standardBell`---------- +// Standard church bell modal model. +// +// Modeled after T. Rossing and R. Perrin, Vibrations of Bells, Applied +// Acoustics 2, 1987. +// +// Model height is 1.8 m. +// +// This model contains 7 excitation positions going linearly from the +// bottom to the top of the bell. Obviously, a model with more excitation +// position could be regenerated using `mesh2faust`. +// +// This function also implement a virtual exciter to drive the model. +// +// #### Usage +// +// ``` +// excitation : standardBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) : _ +// ``` +// +// Where: +// +// * `excitation`: the excitation signal +// * `strikePosition`: strike position (0-6) +// * `strikeCutoff`: cuttoff frequency of the strike genarator (recommended: ~7000Hz) +// * `strikeSharpness`: sharpness of the strike (recommended: ~0.25) +// * `gain`: gain of the strike (0-1) +// * `trigger` signal (0: off, 1: on) +//---------------------------------- +standardBell(strikePosition,strikeCutoff,strikeSharpness,gain,trigger) = +strikeModel(10,strikeCutoff,strikeSharpness,gain,trigger) : +standardBellModel(50,strikePosition,30,1,2.5); + + +//-------`(pm.)standardBell_ui`---------- +// Standard church bell physical model based on [`standardBell`](#standardbell) with +// built-in UI. +// +// #### Usage +// +// ``` +// standardBell_ui : _ +// ``` +//---------------------------------- +standardBell_ui = +standardBell(strikePosition,strikeCutoff,strikeSharpness,gain,gate) +with{ + strikePosition = nentry("v:standardBell/[0]strikePosition",0,0,6,1); + strikeCutoff = hslider("v:standardBell/[1]strikeCutOff",6500,20,20000,1); + strikeSharpness = hslider("v:standardBell/[2]strikeSharpness",0.5,0.01,5,0.01); + gain = hslider("v:standardBell/[3]gain",1,0,1,0.01); + gate = button("v:standardBell/[4]gate"); +}; + + +//==============================Vocal Synthesis=========================================== +// Vocal synthesizer functions (source/filter, fof, etc.). +//======================================================================================== + +//-------`(pm.)formantValues`---------- +// Formant data values. +// +// The formant data used here come from the CSOUND manual +// . +// +// #### Usage +// +// ``` +// ba.take(j+1,formantValues.f(i)) : _ +// ba.take(j+1,formantValues.g(i)) : _ +// ba.take(j+1,formantValues.bw(i)) : _ +// ``` +// +// Where: +// +// * `i`: formant number +// * `j`: (voiceType*nFormants)+vowel +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: +// soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +//-------------------------------------- +formantValues = environment { + f(0) = (800,400,350,450,325,600,400,250,400,350,660,440,270,430,370,800, + 350,270,450,325,650,400,290,400,350); // formant 0 freqs + f(1) = (1150,1600,1700,800,700,1040,1620,1750,750,600,1120,1800,1850,820,630, + 1150,2000,2140,800,700,1080,1700,1870,800,600); // formant 1 freqs + f(2) = (2800,2700,2700,2830,2530,2250,2400,2600,2400,2400,2750,2700,2900,2700,2750, + 2900,2800,2950,2830,2700,2650,2600,2800,2600,2700); // formant 2 freqs + f(3) = (3500,3300,3700,3500,3500,2450,2800,3050,2600,2675,3000,3000,3350,3000,3000, + 3900,3600,3900,3800,3800,2900,3200,3250,2800,2900); // formant 3 freqs + f(4) = (4950,4950,4950,4950,4950,2750,3100,3340,2900,2950,3350,3300,3590,3300,3400, + 4950,4950,4950,4950,4950,3250,3580,3540,3000,3300); // formant 4 freqs + g(0) = (1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1); // formant 0 gains + g(1) = (0.630957,0.063096,0.100000,0.354813,0.251189,0.446684,0.251189,0.031623, + 0.281838,0.100000,0.501187,0.199526,0.063096,0.316228,0.100000, + 0.501187,0.100000,0.251189,0.281838,0.158489,0.501187,0.199526,0.177828, + 0.316228,0.100000); // formant 1 gains + g(2) = (0.100000,0.031623,0.031623,0.158489,0.031623,0.354813,0.354813,0.158489, + 0.089125,0.025119,0.070795,0.125893,0.063096,0.050119,0.070795, + 0.025119,0.177828,0.050119,0.079433,0.017783,0.446684,0.251189,0.125893, + 0.251189,0.141254); // formant 2 gains + g(3) = (0.015849,0.017783,0.015849,0.039811,0.010000,0.354813,0.251189,0.079433, + 0.100000,0.039811,0.063096,0.100000,0.015849,0.079433,0.031623, + 0.100000,0.010000,0.050119,0.079433,0.010000,0.398107,0.199526,0.100000, + 0.251189,0.199526); // formant 3 gains + g(4) = (0.001000,0.001000,0.001000,0.001778,0.000631,0.100000,0.125893,0.039811, + 0.010000,0.015849,0.012589,0.100000,0.015849,0.019953,0.019953, + 0.003162,0.001585,0.006310,0.003162,0.001000,0.079433,0.100000,0.031623, + 0.050119,0.050119); // formant 4 gains + bw(0) = (80,60,50,70,50,60,40,60,40,40,80,70,40,40,40,80,60,60,40,50, + 50,70,40,70,40); // formant 0 bandwidths + bw(1) = (90,80,100,80,60,70,80,90,80,80,90,80,90,80,60,90,100,90,80,60, + 90,80,90,80,60); // formant 1 bandwidths + bw(2) = (120,120,120,100,170,110,100,100,100,100,120,100,100,100,100, + 120,120,100,100,170,120,100,100,100,100); // formant 2 bandwidths + bw(3) = (130,150,150,130,180,120,120,120,120,120,130,120,120,120,120, + 130,150,120,120,180,130,120,120,130,120); // formant 3 bandwidths + bw(4) = (140,200,200,135,200,130,120,120,120,120,140,120,120,120,120, + 140,200,120,120,200,140,120,120,135,120); // formant 4 bandwidths +}; + + +// array of values used to multiply BWs by to get attack Bws for FOF version. +// min/max values per vowel (AEIOU) and per gender (M/F). Index by: +// gender*5 + vowel; +// values were chosen based on informal listening tests +bwMultMins = (1.0, 1.25, 1.25, 1.0, 1.5, 2.0, 3.0, 3.0, 2.0, 2.0); +bwMultMaxes = (10.0, 2.5, 2.5, 10.0, 4.0, 15.0, 12.0, 12.0, 12.0, 12.0); + + +// minimum/maximum frequency values per gender (M/F) used in the calculation +// of the attack Bws from the release Bws in the FOF version +// values are based on arbitrary maximum/minimum singing values +// in Hz for male/female voices +minGenderFreq = (82.41,174.61); +maxGenderFreq = (523.25,1046.5); + + +//--------------`(pm.)voiceGender`----------------- +// Calculate the gender for the provided `voiceType` value. (0: male, 1: female) +// +// #### Usage +// +// ``` +// voiceGender(voiceType) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +//--------------------------------------------- +declare voiceGender author "Mike Olsen"; + +voiceGender(voiceType) = ba.if(voiceType == 0,1,ba.if(voiceType == 3,1,0)); + + +//-----------`(pm.)skirtWidthMultiplier`------------ +// Calculates value to multiply bandwidth to obtain `skirtwidth` +// for a Fof filter. +// +// #### Usage +// +// ``` +// skirtWidthMultiplier(vowel,freq,gender) : _ +// ``` +// +// Where: +// +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `freq`: the fundamental frequency of the excitation signal +// * `gender`: gender of the voice used in the fof filter (0: male, 1: female) +//--------------------------------------------- +declare skirtWidthMultiplier author "Mike Olsen"; + +skirtWidthMultiplier(vowel,freq,gender) = (multMax-multMin)*skirtParam+multMin +with { + nVowels = 5; + index = gender*nVowels + vowel; + multMin = bwMultMins : ba.selectn(10,index); + multMax = bwMultMaxes : ba.selectn(10,index); + freqMin = minGenderFreq : ba.selectn(2,gender); + freqMax = maxGenderFreq : ba.selectn(2,gender); + skirtParam = ba.if(freq <= freqMin,0.0,ba.if(freq >= freqMax,1.0, + (1.0/(freqMax-freqMin))*(freq-freqMin))); +}; + + +//--------------`(pm.)autobendFreq`----------------- +// Autobends the center frequencies of formants 1 and 2 based on +// the fundamental frequency of the excitation signal and leaves +// all other formant frequencies unchanged. Ported from `chant-lib`. +// +// #### Reference +// +// . +// +// #### Usage +// +// ``` +// _ : autobendFreq(n,freq,voiceType) : _ +// ``` +// +// Where: +// +// * `n`: formant index +// * `freq`: the fundamental frequency of the excitation signal +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * input is the center frequency of the corresponding formant +//--------------------------------------------- +declare autobendFreq author "Mike Olsen"; + +autobendFreq(n,freq,voiceType) = autobend(n) +with { + autobend(0) = _ <: ba.if(_ <= freq,freq,_); + autobend(1) = _ <: ba.if(voiceType != 2, + _ <: ba.if((_ >= 1300)&(freq >= 200), + _ -(freq-200)*(_-1300)/1050, + ba.if(_ <= (30 + 2*freq),30 + 2*freq,_)), _); + autobend(n) = _; +}; + + +//--------------`(pm.)vocalEffort`----------------- +// Changes the gains of the formants based on the fundamental +// frequency of the excitation signal. Higher formants are +// reinforced for higher fundamental frequencies. +// Ported from `chant-lib`. +// +// #### Reference +// +// . +// +// #### Usage +// +// ``` +// _ : vocalEffort(freq,gender) : _ +// ``` +// +// Where: +// +// * `freq`: the fundamental frequency of the excitation signal +// * `gender`: the gender of the voice type (0: male, 1: female) +// * input is the linear amplitude of the formant +//--------------------------------------------- +declare vocalEffort author "Mike Olsen"; + +vocalEffort(freq,gender) = _ <: ba.if(gender == 0,*(3+1.1*(400-freq)/300),*(0.8+1.05*(1000-freq)/1250)); + + +//-------------------------`(pm.)fof`-------------------------- +// Function to generate a single Formant-Wave-Function. +// +// #### Reference +// +// . +// +// #### Usage +// +// ``` +// _ : fof(fc,bw,a,g) : _ +// ``` +// +// Where: +// +// * `fc`: formant center frequency, +// * `bw`: formant bandwidth (Hz), +// * `sw`: formant skirtwidth (Hz) +// * `g`: linear scale factor (g=1 gives 0dB amplitude response at fc) +// * input is an impulse signal to excite filter +//--------------------------------------------------------- +declare fof author "Mike Olsen"; + +fof(fc,bw,sw,g) = _ <: (_',_) : (f * s) +with { + T = 1/ma.SR; // sample period + pi = ma.PI; // pi + u1 = exp(-sw*pi*T); // exponential controlling rise + u2 = exp(-bw*pi*T); // exponential controlling decay + a1 = -1*(u1+u2); // a1 filter coefficient + a2 = u1*u2; // a2 filter coefficient + G0 = 1/(1+a1+a2); // magnitude at DC + b0 = g/G0; // filter gain + s = os.hs_oscsin(fc); // hardsyncing wavetable oscillator + f = fi.tf2(b0,0,0,a1,a2); // biquad filter +}; + + +//-------------------------`(pm.)fofSH`------------------------- +// FOF with sample and hold used on `bw` and a parameter +// used in the filter-cycling FOF function `fofCycle`. +// +// #### Reference +// +// . +// +// #### Usage +// +// ``` +// _ : fofSH(fc,bw,a,g) : _ +// ``` +// +// Where: all parameters same as for [`fof`](#fof) +//--------------------------------------------------------- +declare fofSH author "Mike Olsen"; + +fofSH(fc,bw,a,g) = _ <: (((_,bw):ba.sAndH),((_,a):ba.sAndH),_) : (fc,_,_,g,_') : fof; + + +//----------------------`(pm.)fofCycle`------------------------- +// FOF implementation where time-varying filter parameter noise is +// mitigated by using a cycle of `n` sample and hold FOF filters. +// +// #### Reference +// +// . +// +// #### Usage +// +// ``` +// _ : fofCycle(fc,bw,a,g,n) : _ +// ``` +// +// Where: +// +// * `n`: the number of FOF filters to cycle through +// * all other parameters are same as for [`fof`](#fof) +//--------------------------------------------------------- +declare fofCycle author "Mike Olsen"; + +fofCycle(fc,bw,a,g,n) = _ : ba.cycle(n) : par(i,n,fofSH(fc,bw,a,g)) :> _; + + +//----------------------`(pm.)fofSmooth`------------------------- +// FOF implementation where time-varying filter parameter +// noise is mitigated by lowpass filtering the filter +// parameters `bw` and `a` with [smooth](#smooth). +// +// #### Usage +// +// ``` +// _ : fofSmooth(fc,bw,sw,g,tau) : _ +// ``` +// +// Where: +// +// * `tau`: the desired smoothing time constant in seconds +// * all other parameters are same as for [`fof`](#fof) +//--------------------------------------------------------- +declare fofSmooth author "Mike Olsen"; + +fofSmooth(fc,bw,sw,g,tau) = fof(fc,bw2,sw2,g) +with{ + sw2 = sw : si.smooth(ba.tau2pole(tau)); + bw2 = bw : si.smooth(ba.tau2pole(tau)); +}; + + +//-------`(pm.)formantFilterFofCycle`-------------- +// Formant filter based on a single FOF filter. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. A cycle of `n` fof filters with sample-and-hold is +// used so that the fof filter parameters can be varied in realtime. +// This technique is more robust but more computationally expensive than +// [`formantFilterFofSmooth`](#formantFilterFofSmooth).Voice type can be +// selected but must correspond to +// the frequency range of the provided source to be realistic. +// +// #### Usage +// +// ``` +// _ : formantFilterFofCycle(voiceType,vowel,nFormants,i,freq) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, +// 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `nFormants`: number of formant regions in frequency domain, typically 5 +// * `i`: formant number (i.e. 0 - 4) used to index formant data value arrays +// * `freq`: fundamental frequency of excitation signal. Used to calculate +// rise time of envelope +//-------------------------------------- +declare formantFilterFofCycle author "Mike Olsen"; + +formantFilterFofCycle(voiceType,vowel,nFormants,i,freq) = + fofCycle(formantFreq(i),formantBw(i),formantSw(i),formantGain(i),n) +with{ + n = 3; // number of fof filters to cycle between + index = (voiceType*nFormants)+vowel; // index of formant values + // formant center frequency using autobend correction + formantFreq(i) = ba.listInterp(formantValues.f(i),index) : autobendFreq(i,freq,voiceType); + // formant amplitude using vocal effort correction + formantGain(i) = ba.listInterp(formantValues.g(i),index) : vocalEffort(freq,gender); + formantBw(i) = ba.listInterp(formantValues.bw(i),index); // formant bandwidth + // formant skirtwidth + formantSw(i) = skirtWidthMultiplier(vowel,freq,gender)*formantBw(i); + gender = voiceGender(voiceType); // gender of voice +}; + + +//-------`(pm.)formantFilterFofSmooth`-------------- +// Formant filter based on a single FOF filter. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Fof filter parameters are lowpass filtered +// to mitigate possible noise from varying them in realtime. +// Voice type can be selected but must correspond to +// the frequency range of the provided source to be realistic. +// +// #### Usage +// +// ``` +// _ : formantFilterFofSmooth(voiceType,vowel,nFormants,i,freq) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, +// 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `nFormants`: number of formant regions in frequency domain, typically 5 +// * `i`: formant number (i.e. 1 - 5) used to index formant data value arrays +// * `freq`: fundamental frequency of excitation signal. Used to calculate +// rise time of envelope +//-------------------------------------- +declare formantFilterFofSmooth author "Mike Olsen"; + +formantFilterFofSmooth(voiceType,vowel,nFormants,i,freq) = + fofSmooth(formantFreq(i),formantBw(i),formantSw(i),formantGain(i),tau) +with{ + tau = 0.001; + index = (voiceType*nFormants)+vowel; // index of formant values + // formant center frequency using autobend correction + formantFreq(i) = ba.listInterp(formantValues.f(i),index) : autobendFreq(i,freq,voiceType); + // formant amplitude using vocal effort correction + formantGain(i) = ba.listInterp(formantValues.g(i),index) : vocalEffort(freq,gender); + formantBw(i) = ba.listInterp(formantValues.bw(i),index); // formant bandwidth + // formant skirtwidth + formantSw(i) = skirtWidthMultiplier(vowel,freq,gender)*formantBw(i); + gender = voiceGender(voiceType); // gender of voice +}; + + +//-------`(pm.)formantFilterBP`-------------- +// Formant filter based on a single resonant bandpass filter. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the provided source to be realistic. +// +// #### Usage +// +// ``` +// _ : formantFilterBP(voiceType,vowel,nFormants,i,freq) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `nFormants`: number of formant regions in frequency domain, typically 5 +// * `i`: formant index used to index formant data value arrays +// * `freq`: fundamental frequency of excitation signal. +//-------------------------------------- +formantFilterBP(voiceType,vowel,nFormants,i,freq) = + fi.resonbp(formantFreq(i),formantFreq(i)/formantBw(i), + formantGain(i)) +with{ + index = (voiceType*nFormants)+vowel; // index of formant values + // formant center frequency using autobend correction + formantFreq(i) = ba.listInterp(formantValues.f(i),index) : autobendFreq(i,freq,voiceType); + // formant amplitude using vocal effort correction + formantGain(i) = ba.listInterp(formantValues.g(i),index) : vocalEffort(freq,gender); + formantBw(i) = ba.listInterp(formantValues.bw(i),index); // formant bandwidth + gender = voiceGender(voiceType); // gender of voice +}; + + +//-------`(pm.)formantFilterbank`-------------- +// Formant filterbank which can use different types of filterbank +// functions and different excitation signals. Formant parameters are +// linearly interpolated allowing to go smoothly from one vowel to another. +// Voice type can be selected but must correspond to the frequency range +// of the provided source to be realistic. +// +// #### Usage +// +// ``` +// _ : formantFilterbank(voiceType,vowel,formantGen,freq) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `formantGen`: the specific formant filterbank function +// (i.e. FormantFilterbankBP, FormantFilterbankFof,...) +// * `freq`: fundamental frequency of excitation signal. Needed for FOF +// version to calculate rise time of envelope +//-------------------------------------- +declare formantFilterbank author "Mike Olsen"; + +formantFilterbank(voiceType,vowel,formantGen,freq) = + _ <: par(i,nFormants,formantGen(voiceType,vowel,nFormants,i,freq)) :> _ +with{ + nFormants = 5; +}; + + +//-----`(pm.)formantFilterbankFofCycle`----- +// Formant filterbank based on a bank of fof filters. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the provided source to be realistic. +// +// #### Usage +// +// ``` +// _ : formantFilterbankFofCycle(voiceType,vowel,freq) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `freq`: the fundamental frequency of the excitation signal. Needed to calculate the skirtwidth +// of the FOF envelopes and for the autobendFreq and vocalEffort functions +//------------------------------------- +declare formantFilterbankFofCycle author "Mike Olsen"; + +formantFilterbankFofCycle(voiceType,vowel,freq) = +formantFilterbank(voiceType,vowel,formantFilterFofCycle,freq); + + +//-----`(pm.)formantFilterbankFofSmooth`---- +// Formant filterbank based on a bank of fof filters. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the provided source to be realistic. +// +// #### Usage +// +// ``` +// _ : formantFilterbankFofSmooth(voiceType,vowel,freq) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `freq`: the fundamental frequency of the excitation signal. Needed to +// calculate the skirtwidth of the FOF envelopes and for the +// autobendFreq and vocalEffort functions +//------------------------------------- +declare formantFilterbankFofSmooth author "Mike Olsen"; + +formantFilterbankFofSmooth(voiceType,vowel,freq) = +formantFilterbank(voiceType,vowel,formantFilterFofSmooth,freq); + + +//-------`(pm.)formantFilterbankBP`-------------- +// Formant filterbank based on a bank of resonant bandpass filters. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the provided source to be realistic. +// +// #### Usage +// +// ``` +// _ : formantFilterbankBP(voiceType,vowel,freq) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u) +// * `freq`: the fundamental frequency of the excitation signal. Needed for the autobendFreq and vocalEffort functions +//-------------------------------------- +formantFilterbankBP(voiceType,vowel,freq) = +formantFilterbank(voiceType,vowel,formantFilterBP,freq); + + +//-------`(pm.)SFFormantModel`-------------- +// Simple formant/vocal synthesizer based on a source/filter model. The `source` +// and `filterbank` must be specified by the user. `filterbank` must take the same +// input parameters as [`formantFilterbank`](#formantFilterbank) (`BP`/`FofCycle` +// /`FofSmooth`). +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the synthesized voice to be realistic. +// +// #### Usage +// +// ``` +// SFFormantModel(voiceType,vowel,exType,freq,gain,source,filterbank,isFof) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u +// * `exType`: voice vs. fricative sound ratio (0-1 where 1 is 100% fricative) +// * `freq`: the fundamental frequency of the source signal +// * `gain`: linear gain multiplier to multiply the source by +// * `isFof`: whether model is FOF based (0: no, 1: yes) +//-------------------------------------- +declare SFFormantModel author "Mike Olsen"; + +SFFormantModel(voiceType,vowel,exType,freq,gain,source,filterbank,isFof) = + excitation : resonance +with{ + breath = no.noise; + excitation = ba.if(isFof,source,source*(1-exType) + breath*exType : + *(gain)); + resonance = filterbank(voiceType,vowel,freq) <: ba.if(isFof,*(gain),_); +}; + + +//-------`(pm.)SFFormantModelFofCycle`------- +// Simple formant/vocal synthesizer based on a source/filter model. The source +// is just a periodic impulse and the "filter" is a bank of FOF filters. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the synthesized voice to be realistic. This model +// does not work with noise in the source signal so exType has been removed +// and model does not depend on SFFormantModel function. +// +// #### Usage +// +// ``` +// SFFormantModelFofCycle(voiceType,vowel,freq,gain) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u +// * `freq`: the fundamental frequency of the source signal +// * `gain`: linear gain multiplier to multiply the source by +//--------------------------------------- +declare SFFormantModelFofCycle author "Mike Olsen"; + +SFFormantModelFofCycle(voiceType,vowel,freq,gain) = +SFFormantModel(voiceType,vowel,0,freq,gain,os.lf_imptrain(freq), +formantFilterbankFofCycle,1); + + +//-------`(pm.)SFFormantModelFofSmooth`------- +// Simple formant/vocal synthesizer based on a source/filter model. The source +// is just a periodic impulse and the "filter" is a bank of FOF filters. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the synthesized voice to be realistic. +// +// #### Usage +// +// ``` +// SFFormantModelFofSmooth(voiceType,vowel,freq,gain) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u +// * `freq`: the fundamental frequency of the source signal +// * `gain`: linear gain multiplier to multiply the source by +//--------------------------------------- +declare SFFormantModelFofSmooth author "Mike Olsen"; + +SFFormantModelFofSmooth(voiceType,vowel,freq,gain) = +SFFormantModel(voiceType,vowel,0,freq,gain,os.lf_imptrain(freq), +formantFilterbankFofSmooth,1); + + +//-------`(pm.)SFFormantModelBP`-------------- +// Simple formant/vocal synthesizer based on a source/filter model. The source +// is just a sawtooth wave and the "filter" is a bank of resonant bandpass filters. +// Formant parameters are linearly interpolated allowing to go smoothly from +// one vowel to another. Voice type can be selected but must correspond to +// the frequency range of the synthesized voice to be realistic. +// +// The formant data used here come from the CSOUND manual +// . +// +// #### Usage +// +// ``` +// SFFormantModelBP(voiceType,vowel,exType,freq,gain) : _ +// ``` +// +// Where: +// +// * `voiceType`: the voice type (0: alto, 1: bass, 2: countertenor, 3: soprano, 4: tenor) +// * `vowel`: the vowel (0: a, 1: e, 2: i, 3: o, 4: u +// * `exType`: voice vs. fricative sound ratio (0-1 where 1 is 100% fricative) +// * `freq`: the fundamental frequency of the source signal +// * `gain`: linear gain multiplier to multiply the source by +//--------------------------------------- +SFFormantModelBP(voiceType,vowel,exType,freq,gain) = +SFFormantModel(voiceType,vowel,exType,freq,gain,os.sawtooth(freq), +formantFilterbankBP,0); + + +//-------`(pm.)SFFormantModelFofCycle_ui`---------- +// Ready-to-use source-filter vocal synthesizer with built-in user interface. +// +// #### Usage +// +// ``` +// SFFormantModelFofCycle_ui : _ +// ``` +//---------------------------------- +declare SFFormantModelFofCycle_ui author "Mike Olsen"; + +SFFormantModelFofCycle_ui = SFFormantModelFofCycle(voiceType,vowel,freq2,gain*corrFactor) +with{ + freq1 = hslider("v:vocal/[0]freq",440,50,1000,0.01); + gain = hslider("v:vocal/[1]gain",0.9,0,1,0.01); + corrFactor = 75.0; + voiceType = hslider("v:vocal/[2]voiceType",0,0,4,1); + vowel = hslider("v:vocal/[3]vowel",0,0,4,0.01) : si.smoo; + vibratoFreq = hslider("v:vocal/[5]vibratoFreq",6,1,10,0.01); + vibratoGain = hslider("v:vocal/[6]vibratoGain",0.5,0,1,0.01)*0.1; + freq2 = freq1*(os.osc(vibratoFreq)*vibratoGain+1); +}; + + +//-------`(pm.)SFFormantModelFofSmooth_ui`---------- +// Ready-to-use source-filter vocal synthesizer with built-in user interface. +// +// #### Usage +// +// ``` +// SFFormantModelFofSmooth_ui : _ +// ``` +//---------------------------------- +declare SFFormantModelFofSmooth_ui author "Mike Olsen"; + +SFFormantModelFofSmooth_ui = SFFormantModelFofSmooth(voiceType,vowel,freq2,gain*corrFactor) +with{ + freq1 = hslider("v:vocal/[0]freq",440,50,1000,0.01); + gain = hslider("v:vocal/[1]gain",0.9,0,1,0.01); + corrFactor = 25.0; + voiceType = hslider("v:vocal/[2]voiceType",0,0,4,1); + vowel = hslider("v:vocal/[3]vowel",0,0,4,0.01) : si.smoo; + vibratoFreq = hslider("v:vocal/[5]vibratoFreq",6,1,10,0.01); + vibratoGain = hslider("v:vocal/[6]vibratoGain",0.5,0,1,0.01)*0.1; + freq2 = freq1*(os.osc(vibratoFreq)*vibratoGain+1); +}; + + +//-------`(pm.)SFFormantModelBP_ui`---------- +// Ready-to-use source-filter vocal synthesizer with built-in user interface. +// +// #### Usage +// +// ``` +// SFFormantModelBP_ui : _ +// ``` +//---------------------------------- +SFFormantModelBP_ui = SFFormantModelBP(voiceType,vowel,fricative,freq2,gain) +with{ + freq1 = hslider("v:vocal/[0]freq",440,50,1000,0.01); + gain = hslider("v:vocal/[1]gain",0.9,0,1,0.01); + voiceType = hslider("v:vocal/[2]voiceType",0,0,4,1); + vowel = hslider("v:vocal/[3]vowel",0,0,4,0.01) : si.smoo; + fricative = hslider("v:vocal/[4]fricative",0,0,1,0.01) : si.smoo; + vibratoFreq = hslider("v:vocal/[5]vibratoFreq",6,1,10,0.01); + vibratoGain = hslider("v:vocal/[6]vibratoGain",0.5,0,1,0.01)*0.1; + freq2 = freq1*(os.osc(vibratoFreq)*vibratoGain+1); +}; + + +//-------`(pm.)SFFormantModelFofCycle_ui_MIDI`---------- +// Ready-to-use MIDI-controllable source-filter vocal synthesizer. +// +// #### Usage +// +// ``` +// SFFormantModelFofCycle_ui_MIDI : _ +// ``` +//---------------------------------- +SFFormantModelFofCycle_ui_MIDI = SFFormantModelFofCycle(voiceType,vowel,freq2,envelope)*outGain +with{ + freq1 = hslider("v:vocal/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:vocal/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:vocal/h:[0]midi/[2]gain[style:knob] + ",0.9,0,1,0.01); + corrFactor = 75.0; + envAttack = hslider("v:vocal/h:[0]midi/[3]envAttack[style:knob] + ",10,0,30,0.01)*0.001; + s = hslider("v:vocal/h:[0]midi/[4]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + voiceType = hslider("v:vocal/h:[1]otherParams/[0]voiceType + [style:knob]",0,0,4,1); + vowel = hslider("v:vocal/h:[1]otherParams/[1]vowel + [style:knob][midi:ctrl 1]",0,0,4,0.01) : si.smoo; + vibratoFreq = hslider("v:vocal/h:[1]otherParams/[3]vibratoFreq[style:knob] + ",6,1,10,0.01); + vibratoGain = hslider("v:vocal/h:[1]otherParams/[4]vibratoGain[style:knob] + ",0.5,0,1,0.01)*0.1; + outGain = hslider("v:vocal/h:[1]otherParams/[5]outGain[style:knob] + ",0.5,0,1,0.01); + t = button("v:vocal/[2]gate"); + + gate = t+s : min(1); + freq2 = freq1*bend*(os.osc(vibratoFreq)*vibratoGain+1); + envelope = gate*gain*corrFactor : si.smooth(ba.tau2pole(envAttack)); +}; + + +//-------`(pm.)SFFormantModelFofSmooth_ui_MIDI`---------- +// Ready-to-use MIDI-controllable source-filter vocal synthesizer. +// +// #### Usage +// +// ``` +// SFFormantModelFofSmooth_ui_MIDI : _ +// ``` +//---------------------------------- +SFFormantModelFofSmooth_ui_MIDI = SFFormantModelFofSmooth(voiceType,vowel,freq2,envelope)*outGain +with{ + freq1 = hslider("v:vocal/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:vocal/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:vocal/h:[0]midi/[2]gain[style:knob] + ",0.9,0,1,0.01); + corrFactor = 25.0; + envAttack = hslider("v:vocal/h:[0]midi/[3]envAttack[style:knob] + ",10,0,30,0.01)*0.001; + s = hslider("v:vocal/h:[0]midi/[4]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + voiceType = hslider("v:vocal/h:[1]otherParams/[0]voiceType + [style:knob]",0,0,4,1); + vowel = hslider("v:vocal/h:[1]otherParams/[1]vowel + [style:knob][midi:ctrl 1]",0,0,4,0.01) : si.smoo; + vibratoFreq = hslider("v:vocal/h:[1]otherParams/[3]vibratoFreq[style:knob] + ",6,1,10,0.01); + vibratoGain = hslider("v:vocal/h:[1]otherParams/[4]vibratoGain[style:knob] + ",0.5,0,1,0.01)*0.1; + outGain = hslider("v:vocal/h:[1]otherParams/[5]outGain[style:knob] + ",0.5,0,1,0.01); + t = button("v:vocal/[2]gate"); + + gate = t+s : min(1); + freq2 = freq1*bend*(os.osc(vibratoFreq)*vibratoGain+1); + envelope = gate*gain*corrFactor : si.smooth(ba.tau2pole(envAttack)); +}; + + +//-------`(pm.)SFFormantModelBP_ui_MIDI`---------- +// Ready-to-use MIDI-controllable source-filter vocal synthesizer. +// +// #### Usage +// +// ``` +// SFFormantModelBP_ui_MIDI : _ +// ``` +//---------------------------------- +SFFormantModelBP_ui_MIDI = SFFormantModelBP(voiceType,vowel,fricative,freq2,envelope)*outGain +with{ + freq1 = hslider("v:vocal/h:[0]midi/[0]freq[style:knob]",440,50,1000,0.01); + bend = ba.semi2ratio(hslider("v:vocal/h:[0]midi/[1]bend[hidden:1][midi:pitchwheel] + [style:knob]",0,-2,2,0.01)) : si.polySmooth(gate,0.999,1); + gain = hslider("v:vocal/h:[0]midi/[2]gain[style:knob] + ",0.9,0,1,0.01); + envAttack = hslider("v:vocal/h:[0]midi/[3]envAttack[style:knob] + ",10,0,30,0.01)*0.001; + s = hslider("v:vocal/h:[0]midi/[4]sustain[hidden:1][midi:ctrl 64] + [style:knob]",0,0,1,1); + voiceType = hslider("v:vocal/h:[1]otherParams/[0]voiceType + [style:knob]",0,0,4,1); + vowel = hslider("v:vocal/h:[1]otherParams/[1]vowel + [style:knob][midi:ctrl 1]",0,0,4,0.01) : si.smoo; + fricative = hslider("v:vocal/h:[1]otherParams/[2]fricative + [style:knob]",0,0,1,0.01) : si.smoo; + vibratoFreq = hslider("v:vocal/h:[1]otherParams/[3]vibratoFreq[style:knob] + ",6,1,10,0.01); + vibratoGain = hslider("v:vocal/h:[1]otherParams/[4]vibratoGain[style:knob] + ",0.5,0,1,0.01)*0.1; + outGain = hslider("v:vocal/h:[1]otherParams/[5]outGain[style:knob] + ",0.5,0,1,0.01); + t = button("v:vocal/[2]gate"); + + gate = t+s : min(1); + freq2 = freq1*bend*(os.osc(vibratoFreq)*vibratoGain+1); + envelope = gate*gain : si.smooth(ba.tau2pole(envAttack)); +}; + + +//=============================== Misc Functions ========================================= +// Various miscellaneous functions. +//======================================================================================== + +//-------`(pm.)allpassNL`-------------- +// Bidirectional block adding nonlinearities in both directions in a chain. +// Nonlinearities are created by modulating the coefficients of a passive +// allpass filter by the signal it is processing. +// +// #### Usage +// +// ``` +// chain(... : allpassNL(nonlinearity) : ...) +// ``` +// +// Where: +// +// * `nonlinearity`: amount of nonlinearity to be added (0-1) +//-------------------------------------- +allpassNL(nonlinearity) = par(i,2,nlf),_ +with{ + nlf = _ <: fi.allpassn(2,par(i,2,*(nonlinearity)*ma.PI)); +}; + + +//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +// UNCATEGORIZED FUNCTIONS (TODO) +//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +//-------`(pm).modalModel`-------------- +// +// Implement multiple resonance modes using resonant bandpass filters. +// +// #### Usage +// +// ``` +// _ : modalModel(n, freqs, t60s, gains) : _ +// ``` +// +// Where: +// +// * `n`: number of given modes +// * `freqs` : list of filter center freqencies +// * `t60s` : list of mode resonance durations (in seconds) +// * `gains` : list of mode gains (0-1) +// +// For example, to generate a model with 2 modes (440 Hz and 660 Hz, a +// fifth) where the higher one decays faster and is attenuated: +// +// ``` +// os.impulse : modalModel(2, (440, 660), +// (0.5, 0.25), +// (ba.db2linear(-1), ba.db2linear(-6)) : _ +// ``` +// +// Further reading: [Grumiaux et. al., 2017: +// Impulse-Response and CAD-Model-Based Physical Modeling in +// Faust](https://raw.githubusercontent.com/grame-cncm/faust/master-dev/tools/physicalModeling/ir2dsp/lacPaper2017.pdf) +// +//-------------------------------------- +modalModel(n,modeFreqs,modeRes,modeGains) = _ <: par(i,n,modeFilter(freqs(i),res(i),gain(i))) :> _ +with{ + freqs(i) = ba.take(i+1,modeFreqs); + res(i) = ba.take(i+1,modeRes); + gain(i) = ba.take(i+1,modeGains); +}; diff --git a/dist/examples/LIBRARIES/platform.lib b/dist/examples/LIBRARIES/platform.lib new file mode 100644 index 00000000..af91693d --- /dev/null +++ b/dist/examples/LIBRARIES/platform.lib @@ -0,0 +1,59 @@ +//#################################### platform.lib ######################################## +// A library to handle platform specific code in Faust. Its official prefix is `pl`. +// +// #### References +// * +//######################################################################################## +// It can be reimplemented to globally change the SR and the tablesize definitions + + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2020 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +declare name "Generic Platform Library"; +declare version "0.3"; + +//---------------------------------`(pl.)SR`----------------------------------- +// Current sampling rate (between 1 and 192000Hz). Constant during +// program execution. +//----------------------------------------------------------------------------- +SR = min(192000.0, max(1.0, fconstant(int fSamplingFreq, ))); + +//---------------------------------`(pl.)BS`--------------------------------------- +// Current block-size (between 1 and 16384 frames). Can change during the execution. +//----------------------------------------------------------------------------- +BS = min(16384.0, max(1.0, fvariable(int count, ))); + +//---------------------------------`(pl.)tablesize`---------------------------- +// Oscillator table size +//----------------------------------------------------------------------------- +tablesize = 1 << 16; diff --git a/dist/examples/LIBRARIES/quantizers.lib b/dist/examples/LIBRARIES/quantizers.lib new file mode 100644 index 00000000..f1cdedae --- /dev/null +++ b/dist/examples/LIBRARIES/quantizers.lib @@ -0,0 +1,310 @@ +//##################################### quantizers.lib ######################################## +// Faust Frequency Quantization Library. Its official prefix is `qu`. +// +// #### References +// * +//######################################################################################## + +ba = library("basics.lib"); +it = library("interpolators.lib"); + +declare name "Faust Frequency Quantization Library"; +declare version "0.1"; + +//=============================Functions Reference======================================== +//======================================================================================== + +/************************************************************************ +************************************************************************ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to +************************************************************************ +************************************************************************/ + +MinFreq = 10; +MaxFreq = 20000; +TableSize = 1024; + +qLog(x) = ba.tabulate(1,log(_),TableSize,MinFreq,MaxFreq,x).cub; +qSmooth(x) = ba.tabulate(1,0.5*atan(_*20-10)/1.4711+0.5,TableSize,0,1,x).cub; + + +//-------`(qu.)quantize`---------- +// Configurable frequency quantization tool. Output only the frequencies that are part of the specified scale. +// Works for positive audio frequencies. +// +// #### Usage +// +// ``` +// _ : quantize(rf,nl) : _ +// ``` +// Where : +// +// * `rf` : frequency of the root note of the scale +// * `nl` : list of the ratio of the frequencies of each note in relation to the root frequency +//------------------------ +quantize(rf,nl) = _<: octave,_ <: _,!,noteRatio(nN) : rf*_*_ +with{ + octave = (qLog(_)-log(rf))/log(2)<: + (_<0)*(1/(1<<(-1*(_-1)):int))+ + (_>=0)*(1<<(_:int)); + nN = ba.count(nl); + noteRatio(1,oct) = 1; + noteRatio(n,oct) = _ <: (ba.take(n,nl)<=((_/oct)/rf))*ba.take(n,nl)+ + (ba.take(n,nl)>((_/oct)/rf))*(noteRatio(n-1,oct)); +}; + + +//-------`(qu.)quantizeSmoothed`---------- +// Configurable frequency quantization tool. Output frequencies that are closer to the frequencies of the specified scale notes. +// Works for positive audio frequencies. +// +// +// #### Usage +// +// ``` +// _ : quantizeSmoothed(rf,nl) : _ +// nl = (1,1.2,1.4,1.7); +// ``` +// Where : +// +// * `rf` : frequency of the root note of the scale +// * `nl` : list of the ratio of the frequencies of each note in relation to the root frequency +//------------------------ +quantizeSmoothed(rf,nl) = _<: octave,_ <: _,!,noteRatio(nN) : rf*_*_ +with{ + octave = (qLog(_)-log(rf))/log(2)<: + (_<0)*(1/(1<<(-1*(_-1)):int))+ + (_>0)*(1<<(_:int))+ + (_==0)*2; + nN = ba.count(nl); + noteRatio(1,oct) = findValue(1,oct); + noteRatio(n,oct) = _ <: (ba.take(n,nl)<=((_/oct)/rf))*findValue(n,oct)+ + (ba.take(n,nl)>((_/oct)/rf))*(noteRatio(n-1,oct)); + + findValue(n,oct) = _<: (n +//############################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2010-2011 GRAME, Centre National de Creation Musicale +--------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ba = library("basics.lib"); + +declare name "Reduce Library"; +declare author "Yann Orlarey (orlarey at grame.fr)"; +declare copyright "Grame"; +declare version "0.1"; +declare license "LGPL with exception"; + +//--------------------------------------------------------------- +// Provides various operations on block of samples +// using a high order 'reduce(op, n)' fold-like function : +// +// sumn(n) : the sum of a block of n input samples +// maxn(n) : the max of a block of n input samples +// minn(n) : the min of a block of n input samples +// mean(n) : the mean of a block of n input samples +// RMS(n) : the RMS of a block of n input samples +//--------------------------------------------------------------- + + +//--------------------`(rm.)reduce`------------------------------ +// Fold-like high order function. Apply a binary operation `op` +// on a block of consecutive samples of a signal `x`. +// For example: `reduce(max,128)` will compute the maximun of each +// block of 128 samples. Please note that the resulting +// value, while produced continuously, will be constant for +// the duration of a block. A new value is only produced +// at the end of a block. Note also that blocks should be of at +// least one sample (n>0). +// +// #### Usage +// +// ``` +// reduce(op, n, x) +// ``` +//----------------------------------------------------------------------------- + +reduce(op, n, x) = compute ~ (_,_,_) : (!,!,_) + with { + compute(acc, count, val) = + ba.if(count +//######################################################################################## + +ma = library("maths.lib"); +ba = library("basics.lib"); +de = library("delays.lib"); +ro = library("routes.lib"); +si = library("signals.lib"); +fi = library("filters.lib"); +os = library("oscillators.lib"); + +declare name "Faust Reverb Library"; +declare version "0.2"; + +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2017 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +All MarkDown comments in this section are Copyright 2016-2017 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees!) + +************************************************************************/ + +//=============================Schroeder Reverberators====================================== +//========================================================================================== + +//------------------------------`(re.)jcrev`------------------------------ +// This artificial reverberator take a mono signal and output stereo +// (`satrev`) and quad (`jcrev`). They were implemented by John Chowning +// in the MUS10 computer-music language (descended from Music V by Max +// Mathews). They are Schroeder Reverberators, well tuned for their size. +// Nowadays, the more expensive freeverb is more commonly used (see the +// Faust examples directory). +// +// `jcrev` reverb below was made from a listing of "RV", dated April 14, 1972, +// which was recovered from an old SAIL DART backup tape. +// John Chowning thinks this might be the one that became the +// well known and often copied JCREV. +// +// `jcrev` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : jcrev : _,_,_,_ +// ``` +//------------------------------------------------------------ +jcrev = *(0.06) : allpass_chain <: comb_bank : mix_mtx with { + rev1N = fi.rev1; + rev12(len,g) = rev1N(2048,len,g); + rev14(len,g) = rev1N(4096,len,g); + allpass_chain = + fi.rev2(512,347,0.7) : + fi.rev2(128,113,0.7) : + fi.rev2(64, 37,0.7); + comb_bank = + rev12(1601,.802), + rev12(1867,.773), + rev14(2053,.753), + rev14(2251,.733); + mix_mtx = _,_,_,_ <: psum, -psum, asum, -asum : _,_,_,_ with { + psum = _,_,_,_ :> _; + asum = *(-1),_,*(-1),_ :> _; + }; +}; + + +//------------------------------`(re.)satrev`------------------------------ +// This artificial reverberator take a mono signal and output stereo +// (`satrev`) and quad (`jcrev`). They were implemented by John Chowning +// in the MUS10 computer-music language (descended from Music V by Max +// Mathews). They are Schroeder Reverberators, well tuned for their size. +// Nowadays, the more expensive freeverb is more commonly used (see the +// Faust examples directory). +// +// `satrev` was made from a listing of "SATREV", dated May 15, 1971, +// which was recovered from an old SAIL DART backup tape. +// John Chowning thinks this might be the one used on his +// often-heard brass canon sound examples, one of which can be found at +// . +// +// #### Usage +// +// ``` +// _ : satrev : _,_ +// ``` +//------------------------------------------------------------ +satrev = *(0.2) <: comb_bank :> allpass_chain <: _,*(-1) with { + rev1N = fi.rev1; + rev11(len,g) = rev1N(1024,len,g); + rev12(len,g) = rev1N(2048,len,g); + comb_bank = + rev11(778,.827), + rev11(901,.805), + rev11(1011,.783), + rev12(1123,.764); + rev2N = fi.rev2; + allpass_chain = + rev2N(128,125,0.7) : + rev2N(64, 42,0.7) : + rev2N(16, 12,0.7); +}; + +//======================Feedback Delay Network (FDN) Reverberators======================== +//======================================================================================== + +//--------------------------------`(re.)fdnrev0`--------------------------------- +// Pure Feedback Delay Network Reverberator (generalized for easy scaling). +// `fdnrev0` is a standard Faust function. +// +// #### Usage +// +// ``` +// <1,2,4,...,N signals> <: +// fdnrev0(MAXDELAY,delays,BBSO,freqs,durs,loopgainmax,nonl) :> +// <1,2,4,...,N signals> +// ``` +// +// Where: +// +// * `N`: 2, 4, 8, ... (power of 2) +// * `MAXDELAY`: power of 2 at least as large as longest delay-line length +// * `delays`: N delay lines, N a power of 2, lengths perferably coprime +// * `BBSO`: odd positive integer = order of bandsplit desired at freqs +// * `freqs`: NB-1 crossover frequencies separating desired frequency bands +// * `durs`: NB decay times (t60) desired for the various bands +// * `loopgainmax`: scalar gain between 0 and 1 used to "squelch" the reverb +// * `nonl`: nonlinearity (0 to 0.999..., 0 being linear) +// +// #### Reference +// +// +//------------------------------------------------------------ +fdnrev0(MAXDELAY, delays, BBSO, freqs, durs, loopgainmax, nonl) + = (si.bus(2*N) :> si.bus(N) : delaylines(N)) ~ + (delayfilters(N,freqs,durs) : feedbackmatrix(N)) +with { + N = ba.count(delays); + NB = ba.count(durs); +//assert(count(freqs)+1==NB); + delayval(i) = ba.take(i+1,delays); + dlmax(i) = MAXDELAY; // must hardwire this from argument for now +//dlmax(i) = 2^max(1,nextpow2(delayval(i))) // try when slider min/max is known +// with { nextpow2(x) = ceil(log(x)/log(2.0)); }; +// -1 is for feedback delay: + delaylines(N) = par(i,N,(de.delay(dlmax(i),(delayval(i)-1)))); + delayfilters(N,freqs,durs) = par(i,N,filter(i,freqs,durs)); + feedbackmatrix(N) = bhadamard(N); + vbutterfly(n) = si.bus(n) <: (si.bus(n):>bus(n/2)) , ((si.bus(n/2),(si.bus(n/2):par(i,n/2,*(-1)))) :> si.bus(n/2)); + bhadamard(2) = si.bus(2) <: +,-; + bhadamard(n) = si.bus(n) <: (si.bus(n):>si.bus(n/2)) , ((si.bus(n/2),(si.bus(n/2):par(i,n/2,*(-1)))) :> si.bus(n/2)) + : (bhadamard(n/2) , bhadamard(n/2)); + + // Experimental nonlinearities: + // nonlinallpass = apnl(nonl,-nonl); + // s = nonl*PI; + // nonlinallpass(x) = allpassnn(3,(s*x,s*x*x,s*x*x*x)); // filters.lib + nonlinallpass = _; // disabled by default (rather expensive) + + filter(i,freqs,durs) = fi.filterbank(BBSO,freqs) : par(j,NB,*(g(j,i))) + :> *(loopgainmax) / sqrt(N) : nonlinallpass + with { + dur(j) = ba.take(j+1,durs); + n60(j) = dur(j)*ma.SR; // decay time in samples + g(j,i) = exp(-3.0*log(10.0)*delayval(i)/n60(j)); + // ~ 1.0 - 6.91*delayval(i)/(SR*dur(j)); // valid for large dur(j) + }; +}; + + +//-------------------------------`(re.)zita_rev_fdn`------------------------------- +// Internal 8x8 late-reverberation FDN used in the FOSS Linux reverb `zita-rev1` +// by Fons Adriaensen . This is an FDN reverb with +// allpass comb filters in each feedback delay in addition to the +// damping filters. +// +// #### Usage +// +// ``` +// si.bus(8) : zita_rev_fdn(f1,f2,t60dc,t60m,fsmax) : si.bus(8) +// ``` +// +// Where: +// +// * `f1`: crossover frequency (Hz) separating dc and midrange frequencies +// * `f2`: frequency (Hz) above f1 where T60 = t60m/2 (see below) +// * `t60dc`: desired decay time (t60) at frequency 0 (sec) +// * `t60m`: desired decay time (t60) at midrange frequencies (sec) +// * `fsmax`: maximum sampling rate to be used (Hz) +// +// #### Reference +// +// * +// * +//------------------------------------------------------------ +zita_rev_fdn(f1,f2,t60dc,t60m,fsmax) = + ((si.bus(2*N) :> allpass_combs(N) : feedbackmatrix(N)) ~ + (delayfilters(N,freqs,durs) : fbdelaylines(N))) +with { + N = 8; + + // Delay-line lengths in seconds: + apdelays = (0.020346, 0.024421, 0.031604, 0.027333, 0.022904, + 0.029291, 0.013458, 0.019123); // feedforward delays in seconds + tdelays = (0.153129, 0.210389, 0.127837, 0.256891, 0.174713, + 0.192303, 0.125000, 0.219991); // total delays in seconds + tdelay(i) = floor(0.5 + ma.SR*ba.take(i+1,tdelays)); // samples + apdelay(i) = floor(0.5 + ma.SR*ba.take(i+1,apdelays)); + fbdelay(i) = tdelay(i) - apdelay(i); + // NOTE: Since SR is not bounded at compile time, we can't use it to + // allocate delay lines; hence, the fsmax parameter: + tdelaymaxfs(i) = floor(0.5 + fsmax*ba.take(i+1,tdelays)); + apdelaymaxfs(i) = floor(0.5 + fsmax*ba.take(i+1,apdelays)); + fbdelaymaxfs(i) = tdelaymaxfs(i) - apdelaymaxfs(i); + nextpow2(x) = ceil(log(x)/log(2.0)); + maxapdelay(i) = int(2.0^max(1.0,nextpow2(apdelaymaxfs(i)))); + maxfbdelay(i) = int(2.0^max(1.0,nextpow2(fbdelaymaxfs(i)))); + + apcoeff(i) = select2(i&1,0.6,-0.6); // allpass comb-filter coefficient + allpass_combs(N) = + par(i,N,(fi.allpass_comb(maxapdelay(i),apdelay(i),apcoeff(i)))); // filters.lib + fbdelaylines(N) = par(i,N,(de.delay(maxfbdelay(i),(fbdelay(i))))); + freqs = (f1,f2); durs = (t60dc,t60m); + delayfilters(N,freqs,durs) = par(i,N,filter(i,freqs,durs)); + feedbackmatrix(N) = ro.hadamard(N); + + staynormal = 10.0^(-20); // let signals decay well below LSB, but not to zero + + special_lowpass(g,f) = si.smooth(p) with { + // unity-dc-gain lowpass needs gain g at frequency f => quadratic formula: + p = mbo2 - sqrt(max(0,mbo2*mbo2 - 1.0)); // other solution is unstable + mbo2 = (1.0 - gs*c)/(1.0 - gs); // NOTE: must ensure |g|<1 (t60m finite) + gs = g*g; + c = cos(2.0*ma.PI*f/float(ma.SR)); + }; + + filter(i,freqs,durs) = lowshelf_lowpass(i)/sqrt(float(N))+staynormal + with { + lowshelf_lowpass(i) = gM*low_shelf1_l(g0/gM,f(1)):special_lowpass(gM,f(2)); + low_shelf1_l(G0,fx,x) = x + (G0-1)*fi.lowpass(1,fx,x); // filters.lib + g0 = g(0,i); + gM = g(1,i); + f(k) = ba.take(k,freqs); + dur(j) = ba.take(j+1,durs); + n60(j) = dur(j)*ma.SR; // decay time in samples + g(j,i) = exp(-3.0*log(10.0)*tdelay(i)/n60(j)); + }; +}; + +// Stereo input delay used by zita_rev1 in both stereo and ambisonics mode: +zita_in_delay(rdel) = zita_delay_mono(rdel), zita_delay_mono(rdel) with { + zita_delay_mono(rdel) = de.delay(8192,ma.SR*rdel*0.001) * 0.3; +}; + +// Stereo input mapping used by zita_rev1 in both stereo and ambisonics mode: +zita_distrib2(N) = _,_ <: fanflip(N) with { + fanflip(4) = _,_,*(-1),*(-1); + fanflip(N) = fanflip(N/2),fanflip(N/2); +}; + + +//----------------------------`(re.)zita_rev1_stereo`--------------------------- +// Extend `zita_rev_fdn` to include `zita_rev1` input/output mapping in stereo mode. +// `zita_rev1_stereo` is a standard Faust function. +// +// #### Usage +// +// ``` +// _,_ : zita_rev1_stereo(rdel,f1,f2,t60dc,t60m,fsmax) : _,_ +// ``` +// +// Where: +// +// `rdel` = delay (in ms) before reverberation begins (e.g., 0 to ~100 ms) +// (remaining args and refs as for `zita_rev_fdn` above) +//------------------------------------------------------------ +zita_rev1_stereo(rdel,f1,f2,t60dc,t60m,fsmax) = + zita_in_delay(rdel) + : zita_distrib2(N) + : zita_rev_fdn(f1,f2,t60dc,t60m,fsmax) + : output2(N) +with { + N = 8; + output2(N) = outmix(N) : *(t1),*(t1); + t1 = 0.37; // zita-rev1 linearly ramps from 0 to t1 over one buffer + outmix(4) = !,ro.butterfly(2),!; // probably the result of some experimenting! + outmix(N) = outmix(N/2),par(i,N/2,!); +}; + + +//-----------------------------`(re.)zita_rev1_ambi`--------------------------- +// Extend `zita_rev_fdn` to include `zita_rev1` input/output mapping in +// "ambisonics mode", as provided in the Linux C++ version. +// +// #### Usage +// +// ``` +// _,_ : zita_rev1_ambi(rgxyz,rdel,f1,f2,t60dc,t60m,fsmax) : _,_,_,_ +// ``` +// +// Where: +// +// `rgxyz` = relative gain of lanes 1,4,2 to lane 0 in output (e.g., -9 to 9) +// (remaining args and references as for zita_rev1_stereo above) +//------------------------------------------------------------ +zita_rev1_ambi(rgxyz,rdel,f1,f2,t60dc,t60m,fsmax) = + zita_in_delay(rdel) + : zita_distrib2(N) + : zita_rev_fdn(f1,f2,t60dc,t60m,fsmax) + : output4(N) // ambisonics mode +with { + N = 8; + output4(N) = select4 : *(t0),*(t1),*(t1),*(t1); + select4 = _,_,_,!,_,!,!,! : _,_,cross with { cross(x,y) = y,x; }; + t0 = 1.0/sqrt(2.0); + t1 = t0 * 10.0^(0.05 * rgxyz); +}; + +// end jos section +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +//===============================Freeverb=================================== +//========================================================================== + +//----------------------------`(re.)mono_freeverb`------------------------- +// A simple Schroeder reverberator primarily developed by "Jezar at Dreampoint" that +// is extensively used in the free-software world. It uses four Schroeder allpasses in +// series and eight parallel Schroeder-Moorer filtered-feedback comb-filters for each +// audio channel, and is said to be especially well tuned. +// +// `mono_freeverb` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : mono_freeverb(fb1, fb2, damp, spread) : _ +// ``` +// +// Where: +// +// * `fb1`: coefficient of the lowpass comb filters (0-1) +// * `fb2`: coefficient of the allpass comb filters (0-1) +// * `damp`: damping of the lowpass comb filter (0-1) +// * `spread`: spatial spread in number of samples (for stereo) +// +// #### License +// While this version is licensed LGPL (with exception) along with other GRAME +// library functions, the file freeverb.dsp in the examples directory of older +// Faust distributions, such as faust-0.9.85, was released under the BSD license, +// which is less restrictive. +//------------------------------------------------------------ +declare mono_freeverb author "Romain Michon"; + +mono_freeverb(fb1, fb2, damp, spread) = _ <: par(i,8,lbcf(combtuningL(i)+spread,fb1,damp)) + :> seq(i,4,fi.allpass_comb(1024, allpasstuningL(i)+spread, -fb2)) +with { + + // Filters parameters + combtuningL(0) = adaptSR(1116); + combtuningL(1) = adaptSR(1188); + combtuningL(2) = adaptSR(1277); + combtuningL(3) = adaptSR(1356); + combtuningL(4) = adaptSR(1422); + combtuningL(5) = adaptSR(1491); + combtuningL(6) = adaptSR(1557); + combtuningL(7) = adaptSR(1617); + + allpasstuningL(0) = adaptSR(556); + allpasstuningL(1) = adaptSR(441); + allpasstuningL(2) = adaptSR(341); + allpasstuningL(3) = adaptSR(225); + + // Lowpass Feedback Combfilter: + // + lbcf(dt, fb, damp) = (+:@(dt)) ~ (*(1-damp) : (+ ~ *(damp)) : *(fb)); + + origSR = 44100; + adaptSR(val) = val*ma.SR/origSR : int; + +}; + + +//----------------------------`(re.)stereo_freeverb`------------------------- +// A simple Schroeder reverberator primarily developed by "Jezar at Dreampoint" that +// is extensively used in the free-software world. It uses four Schroeder allpasses in +// series and eight parallel Schroeder-Moorer filtered-feedback comb-filters for each +// audio channel, and is said to be especially well tuned. +// +// #### Usage +// +// ``` +// _,_ : stereo_freeverb(fb1, fb2, damp, spread) : _,_ +// ``` +// +// Where: +// +// * `fb1`: coefficient of the lowpass comb filters (0-1) +// * `fb2`: coefficient of the allpass comb filters (0-1) +// * `damp`: damping of the lowpass comb filter (0-1) +// * `spread`: spatial spread in number of samples (for stereo) +//------------------------------------------------------------ +declare stereo_freeverb author "Romain Michon"; + +stereo_freeverb(fb1, fb2, damp, spread) = + <: mono_freeverb(fb1, fb2, damp, 0), mono_freeverb(fb1, fb2, damp, spread); + +//######################################################################################## +/************************************************************************ +FAUST library file, further contributions section + +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ + +//===============================Dattorro Reverb============================ +//========================================================================== + +//-------------------------------`(re.)dattorro_rev`------------------------------- +// Reverberator based on the Dattorro reverb topology. This implementation does +// not use modulated delay lengths (excursion). +// +// #### Usage +// +// ``` +// _,_ : dattorro_rev(pre_delay, bw, i_diff1, i_diff2, decay, d_diff1, d_diff2, damping) : _,_ +// ``` +// +// Where: +// +// * `pre_delay`: pre-delay in samples (fixed at compile time) +// * `bw`: band-width filter (pre filtering); (0 - 1) +// * `i_diff1`: input diffusion factor 1; (0 - 1) +// * `i_diff2`: input diffusion factor 2; +// * `decay`: decay rate; (0 - 1); infinite decay = 1.0 +// * `d_diff1`: decay diffusion factor 1; (0 - 1) +// * `d_diff2`: decay diffusion factor 2; +// * `damping`: high-frequency damping; no damping = 0.0 +// +// #### Reference +// +// +//------------------------------------------------------------ +declare dattorro_rev author "Jakob Zerbian"; +declare dattorro_rev licence "MIT-style STK-4.3 license"; + +dattorro_rev(pre_delay, bw, i_diff1, i_diff2, decay, d_diff1, d_diff2, damping) = + si.bus(2) : + : *(0.5) : predelay : bw_filter : diffusion_network <: ((si.bus(4) :> _,_) ~ (reverb_network : ro.cross(2))) +with { + // allpass using delay with fixed size + allpass_f(t, a) = (+ <: @(t),*(a)) ~ *(-a) : mem,_ : +; + + // input pre-delay and diffusion + predelay = @(pre_delay); + bw_filter = *(bw) : +~(mem : *(1-bw)); + diffusion_network = allpass_f(142, i_diff1) : allpass_f(107, i_diff1) : allpass_f(379, i_diff2) : allpass_f(277, i_diff2); + + // reverb loop + reverb_network = par(i, 2, block(i)) with { + d = (672, 908, 4453, 4217, 1800, 2656, 3720, 3163); + block(i) = allpass_f(ba.take(i+1, d),-d_diff1) : @(ba.take(i+3, d)) : damp : + allpass_f(ba.take(i+5, d), d_diff2) : @(ba.take(i+5, d)) : *(decay) + with { + damp = *(1-damping) : +~*(damping) : *(decay); + }; + }; +}; + + +//-------------------------------`(re.)dattorro_rev_default`------------------------------- +// Reverberator based on the Dattorro reverb topology with reverb parameters from the +// original paper. +// This implementation does not use modulated delay lengths (excursion) and +// uses zero length pre-delay. +// +// #### Usage +// +// ``` +// _,_ : dattorro_rev_default : _,_ +// ``` +// +// #### Reference +// +// +//------------------------------------------------------------ +declare dattorro_rev_default author "Jakob Zerbian"; +declare dattorro_rev_default license "MIT-style STK-4.3 license"; + +dattorro_rev_default = dattorro_rev(0, 0.9995, 0.75, 0.625, 0.5, 0.7, 0.5, 0.0005); + +//===============================JPverb and Greyhole Reverbs============================ +//====================================================================================== + +jp_gh_rev = environment { + + diffuser_aux(angle, g, scale1, scale2, size, block) = si.bus(2) <: ((si.bus(2):par(i,2,*(c_norm)) + : ((si.bus(4) :> si.bus(2) + : block + : rotator(angle) + : (de.fdelay1a(8192, prime_delays(size*scale1):smooth_init(0.9999,prime_delays(size*scale1)) -1), + de.fdelay1a(8192, prime_delays(size*scale2):smooth_init(0.9999,prime_delays(size*scale2)) -1))) + ~ par(i,2,*(-s_norm))) : par(i,2,mem:*(c_norm))) + , + par(i,2,*(s_norm))) + :> si.bus(2) + with { + rotator(angle) = si.bus(2) <: (*(c),*(-s),*(s),*(c)) :(+,+) : si.bus(2) + with { + c = cos(angle); + s = sin(angle); + }; + c_norm = cos(g); + s_norm = sin(g); + }; + + diffuser(angle, g, scale1, scale2, size) = diffuser_aux(angle,g,scale1,scale2,size,si.bus(2)); + + // Nested version + diffuser_nested(1, angle, g, scale, size) = diffuser_aux(angle,g,scale,scale+10,size,si.bus(2)); + diffuser_nested(N, angle, g, scale, size) = diffuser_aux(angle,g,scale,scale+10,size,diffuser_nested(N-1,angle,g,scale+13,size)); + + prime_delays(x) = (waveform {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343, 10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487, 10499, 10501, 10513, 10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627, 10631, 10639, 10651, 10657, 10663, 10667}, int(x)) : rdtable; + + smooth_init(s,default) = *(1.0 - s) : + ~ (+(default*init(1)):*(s)) with { init(value) = value - value'; }; + + jpverb(t60, damp, size, early_diff, mod_depth, mod_freq, low, mid, high, low_cutoff, high_cutoff) + = ((si.bus(4) :> (de.fdelay4(512, depth + depth*os.oscrs(mod_freq) + 5),de.fdelay4(512, depth + depth*os.oscrc(mod_freq) + 5)) + : par(i,2,si.smooth(damp)) + : diffuser(ma.PI/4,early_diff,55,240,size) + : diffuser(ma.PI/4,early_diff,215,85,size) + : diffuser(ma.PI/4,early_diff,115,190,size) + : diffuser(ma.PI/4,early_diff,175,145,size) + )~(seq(i,5,diffuser(ma.PI/4,0.707,10+30*i,110+30*i,size)) + : par(i,2,de.fdelay4(512, depth + (-1^i)*depth*os.oscrc(mod_freq)+5) + : de.fdelay1a(8192,(prime_delays(size*(54+150*i)) + : smooth_init(0.995,prime_delays(size*(54+150*i)))) -1)) + : seq(i,5,diffuser(ma.PI/4,0.707,125+30*i,25+30*i,size)) + : par(i,2,de.fdelay4(8192, depth + (-1^i)*depth*os.oscrs(mod_freq)+5) + : de.fdelay1a(8192,(prime_delays(size*(134-100*i)) + : smooth_init(0.995,prime_delays(size*(134-100*i)))) -1)) + : par(i,2,fi.filterbank(5,(low_cutoff,high_cutoff)):(_*(high),_*(mid),_*(low)) :> _) + : par(i,2,*(fb)))) + with { + depth = 50*mod_depth; + calib = 1.7; // Calibration constant given by t60 in seconds when fb = 0.5 + total_length = calib*0.1*(size*5/4 -1/4); + fb = 10^(-3/((t60)/(total_length))); + }; + + greyhole(dt, damp, size, early_diff, feedback, mod_depth, mod_freq) + = (si.bus(4) :> seq(i,3,diffuser_nested(4,ma.PI/2,(-1^i)*diff,10+19*i,size)) + : par(i,2,si.smooth(damp_interp))) + ~((de.fdelay4(512, 10 + depth + depth*os.oscrc(freq)),de.fdelay4(512, 10 + depth + depth*os.oscrs(freq))) + : (de.sdelay(65536,44100/2,floor(dt_constrained)),de.sdelay(65536,44100/2,floor(dt_constrained))) + : par(i,2,*(fb))) + with { + fb = feedback:linear_interp; + depth = ((ma.SR/44100)*50*mod_depth):linear_interp; + freq = mod_freq:linear_interp; + diff = early_diff:linear_interp; + dt_constrained = min(65533,ma.SR*dt); + damp_interp = damp:linear_interp; + linear_interp(x) = (x+x')/2; + }; + +}; + +//-------------------------------`(re.)jpverb`------------------------------- +// An algorithmic reverb (stereo in/out), inspired by the lush chorused sound +// of certain vintage Lexicon and Alesis reverberation units. +// Designed to sound great with synthetic sound sources, rather than sound like a realistic space. +// +// #### Usage +// +// ``` +// _,_ : jpverb(t60, damp, size, early_diff, mod_depth, mod_freq, low, mid, high, low_cutoff, high_cutoff) : _,_ +// ``` +// +// Where: +// +// * `t60`: approximate reverberation time in seconds ([0.1..60] sec) (T60 - the time for the reverb to decay by 60db when damp == 0 ). Does not effect early reflections +// * `damp`: controls damping of high-frequencies as the reverb decays. 0 is no damping, 1 is very strong damping. Values should be between ([0..1]) +// * `size`: scales size of delay-lines within the reverberator, producing the impression of a larger or smaller space. Values below 1 can sound metallic. Values should be between [0.5..5] +// * `early_diff`: controls shape of early reflections. Values of 0.707 or more produce smooth exponential decay. Lower values produce a slower build-up of echoes. Values should be between ([0..1]) +// * `mod_depth`: depth ([0..1]) of delay-line modulation. Use in combination with mod_freq to set amount of chorusing within the structure +// * `modFreq`: frequency ([0..10] Hz) of delay-line modulation. Use in combination with modDepth to set amount of chorusing within the structure +// * `low`: multiplier ([0..1]) for the reverberation time within the low band +// * `mid`: multiplier ([0..1]) for the reverberation time within the mid band +// * `high`: multiplier ([0..1]) for the reverberation time within the high band +// * `lowcut`: frequency (100..6000 Hz) at which the crossover between the low and mid bands of the reverb occurs +// * `highcut`: frequency (1000..10000 Hz) at which the crossover between the mid and high bands of the reverb occurs +// +// #### Reference +// +// +//------------------------------------------------------------ +declare jpverb author "Julian Parker, bug fixes and minor interface changes by Till Bovermann"; +declare jpverb license "GPL2+"; + +jpverb(t60, damp, size, early_diff, + mod_depth, mod_freq, + low, mid, high, + low_cutoff, high_cutoff) + = jp_gh_rev.jpverb(t60, damp, size, early_diff, mod_depth, mod_freq, low, mid, high, low_cutoff, high_cutoff); + + +//-------------------------------`(re.)greyhole`------------------------------- +// A complex echo-like effect (stereo in/out), inspired by the classic Eventide effect of a similar name. +// The effect consists of a diffuser (like a mini-reverb, structurally similar to the one used in `jpverb`) +// connected in a feedback system with a long, modulated delay-line. +// Excels at producing spacey washes of sound. +// +// #### Usage +// +// ``` +// _,_ : greyhole(dt, damp, size, early_diff, feedback, mod_depth, mod_freq) : _,_ +// ``` +// +// Where: +// +// * `dt`: approximate reverberation time in seconds ([0.1..60 sec]) +// * `damp`: controls damping of high-frequencies as the reverb decays. 0 is no damping, 1 is very strong damping. Values should be between ([0..1]) +// * `size`: scales size of delay-lines within the diffusion unit, producing the impression of a larger or smaller space. Values below 1 can sound metallic. Values should be between ([0.5..5]) +// * `size`: control of relative "room size" roughly between ([0.5..3]) +// * `early_diff`: controls pattern of echoes produced by the diffuser. At very low values, the diffuser acts like a delay-line whose length is controlled by the 'size' parameter. Medium values produce a slow build-up of echoes, giving the sound a reversed-like quality. Values of 0.707 or greater than produce smooth exponentially decaying echoes. Values should be in the range ([0..1]) +// * `feedback`: amount of feedback through the system. Sets the number of repeating echoes. A setting of 1.0 produces infinite sustain. Values should be in the range ([0..1]) +// * `mod_depth`: depth ([0..1]) of delay-line modulation. Use in combination with mod_freq to produce chorus and pitch-variations in the echoes +// * `mod_freq`: frequency ([0..10] Hz) of delay-line modulation. Use in combination with mod_depth to produce chorus and pitch-variations in the echoes +// +// #### Reference +// +// +//------------------------------------------------------------ +declare greyhole author "Julian Parker, bug fixes and minor interface changes by Till Bovermann"; +declare greyhole license "GPL2+"; + +greyhole(dt, damp, size, early_diff, feedback, mod_depth, mod_freq) + = jp_gh_rev.greyhole(dt, damp, size, early_diff, feedback, mod_depth, mod_freq); + +// end further further contributions section diff --git a/dist/examples/LIBRARIES/routes.lib b/dist/examples/LIBRARIES/routes.lib new file mode 100644 index 00000000..e1241f3e --- /dev/null +++ b/dist/examples/LIBRARIES/routes.lib @@ -0,0 +1,262 @@ +//#################################### routes.lib ######################################## +// A library to handle signal routing in Faust. Its official prefix is `ro`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2003-2019 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ba = library("basics.lib"); +si = library("signals.lib"); +sp = library("spats.lib"); + +declare name "Faust Signal Routing Library"; +declare version "0.2"; + +//=============================Functions Reference======================================== +//======================================================================================== + +//--------------------------------`(ro.)cross`----------------------------------- +// Cross N signals: `(x1,x2,..,xn) -> (xn,..,x2,x1)`. +// `cross` is a standard Faust function. +// +// #### Usage +// +// ``` +// cross(N) +// _,_,_ : cross(3) : _,_,_ +// ``` +// +// Where: +// +// * `N`: number of signals (int, as a constant numerical expression) +// +// #### Note +// +// Special case: `cross2`: +// +// ``` +// cross2 = _,cross(2),_; +// ``` +//----------------------------------------------------------------------------- +// cross n cables : (x1,x2,..,xn) -> (xn,..,x2,x1) +cross(N) = route(N, N, par(i, N, (i+1, N-i))); +cross2 = _,cross(2),_; // for compatibility with some old misceffects.lib functions + + +//--------------`(ro.)crossnn`-------------- +// Cross two `bus(N)`s. +// +// #### Usage +// +// ``` +// (si.bus(2*N)) : crossnn(N) : (si.bus(2*N)) +// ``` +// +// Where: +// +// * `N`: the number of signals in the `bus` (int, as a constant numerical expression) +//-------------------------------------- +crossnn(N) = crossNM(N,N); + + +//--------------`(ro.)crossn1`-------------- +// Cross `bus(N)` and `bus(1)`. +// +// #### Usage +// +// ``` +// (si.bus(N),_) : crossn1(N) : (_,si.bus(N)) +// ``` +// +// Where: +// +// * `N`: the number of signals in the first `bus` (int, as a constant numerical expression) +//-------------------------------------- +crossn1(N) = crossNM(N,1); + + +//--------------`(ro.)cross1n`-------------- +// Cross `bus(1)` and `bus(N)`. +// +// #### Usage +// +// ``` +// (_,si.bus(N)) : crossn1(N) : (si.bus(N),_) +// ``` +// +// Where: +// +// * `N`: the number of signals in the second `bus` (int, as a constant numerical expression) +//-------------------------------------- +cross1n(N) = crossNM(1,N); + + +//--------------`(ro.)crossNM`-------------- +// Cross `bus(N)` and `bus(M)`. +// +// #### Usage +// +// ``` +// (si.bus(N),si.bus(M)) : crossNM(N,M) : (si.bus(M),si.bus(N)) +// ``` +// +// Where: +// +// * `N`: the number of signals in the first `bus` (int, as a constant numerical expression) +// * `M`: the number of signals in the second `bus` (int, as a constant numerical expression) +//-------------------------------------- +crossNM(N,M) = route(N+M, N+M, par(i, N+M, i+1, ((i+M)%(N+M))+1)); + + +//--------------------------`(ro.)interleave`------------------------------ +// Interleave R x C cables from column order to row order. +// input : x(0), x(1), x(2) ..., x(row*col-1) +// output: x(0+0*row), x(0+1*row), x(0+2*row), ..., x(1+0*row), x(1+1*row), x(1+2*row), ... +// +// #### Usage +// +// ``` +// si.bus(R*C) : interleave(R,C) : si.bus(R*C) +// ``` +// +// Where: +// +// * `R`: the number of row (int, as a constant numerical expression) +// * `C`: the number of column (int, as a constant numerical expression) +//----------------------------------------------------------------------------- +interleave(1,2) = _,_; +interleave(R,C) = route(R*C, R*C, par(i, R*C, (i+1, (i%R)*C + int(i/R) + 1))); + + +//-------------------------------`(ro.)butterfly`-------------------------------- +// Addition (first half) then substraction (second half) of interleaved signals. +// +// #### Usage +// +// ``` +// si.bus(N) : butterfly(N) : si.bus(N) +// ``` +// +// Where: +// +// * `N`: size of the butterfly (N is int, even and as a constant numerical expression) +//----------------------------------------------------------------------------- +butterfly(2) = si.bus(2) <: +,-; +butterfly(N) = si.bus(N) <: interleave(N/2,2), interleave(N/2,2) : par(i, N/2, +), par(i, N/2, -); + + +//------------------------------`(ro.)hadamard`---------------------------------- +// Hadamard matrix function of size `N = 2^k`. +// +// #### Usage +// +// ``` +// si.bus(N) : hadamard(N) : si.bus(N) +// ``` +// +// Where: +// +// * `N`: `2^k`, size of the matrix (int, as a constant numerical expression) +// +//----------------------------------------------------------------------------- +declare hadamard author "Remy Muller, revised by Romain Michon"; +hadamard(2) = butterfly(2); +hadamard(N) = butterfly(N) : (hadamard(N/2), hadamard(N/2)); + + +//---------------`(ro.)recursivize`------------- +// Create a recursion from two arbitrary processors `p` and `q`. +// +// #### Usage +// +// ``` +// _,_ : recursivize(p,q) : _,_ +// +// ``` +// +// Where: +// +// * `p`: the forward arbitrary processor +// * `q`: the feedback arbitrary processor +//---------------------------------------- +recursivize(p,q) = (_,_,_,_ :> sp.stereoize(p)) ~ sp.stereoize(q); + + +//--------------------`(ro.)bubbleSort`----------------------------------------- +// +// Sort a set of N parallel signals in ascending order on-the-fly through +// the Bubble Sort algorithm. +// +// Mechanism: having a set of N parallel signals indexed from 0 to N - 1, +// compare the first pair of signals and swap them if sig[0] > sig[1]; +// repeat the pair comparison for the signals sig[1] and sig[2], then again +// recursively until reaching the signals sig[N - 2] and sig[N - 1]; by the end, +// the largest element in the set will be placed last; repeat the process for +// the remaining N - 1 signals until there is a single pair left. +// +// Note that this implementation will always perform the worst-case +// computation, O(n^2). +// +// Even though the Bubble Sort algorithm is one of the least efficient ones, +// it is a useful example of how automatic sorting can be implemented at the +// signal level. +// +// #### Usage +// +// ``` +// si.bus(N) : bubbleSort(N) : si.bus(N) +// +// ``` +// +// Where: +// +// * `N`: the number of signals to be sorted (must be an int >= 0, as a constant numerical expression) +// +// #### Reference +// +//------------------------------------------------------------------------------ +declare bubbleSort author "Dario Sanfilippo"; +declare bubbleSort copyright "Copyright (C) 2021 Dario Sanfilippo + "; +declare bubbleSort license "MIT License"; +bubbleSort(0) = 0 : !; +bubbleSort(1) = _; +bubbleSort(N) = seq(i, N - 1, pairSortN(N - i), bus(i)) + with { + bus(0) = 0 : !; + bus(N) = si.bus(N); + pairSort = bus(2) <: select2(>), select2(<); + pairSortN(N) = seq(i, N - 1, bus(i), pairSort, bus(N - i - 2)); + }; diff --git a/dist/examples/LIBRARIES/sf.lib b/dist/examples/LIBRARIES/sf.lib new file mode 100644 index 00000000..99e1d91c --- /dev/null +++ b/dist/examples/LIBRARIES/sf.lib @@ -0,0 +1,53 @@ +/* + sf.lib - aliases all prefixes to sf = all.lib, so that both old and new prefixes can be mixed. + + USAGE: + + import("sf.lib"); // use either standard prefixes or the one prefix "sf" + + The Faust team is committed to unique names for standard Faust + functions, allowing them to all be in the same namespace. + Therefore, only two namespaces are needed: (1) the highest-level + scope (no prefix), and (2) the Standard Faust scope, using prefix 'sf'. +*/ + +sf = library("all.lib"); // "Standard Faust" prefix + +//--- use old library prefixes using old libraries --- +/* + ml = library("old/music.lib"); + fl = library("old/filter.lib"); + ol = library("old/oscillator.lib"); + el = library("old/effect.lib"); +*/ +//--- use old library prefixes using new libraries --- +ol = sf; +fl = sf; +ml = sf; +el = sf; +//--- new library prefixes --- +an = sf; +ba = sf; +co = sf; +de = sf; +dm = sf; +dx = sf; +ef = sf; +en = sf; +fd = sf; +fi = sf; +ho = sf; +ma = sf; +os = sf; +no = sf; +pf = sf; +pm = sf; +re = sf; +ro = sf; +sp = sf; +si = sf; +so = sf; +sy = sf; +ve = sf; +wa = sf; +//----- diff --git a/dist/examples/LIBRARIES/signals.lib b/dist/examples/LIBRARIES/signals.lib new file mode 100644 index 00000000..c0a4b8ea --- /dev/null +++ b/dist/examples/LIBRARIES/signals.lib @@ -0,0 +1,480 @@ +//#################################### signals.lib ######################################## +// A library of basic elements to handle signals in Faust. Its official prefix is `si`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. + +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ba = library("basics.lib"); +ro = library("routes.lib"); +ma = library("maths.lib"); +si = library("signals.lib"); + +declare name "Faust Signal Routing Library"; +declare version "0.3"; + +//=============================Functions Reference======================================== +//======================================================================================== + +//--------------------------------`(si.)bus`------------------------------------- +// Put N cables in parallel. +// `bus` is a standard Faust function. +// +// #### Usage +// +// ``` +// bus(N) +// bus(4) : _,_,_,_ +// ``` +// +// Where: +// +// * `N`: is an integer known at compile time that indicates the number of parallel cables +//----------------------------------------------------------------------------- +bus(0) = 0:!; +bus(1) = _; // avoids a lot of "bus(1)" labels in block diagrams +bus(2) = _,_; // avoids a lot of "bus(2)" labels in block diagrams +bus(N) = par(i, N, _); + +//--------------`(si.)block`-------------- +// Block - terminate N signals. +// `block` is a standard Faust function. +// +// #### Usage +// +// ``` +// si.bus(N) : block(N) +// ``` +// +// Where: +// +// * `N`: the number of signals to be blocked known at compile time +//-------------------------------------- +block(N) = par(i, N, !); + +//-----------------------------`(si.)interpolate`------------------------------- +// Linear interpolation between two signals. +// +// #### Usage +// +// ``` +// _,_ : interpolate(i) : _ +// ``` +// +// Where: +// +// * `i`: interpolation control between 0 and 1 (0: first input; 1: second input) +//----------------------------------------------------------------------------- +interpolate(i,x,y) = x + i*(y-x); + +//------------------------`(si.)smoo`--------------------------------------- +// Smoothing function based on `smooth` ideal to smooth UI signals +// (sliders, etc.) down. Approximately, this is a 7 Hz one-pole +// low-pass considering the coefficient calculation: +// exp(-2pi*CF/SR). +// +// `smoo` is a standard Faust function. +// +// #### Usage +// +// ``` +// hslider(...) : smoo; +// ``` +//--------------------------------------------------------------------- +smoo = si.smooth(1 - 44.1/ma.SR); + +//-----------------------`(si.)polySmooth`-------------------------------- +// A smoothing function based on `smooth` that doesn't smooth when a +// trigger signal is given. This is very useful when making +// polyphonic synthesizer to make sure that the value of the parameter +// is the right one when the note is started. +// +// #### Usage +// +// ``` +// hslider(...) : polySmooth(g,s,d) : _ +// ``` +// +// Where: +// +// * `g`: the gate/trigger signal used when making polyphonic synths +// * `s`: the smoothness (see `smooth`) +// * `d`: the number of samples to wait before the signal start being +// smoothed after `g` switched to 1 +//------------------------------------------------------------------- +polySmooth(g,s,d) = si.smooth(s*((g==(g@d)) | (g == 0))); + +//-----------------------`(si.)smoothAndH`-------------------------------- +// A smoothing function based on `smooth` that holds its output +// signal when a trigger is sent to it. This feature is convenient +// when implementing polyphonic instruments to prevent some +// smoothed parameter to change when a note-off event is sent. +// +// #### Usage +// +// ``` +// hslider(...) : smoothAndH(g,s) : _ +// ``` +// +// Where: +// +// * `g`: the hold signal (0 for hold, 1 for bypass) +// * `s`: the smoothness (see `smooth`) +//------------------------------------------------------------------- +smoothAndH(t,s) = si.smooth(s*t) : ba.sAndH(t); + +//-----------------------------`(si.)bsmooth`------------------------------ +// Block smooth linear interpolation during a block of samples (given by the `ma.BS` value). +// +// #### Usage +// +// ``` +// hslider(...) : bsmooth : _ +// ``` +//----------------------------------------------------------------------- +bsmooth(c) = +(i) ~ _ +with { + i = (c-c@n)/n; + n = min(4096, max(1, ma.BS)); +}; + +//-------------------------------`(si.)dot`-------------------------------------- +// Dot product for two vectors of size N. +// +// #### Usage +// +// ``` +// si.bus(N), si.bus(N) : dot(N) : _ +// ``` +// +// Where: +// +// * `N`: size of the vectors (int, must be known at compile time) +//----------------------------------------------------------------------------- +dot(N) = ro.interleave(N,2) : par(i,N,*) :> _; + +// end GRAME section +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2017 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +All MarkDown comments in this section are Copyright 2016-2017 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees!) + +************************************************************************/ +//-------------------`(si.)smooth`----------------------------------- +// Exponential smoothing by a unity-dc-gain one-pole lowpass. +// `smooth` is a standard Faust function. +// +// #### Usage: +// +// ``` +// _ : si.smooth(ba.tau2pole(tau)) : _ +// ``` +// +// Where: +// +// * `tau`: desired smoothing time constant in seconds, or +// +// ``` +// hslider(...) : smooth(s) : _ +// ``` +// +// Where: +// +// * `s`: smoothness between 0 and 1. s=0 for no smoothing, s=0.999 is "very smooth", +// s>1 is unstable, and s=1 yields the zero signal for all inputs. +// The exponential time-constant is approximately 1/(1-s) samples, when s is close to +// (but less than) 1. +// +// #### References: +// +// * +// * +//------------------------------------------------------------- + +// See [grame-cncm/faustlibraries]: Minor improvement to si.smoo. (Discussion #106) + +smooth_imp = case { + // y[n] = (1 - s) * x[n] + s * y[n - 1] + (0,s) => \(x).(fb ~ _ with { fb(y) = (1.0 - s) * x + s * y; }); + + // y[n] = s * (y[n - 1] - x[n]) + x[n] + (1,s) => \(x).(fb ~ _ with { fb(y) = s * (y - x) + x; }); + + // y[n] = y[n - 1] + (1 - s) * (x[n] - y[n - 1]) + (2,s) => \(x).(fb ~ _ with { fb(y) = y + (1.0 - s) * (x - y); }); +}; + +// The best compromise on modern CPUs where two independent multiplications can be done in parallel. +// Other versions could possibly be faster on embedded devices. +smooth = smooth_imp(0); + +//--------------------------------`(si.)cbus`------------------------------------- +// N parallel cables for complex signals. +// `cbus` is a standard Faust function. +// +// #### Usage +// +// ``` +// cbus(N) +// cbus(4) : (r0,i0), (r1,i1), (r2,i2), (r3,i3) +// ``` +// +// Where: +// +// * `N`: is an integer known at compile time that indicates the number of parallel cables. +// * each complex number is represented by two real signals as (real,imag) +//----------------------------------------------------------------------------- +cbus(1) = (_,_); +cbus(N) = par(i, N, (_,_)); + +//--------------------------------`(si.)cmul`------------------------------------- +// Multiply two complex signals pointwise. +// `cmul` is a standard Faust function. +// +// #### Usage +// +// ``` +// (r1,i1) : cmul(r2,i2) : (_,_) +// ``` +// +// Where: +// +// * Each complex number is represented by two real signals as (real,imag), so +// - `(r1,i1)` = real and imaginary parts of signal 1 +// - `(r2,i2)` = real and imaginary parts of signal 2 +//----------------------------------------------------------------------------- +cmul(r1,i1,r2,i2) = (r1*r2 - i1*i2), (r1*i2 + r2*i1); + +//--------------------------------`(si.)cconj`------------------------------------- +// Complex conjugation of a (complex) signal. +// `cconj` is a standard Faust function. +// +// #### Usage +// +// ``` +// (r1,i1) : cconj : (_,_) +// ``` +// +// Where: +// +// * Each complex number is represented by two real signals as (real,imag), so +// - `(r1,i1)` = real and imaginary parts of the input signal +// - `(r1,-i1)` = real and imaginary parts of the output signal +//----------------------------------------------------------------------------- +cconj = _, *(-1); + +// end jos section +/************************************************************************ +FAUST library file, further contributions section +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ + +//-------------`(si.)onePoleSwitching`--------------- +// One pole filter with independent attack and release times. +// +// #### Usage +// +// ``` +// _ : onePoleSwitching(att,rel) : _ +// ``` +// +// Where: +// +// * `att`: the attack tau time constant in second +// * `rel`: the release tau time constant in second +// +//---------------------------------------------------- +declare onePoleSwitching author "Jonatan Liljedahl, revised by Dario Sanfilippo"; +declare onePoleSwitching licence "STK-4.3"; + +onePoleSwitching(att, rel, x) = loop ~ _ + with { + loop(yState) = (1.0 - coeff) * x + coeff * yState + with { + coeff = ba.if(x > yState, ba.tau2pole(att), ba.tau2pole(rel)); + }; + }; + +// Kept for backward compatibility +lag_ud = onePoleSwitching; + + +// end further further contributions section + +//-------------`(si.)rev`--------------- +// Reverse the input signal by blocks of n>0 samples. `rev(1)` is the indentity +// function. `rev(n)` has a latency of `n-1` samples. +// +// #### Usage +// +// ``` +// _ : rev(n) : _ +// ``` +// +// Where: +// +// * `n`: the block size in samples +//---------------------------------------------------- +declare rev author "Yann Orlarey"; + +rev(n) = @(phase(n)*2) +with { + phase(n) = 1 : (+ : %(n)) ~ _ : max(0) : min(n-1); +}; + +//--------------------`(si.)vecOp`---------------------------------------------- +// +// This function is a generalisation of Faust's iterators such as `prod` and +// `sum`, and it allows to perform operations on an arbitrary number of +// vectors, provided that they all have the same length. Unlike Faust's +// iterators `prod` and `sum` where the vector size is equal to one and the +// vector space dimension must be specified by the user, this function will +// infer the vector space dimension and vector size based on the vectors list +// that we provide. +// +// The outputs of the function are equal to the vector size, whereas the +// number of inputs is dependent on whether the elements of the vectors +// provided expect an incoming signal themselves or not. We will see a +// clarifying example later; in general, the number of total inputs will +// be the sum of the inputs in each input vector. +// +// Note that we must provide a list of at least two vectors, each with a size +// that is greater or equal to one. +// +// #### Usage +// +// ``` +// si.bus(inputs(vectorsList)) : vecOp((vectorsList), op) : si.bus(outputs(ba.take(1, vectorsList))); +// ``` +// +// #### Where +// +// * `vectorsList`: is a list of vectors +// * `op`: is a two-input, one-output operator +// +// For example, consider the following vectors lists: +// +// v0 = (0 , 1 , 2 , 3); +// v1 = (4 , 5 , 6 , 7); +// v2 = (8 , 9 , 10 , 11); +// v3 = (12 , 13 , 14 , 15); +// v4 = (+(16) , _ , 18 , *(19)); +// vv = (v0 , v1 , v2 , v3); +// +// Although Faust has limitations for list processing, these vectors can be +// combined or processed individually. +// +// If we do: +// +// process = vecOp(v0, +); +// +// the function will deduce a vector space of dimension equal to four and +// a vector length equal to one. Note that this is equivalent to writing: +// +// process = v0 : sum(i, 4, _); +// +// Similarly, we can write: +// +// process = vecOp((v0 , v1), *) :> _; +// +// and we have a dimension-two space and length-four vectors. This is the dot +// product between vectors v0 and v1, which is equivalent to writing: +// +// process = v0 , v1 : dot(4); +// +// The examples above have no inputs, as none of the elements of the vectors +// expect inputs. On the other hand, we can write: +// +// process = vecOp((v4 , v4), +); +// +// and the function will have six inputs and four outputs, as each vector +// has three of the four elements expecting an input, times two, as the two +// input vectors are identical. +// +// Finally, we can write: +// +// process = vecOp(vv, &); +// +// to perform the bitwise AND on all the elements at the same position in +// each vector, having dimension equal to the vector length equal to four. +// +// Or even: +// +// process = vecOp((vv , vv), &); +// +// which gives us a dimension equal to two, and a vector size equal to sixteen. +// +// For a more practical use-case, this is how we can implement a time-invariant +// feedback delay network with Hadamard matrix: +// +// N = 4; +// normalisation = 1.0 / sqrt(N); +// coeffVec = par(i, N, .99 * normalisation); +// delVec = par(i, N, (i + 1) * 3); +// process = vecOp((si.bus(N) , si.bus(N)), +) ~ +// vecOp((vecOp((ro.hadamard(N) , coeffVec), *) , delVec), @); +// +//------------------------------------------------------------------------------ +declare vecOp author "Dario Sanfilippo"; +declare vecOp copyright "Copyright (C) 2022 Dario Sanfilippo + "; +declare vecOp license "MIT License"; +vecOp(vectorsList, op) = + vectorsList : seq(i, vecDim - 1, vecOp2D , vecBus(vecDim - 2 - i)) + with { + vecBus(0) = par(i, vecLen, 0 : !); + vecBus(dim) = par(i, dim, si.bus(vecLen)); + vecOp2D = ro.interleave(vecLen, 2) : par(i, vecLen, op); + vecDim = outputs(vectorsList) / vecLen; + vecLen = outputs(ba.take(1, vectorsList)); + }; diff --git a/dist/examples/LIBRARIES/soundfiles.lib b/dist/examples/LIBRARIES/soundfiles.lib new file mode 100644 index 00000000..154672a7 --- /dev/null +++ b/dist/examples/LIBRARIES/soundfiles.lib @@ -0,0 +1,234 @@ +//#################################### soundfiles.lib ######################################## +// A library to handle soundfiles in Faust. Its official prefix is `so`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2018-2020 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ba = library("basics.lib"); +ma = library("maths.lib"); +si = library("signals.lib"); +ro = library("routes.lib"); +it = library("interpolators.lib"); + +declare name "Faust Soundfile Library"; +declare version "0.7"; + +//======================================================================= +// Utility functions added in a 'super' environment (to test the idea...) +//======================================================================= + +super = environment { + + length(sf, part) = (part, 0) : sf : (_,si.block(outputs(sf)-1)); + srate(sf, part) = (part, 0) : sf : (!,_,si.block(outputs(sf)-2)) : float; + outs(sf, level) = sf : si.block(2), bus(outputs(sf)-2) with { bus(n) = par(i,n,*(level)); }; + + // Plays a soundfile + // 'reader' in a function of type \(sf,part).(body) whih produces the (possibly fractional) read index + player(sf, part, reader, level) = (part, it.int_part(reader(sf, part))) : outs(sf, level); + + // Plays a soundfile with configurable interpolation + player_interp(sf, part, reader, level, selector) = it.interpolator_select(gen, idv, selector) + with { + // Adapts the (sf, part, reader) parameters as 'idv' and 'gen' types for the generic interpolator + idv = reader(sf, part); + gen(idx) = (part, idx) : outs(sf, level); + }; + + // Plays a soundfile with configurable interpolation and a reference frequence 'ref' + play_interp(sf, part, ref, freq, level, gate, selector) = player_interp(sf, part, reader, level, selector) + with { + reader(sf, part) = it.raise(gate, step, length(sf, part)) with { step = freq/ref*srate(sf, part)/ma.SR; }; + }; + + // Generic version + loop_speed_level(sf, part, speed, level) = player(sf, part, reader, level) + with { + // A 'reader' which loops the sound with 'speed' and 'level' control + reader(sf, part) = it.raise_modulo(1, step, length(sf, part)) with { step = speed*srate(sf, part)/ma.SR; }; + }; + + // Defines 'loop_speed' as a specialized version of loop_speed_level with level = 1 + loop_speed(sf, part, speed) = loop_speed_level(sf, part, speed, 1); + + // Defines 'loop_speed' as a specialized version of loop_speed_level with speed = 1 and level = 1 + loop(sf, part) = loop_speed_level(sf, part, 1, 1); + + +}; // End of environment + +//=============================Functions Reference======================================== +//======================================================================================== + +//--------------------------------`(so.)loop`----------------------------------- +// Play a soundfile in a loop taking into account its sampling rate. +// `loop` is a standard Faust function. +// +// #### Usage +// +// ``` +// loop(sf, part) : si.bus(outputs(sf)) +// ``` +// +// Where: +// +// * `sf`: the soundfile +// * `part`: the part in the soundfile list of sounds +// +//----------------------------------------------------------------------------- + +loop(sf, part) = super.loop(sf, part); + +//--------------------------------`(so.)loop_speed`----------------------------------- +// Play a soundfile in a loop taking into account its sampling rate, with speed control. +// `loop_speed` is a standard Faust function. +// +// #### Usage +// +// ``` +// loop_speed(sf, part, speed) : si.bus(outputs(sf)) +// ``` +// +// Where: +// +// * `sf`: the soundfile +// * `part`: the part in the soundfile list of sounds +// * `speed`: the speed between 0 and n +// +//----------------------------------------------------------------------------- + +loop_speed(sf, part, speed) = super.loop_speed(sf, part, speed); + +//--------------------------------`(so.)loop_speed_level`----------------------------------- +// Play a soundfile in a loop taking into account its sampling rate, with speed and level controls. +// `loop_speed_level` is a standard Faust function. +// +// #### Usage +// +// ``` +// loop_speed_level(sf, part, speed, level) : si.bus(outputs(sf)) +// ``` +// +// Where: +// +// * `sf`: the soundfile +// * `part`: the part in the soundfile list of sounds +// * `speed`: the speed between 0 and n +// * `level`: the volume between 0 and n +// +//----------------------------------------------------------------------------- + +loop_speed_level(sf, part, speed, level) = super.loop_speed_level(sf, part, speed, level); + +//==================================================== +// Environment to handle a given sound in a soundfile +//==================================================== + +sound(sf, part) = environment { + + // Looping the sound + loop = super.loop(sf, part); + loop_speed(speed) = super.loop_speed(sf, part, speed); + loop_speed_level(speed, level) = super.loop_speed_level(sf, part, speed, level); + + // Play once + play(level, gate) = super.player(sf, part, reader, level) + with { + reader(sf, part) = it.raise(gate, super.srate(sf, part)/ma.SR, super.length(sf, part)); + }; + + // Play once in reverse + play_rev(level, gate) = super.player(sf, part, reader, level) + with { + reader(sf, part) = it.decrease(gate, super.srate(sf, part)/ma.SR, super.length(sf, part)); + }; + + // Play sound once with configurable interpolation and freq control (using a 'ref' value) + play_interp(ref, freq, level, gate, selector) = super.play_interp(sf, part, ref, freq, level, gate, selector); + + // Play sound once and alternate between normal play and reverse play + //play_alt(level, gate, ctrl) = super.player(sf, part, alt2(ramp1, ramp2, ctrl), level) + play_alt(level, gate, ctrl) = super.player(sf, part, altN(lramp, ctrl), level) + with { + // High-order function which alternate between 2 'readers' depending of the 'ctrl' signal + alt2(r1, r2, ctrl) = \(sf, part).(ba.selectmulti(ma.SR/100, lr, ctrl) with { lr = r1(sf, part), r2(sf, part); }); + + altN(lrs, ctrl) = \(sf, part).(ba.selectmulti(ma.SR/100, mapper(lrs), ctrl) + with { + mapper((xs, xxs)) = xs(sf, part), mapper(xxs); + mapper(xs) = xs(sf, part); + }); + + step = super.srate(sf, part)/ma.SR; + + ramp1(sf, part) = it.raise(gate, step, super.length(sf, part)); + ramp2(sf, part) = it.decrease(gate, step, super.length(sf, part)); + + lramp = (ramp1, ramp2, ramp2, ramp2, ramp1); + }; + +}; // End of environment + +/* +// Using the `sound` environment allocated with a given `sf` and `part` + +import("soundfiles.lib"); + +s1 = soundfile("[url:{'piano-C5.ogg';'piano-G5.ogg';'piano-C6.ogg';'piano-G6.ogg'}]",2); +sample1 = so.sound(s1, 0); +sample2 = so.sound(s1, 1); +sample3 = so.sound(s1, 2); + +// Plays the sound in various ways +sample1.loop; +sample1.loop_speed(0.5); +sample1.loop_speed_level(0.5, 0.5); + +sample2.play(0.5, button("gate")); +sample2.play_rev(0.5, button("gate")); +sample2.play_alt(0.5, button("gate"), checkbox("alt")); + +sample3.play_interp(440.0, 600.0, 0.5, button("gate"), it.linear); +sample3.play_interp(440.0, 800.0, en.ar(0.1, 0.8, button("gate")), button("gate"), it.cubic); + +play = button("gate"); +sample3.play_interp(440.0, + hslider("freq", 200, 200, 880, 0.01), + hslider("gain", 0.5, 0, 1, 0.01)*en.ar(0.1, 0.8, play), + play, + nentry("interp", 0, 0, 3, 1)); + +*/ diff --git a/dist/examples/LIBRARIES/spats.lib b/dist/examples/LIBRARIES/spats.lib new file mode 100644 index 00000000..3ca4cebd --- /dev/null +++ b/dist/examples/LIBRARIES/spats.lib @@ -0,0 +1,145 @@ +//#################################### spats.lib ########################################## +// This library contains a collection of tools for sound spatialization. +// Its official prefix is `sp`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ + ************************************************************************ +FAUST library file +Copyright (C) 2003-2012 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. + + ************************************************************************ + ************************************************************************/ + +si = library("signals.lib"); + +declare name "Faust Spatialization Library"; +declare version "0.0"; + +//-----------------------`(sp.)panner`------------------------ +// A simple linear stereo panner. +// `panner` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : panner(g) : _,_ +// ``` +// +// Where: +// +// * `g`: the panning (0-1) +//------------------------------------------------------------ +panner(g) = _ <: *(1-g), *(g); + +// TODO: need demo function for panner here + + +//-----------------------`(sp.)spat`------------------------ +// GMEM SPAT: n-outputs spatializer. +// `spat` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : spat(n,r,d) : _,_,... +// ``` +// +// Where: +// +// * `n`: number of outputs +// * `r`: rotation (between 0 et 1) +// * `d`: distance of the source (between 0 et 1) +//------------------------------------------------------ +declare spat author "Laurent Pottier, revised by Romain Michon"; + +spat(n,a,d) = _ <: par(i, n, *( scaler(i, n, a, d) : si.smooth(0.9999) )) +with { + scaler(i,n,a,d) = (d/2.0+0.5) + * sqrt( max(0.0, 1.0 - abs(fmod(a+0.5+float(n-i)/n, 1.0) - 0.5) * n * d) ); +}; + + +//---------------`(sp.)stereoize`------------- +// Transform an arbitrary processor `p` into a stereo processor with 2 inputs +// and 2 outputs. +// +// #### Usage +// +// ``` +// _,_ : stereoize(p) : _,_ +// ``` +// +// Where: +// +// * `p`: the arbitrary processor +//---------------------------------------- +stereoize(p) = S(inputs(p), outputs(p)) +with { + // degenerated processor with no outputs + S(n,0) = !,! : 0,0; // just in case, probably a rare case + // processors with no inputs + S(0,1) = !,! : p <: _,_; // add two fake inputs and split output + S(0,2) = !,! : p; + S(0,n) = !,! : p,p :> _,_; // we are sure this will work if n is odd + // processors with one input + S(1,1) = p,p; // add two fake inputs and split output + S(1,n) = p,p :> _,_; // we are sure this will work if n is odd + // processors with two inputs + S(2,1) = p <: _,_; // split the output + S(2,2) = p; // nothing to do, p is already stereo + // processors with inputs > 2 and outputs > 2 + S(n,m) = _,_ <: p,p :> _,_; // we are sure this works if n or p are odd +}; + +// TODO: need demo function of spat here + +////////////////////////////////////////////////////////////////////////////////////////// +// UNDOCUMENTED/DISMISSED ELEMENTS +////////////////////////////////////////////////////////////////////////////////////////// + +// music.lib: + // The following functions could remain available but they would have to be + // factorized and reimplemented using the `par` function... + // bus2 = _,_; + // bus3 = _,_,_; + // bus4 = _,_,_,_; + // bus5 = _,_,_,_,_; + // bus6 = _,_,_,_,_,_; + // bus7 = _,_,_,_,_,_,_; + // bus8 = _,_,_,_,_,_,_,_; + // gain2(g) = *(g),*(g); + // gain3(g) = *(g),*(g),*(g); + // gain4(g) = *(g),*(g),*(g),*(g); + // gain5(g) = *(g),*(g),*(g),*(g),*(g); + // gain6(g) = *(g),*(g),*(g),*(g),*(g),*(g); + // gain7(g) = *(g),*(g),*(g),*(g),*(g),*(g),*(g); + // gain8(g) = *(g),*(g),*(g),*(g),*(g),*(g),*(g),*(g); diff --git a/dist/examples/LIBRARIES/stdfaust.lib b/dist/examples/LIBRARIES/stdfaust.lib new file mode 100644 index 00000000..25e1922f --- /dev/null +++ b/dist/examples/LIBRARIES/stdfaust.lib @@ -0,0 +1,38 @@ +//################################ stdfaust.lib ########################################## +// The purpose of this library is to give access to all the Faust standard libraries +// through a series of environments. +//######################################################################################## + +aa = library("aanl.lib"); +sf = library("all.lib"); +an = library("analyzers.lib"); +ba = library("basics.lib"); +co = library("compressors.lib"); +de = library("delays.lib"); +dm = library("demos.lib"); +dx = library("dx7.lib"); +en = library("envelopes.lib"); +fd = library("fds.lib"); +fi = library("filters.lib"); +ho = library("hoa.lib"); +it = library("interpolators.lib"); +ma = library("maths.lib"); +mi = library("mi.lib"); +ef = library("misceffects.lib"); +os = library("oscillators.lib"); +no = library("noises.lib"); +pf = library("phaflangers.lib"); +pl = library("platform.lib"); +pm = library("physmodels.lib"); +qu = library("quantizers.lib"); +rm = library("reducemaps.lib"); +re = library("reverbs.lib"); +ro = library("routes.lib"); +sp = library("spats.lib"); +si = library("signals.lib"); +so = library("soundfiles.lib"); +sy = library("synths.lib"); +ve = library("vaeffects.lib"); +vl = library("version.lib"); +wa = library("webaudio.lib"); +wd = library("wdmodels.lib"); diff --git a/dist/examples/LIBRARIES/synths.lib b/dist/examples/LIBRARIES/synths.lib new file mode 100644 index 00000000..44573864 --- /dev/null +++ b/dist/examples/LIBRARIES/synths.lib @@ -0,0 +1,322 @@ +//################################### synths.lib ########################################## +// This library contains a collection of synthesizers. Its official prefix is `sy`. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2003-2016 GRAME, Centre National de Creation Musicale +---------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +ba = library("basics.lib"); +en = library("envelopes.lib"); +fi = library("filters.lib"); +os = library("oscillators.lib"); +no = library("noises.lib"); + +declare name "Faust Synthesizer Library"; +declare version "0.1"; + +//-----------------------------------`(sy.)popFilterPerc`-------------------------------------- +// A simple percussion instrument based on a "popped" resonant bandpass filter. +// `popFilterPerc` is a standard Faust function. +// +// #### Usage +// +// ``` +// popFilterDrum(freq,q,gate) : _ +// ``` +// +// Where: +// +// * `freq`: the resonance frequency of the instrument +// * `q`: the q of the res filter (typically, 5 is a good value) +// * `gate`: the trigger signal (0 or 1) +//---------------------------------------------------------------------------------------- +declare popFilterDrum author "Romain Michon"; + +popFilterDrum(freq,q,gate) = en.ar(0.001,0.001,gate)*no.noise : fi.resonbp(freq,q,1); + + +//---------------------------------------`(sy.)dubDub`----------------------------------------- +// A simple synth based on a sawtooth wave filtered by a resonant lowpass. +// `dubDub` is a standard Faust function. +// +// #### Usage +// +// ``` +// dubDub(freq,ctFreq,q,gate) : _ +// ``` +// +// Where: +// +// * `freq`: frequency of the sawtooth +// * `ctFreq`: cutoff frequency of the filter +// * `q`: Q of the filter +// * `gate`: the trigger signal (0 or 1) +//---------------------------------------------------------------------------------------- +declare dubDub author "Romain Michon"; + +dubDub(freq,ctFreq,q,gate) = os.sawtooth(freq)*gainEnvelope : fi.resonlp(ctFreq,q,1) +with { + maxGain = 0.5; + gainEnvelope = en.smoothEnvelope(0.01,gate)*maxGain; +}; + + +//-----------------------------------`(sy.)sawTrombone`---------------------------------------- +// A simple trombone based on a lowpassed sawtooth wave. +// `sawTrombone` is a standard Faust function. +// +// #### Usage +// +// ``` +// sawTrombone(att,freq,gain,gate) : _ +// ``` +// +// Where: +// +// * `att`: exponential attack duration in s (typically 0.01) +// * `freq`: the frequency +// * `gain`: the gain (0-1) +// * `gate`: the gate (0 or 1) +//---------------------------------------------------------------------------------------- +declare sawTrombone author "Romain Michon"; + +sawTrombone(freq,gain,gate) = os.sawtooth(freq)*gainEnvelope : fi.lowpass(3,cutoff) +with { + // controls both the gain of the instrument and the lowpass frequency + gainEnvelope = en.smoothEnvelope(0.01,gate)*gain; + cutoff = gainEnvelope*5000+50; +}; + + +//-----------------------------------`(sy.)combString`----------------------------------------- +// Simplest string physical model ever based on a comb filter. +// `combString` is a standard Faust function. +// +// #### Usage +// +// ``` +// combString(freq,res,gate) : _ +// ``` +// +// Where: +// +// * `freq`: the frequency of the string +// * `res`: string T60 (resonance time) in second +// * `gate`: trigger signal (0 or 1) +//---------------------------------------------------------------------------------------- +declare combString author "Romain Michon"; + +combString(freq,res,gate) = excitation : fi.fb_fcomb(maxDel,N,b0,aN) +with { + maxDel = 1024; + N = ma.SR/freq; + b0 = 1; + aN = ba.tau2pole(res*0.001)*-1; + excitation = no.noise*en.ar(0.001,0.001,gate); +}; + + +//-----------------------------------`(sy.)additiveDrum`--------------------------------------- +// A simple drum using additive synthesis. +// `additiveDrum` is a standard Faust function. +// +// #### Usage +// +// ``` +// additiveDrum(freq,freqRatio,gain,harmDec,att,rel,gate) : _ +// ``` +// +// Where: +// +// * `freq`: the resonance frequency of the drum +// * `freqRatio`: a list of ratio to choose the frequency of the mode in +// function of `freq` e.g.(1 1.2 1.5 ...). The first element should always +// be one (fundamental). +// * `gain`: the gain of each mode as a list (1 0.9 0.8 ...). The first element +// is the gain of the fundamental. +// * `harmDec`: harmonic decay ratio (0-1): configure the speed at which +// higher modes decay compare to lower modes. +// * `att`: attack duration in second +// * `rel`: release duration in second +// * `gate`: trigger signal (0 or 1) +//---------------------------------------------------------------------------------------- +declare additiveDrum author "Romain Michon"; + +additiveDrum(freq,freqRatio,gain,modeDec,att,rel,gate) = par(i,N,os.osc(modeFreq(i))*gainEnvelope(i)) :> _ +with { + N = ba.count(freqRatio); + modeFreq(i) = freq*ba.take(i+1,freqRatio); + modeGain(i) = ba.take(i+1,gain); + gainEnvelope(i) = modeGain(i)*en.ar(att,rel*(1-(modeDec*(i/N))),gate); +}; + + +//-----------------------------------`(sy.)fm`--------------------------------------- +// An FM synthesizer with an arbitrary number of modulators connected as a sequence. +// `fm` is a standard Faust function. +// +// #### Usage +// +// ``` +// freqs = (300,400,...); +// indices = (20,...); +// fm(freqs,indices) : _ +// ``` +// +// Where: +// +// * `freqs`: a list of frequencies where the first one is the frequency of the carrier +// and the others, the frequency of the modulator(s) +// * `indices`: the indices of modulation (Nfreqs-1) +//---------------------------------------------------------------------------------------- +declare fm author "Romain Michon"; + +fm(freqs,indices) = seq(i,N,fmBlock(i)) +with { + N = ba.count(freqs); + freq(i) = ba.take(N-i,freqs); + gain(i) = ba.take(N-i,indices); + fmBlock(0) = freq(0) : os.osc; + fmBlock(i) = *(gain(i))+freq(i) : os.osc; +}; + + +//===============================Drum Synthesis=================================== +// Drum Synthesis ported in Faust from a version written in [Elementary](https://www.elementary.audio/) +// and JavaScript by Nick Thompson. +// +// #### Reference +// +// +//======================================================================================== + +//-----------------------------------`(sy.)kick`--------------------------------------- +// Kick drum synthesis via a pitched sine sweep. +// +// #### Usage +// +// ``` +// kick(pitch, click, attack, decay, drive, gate) : _ +// ``` +// +// Where: +// +// * `pitch`: the base frequency of the kick drum in Hz +// * `click`: the speed of the pitch envelope, tuned for [0.005s, 1s] +// * `attack`: attack time in seconds, tuned for [0.005s, 0.4s] +// * `decay`: decay time in seconds, tuned for [0.005s, 4.0s] +// * `drive`: a gain multiplier going into the saturator. Tuned for [1, 10] +// * `gate`: the gate which triggers the amp envelope +// +// #### Reference +// +// +//------------------------------------------------------------------------------------- +kick(pitch, click, attack, decay, drive, gate) = out +with { + env = en.adsr(attack, decay, 0.0, 0.1, gate); + pitchenv = en.adsr(0.005, click, 0.0, 0.1, gate); + clean = env * os.osc((1 + pitchenv * 4) * pitch); + out = ma.tanh(clean * drive); +}; + + +//-----------------------------------`(sy.)clap`--------------------------------------- +// Clap synthesis via filtered white noise. +// +// #### Usage +// +// ``` +// clap(tone, attack, decay, gate) : _ +// ``` +// +// Where: +// +// * `tone`: bandpass filter cutoff frequency, tuned for [400Hz, 3500Hz] +// * `attack`: attack time in seconds, tuned for [0s, 0.2s] +// * `decay`: decay time in seconds, tuned for [0s, 4.0s] +// * `gate`: the gate which triggers the amp envelope +// +// #### Reference +// +// +//------------------------------------------------------------------------------------- +clap(tone, attack, decay, gate) = out +with { + e1 = en.adsr(0.035 + attack, 0.06 + decay, 0.0, 0.1, gate); + e2 = en.adsr(0.025 + attack, 0.05 + decay, 0.0, 0.1, gate); + e3 = en.adsr(0.015 + attack, 0.04 + decay, 0.0, 0.1, gate); + e4 = en.adsr(0.005 + attack, 0.02 + decay, 0.0, 0.1, gate); + out = ma.tanh(((e1 + e2 + e3 + e4) * no.noise) : fi.resonlp(tone, 1.214, 1)); +}; + + +//-----------------------------------`(sy.)hat`--------------------------------------- +// Hi hat drum synthesis via phase modulation. +// +// #### Usage +// +// ``` +// hat(pitch, tone, attack, decay, gate): _ +// ``` +// +// Where: +// +// * `pitch`: base frequency in the range [317Hz, 3170Hz] +// * `tone`: bandpass filter cutoff frequency, tuned for [800Hz, 18kHz] +// * `attack`: attack time in seconds, tuned for [0.005s, 0.2s] +// * `decay`: decay time in seconds, tuned for [0.005s, 4.0s] +// * `gate`: the gate which triggers the amp envelope +// +// #### Reference +// +// +//------------------------------------------------------------------------------------- +hat(pitch, tone, attack, decay, gate) = out +with { + m2 = no.noise; + m1 = cycle(2 * pitch, 2 * m2); + m0 = cycle(pitch, 2 * m1); + f = m0 : fi.resonlp(tone, 1.214, 1); + env = en.adsr(attack, decay, 0.0, 0.1, gate); + out = f * env; + cycle(freq, offset) = sin(2 * ma.PI * p) + with { + t = phasor(freq) + offset; + p = t - floor(t); + phasor(f) = f/ma.SR : (+ : decimalpart) ~ _ with { decimalpart(x) = x-int(x); }; + }; +}; diff --git a/dist/examples/LIBRARIES/tonestacks.lib b/dist/examples/LIBRARIES/tonestacks.lib new file mode 100644 index 00000000..c8ba6bb3 --- /dev/null +++ b/dist/examples/LIBRARIES/tonestacks.lib @@ -0,0 +1,427 @@ +/** + ** Guitar tone stacks (based on the work from D.T. Yeh) + ** some values are taken from CAPS plugin tonestack + ** + ** this tonestacks.library provide the following tonestack models: + ** bassman, mesa, twin, princeton, jcm800, jcm2000, jtm45, mlead, + ** m2199, ac30, ac15, soldano, sovtek, peavey, ibanez, roland, + ** ampeg, ampeg_rev, bogner, groove, crunch, fender_blues, + ** fender_default, fender_deville, gibsen + ** + ** USAGE : + ** _:component("tonestacks.lib").model(t,m,l):_ + ** WHERE : + ** model is on of the models above. + ** t is treble freq control in range of (0.0 - 1.0) + ** m is middle freq control in range of (0.0 - 1.0) + ** l is low freq control in range of (0.0 - 1.0) + ** + ** EXAMPLE : + ** process = component("tonestacks.lib").jcm2000(t,m,l) + ** with { + ** t = vslider("Treble ", 0.5, 0, 1, 0.01); + ** m = vslider("Middle ", 0.5, 0, 1, 0.01); + ** l = vslider("Bass ", 0.5, 0, 1, 0.01); + ** }; + **/ + +ma = library("maths.lib"); +fi = library("filters.lib"); + +declare name "Faust Tonestack Emulation Library"; +declare author "Guitarix project ()"; +declare copyright "Guitarix project"; +declare version "0.28"; +declare license "LGPL"; + +/**************************************************************** + ** Equalisation 3 bands + ** C1 + ** IN >---------||--------- + ** | | + ** | | + ** | | R4 | | R1 Treble + ** | | | |<------< Out + ** | | | | + ** | C2 | + ** |-------||--------|------ + ** | | | + ** | | | | + ** | | |<---- R2 Bass + ** | | | + ** | | + ** | C3 | | + ** --------||------>| | R3 Middle + ** | | + ** | + ** _|_ + ** - + ** + ****************************************************************/ + +tonestack(C1,C2,C3,R1,R2,R3,R4,t,m,L) = + 1/A0*fi.iir((B0,B1,B2,B3),(A1/A0,A2/A0,A3/A0)) + with { + + l = L : (_-1)*3.4 : exp; + + b1 = t*C1*R1 + m*C3*R3 + l*(C1*R2 + C2*R2) + (C1*R3 + C2*R3); + + b2 = t*(C1*C2*R1*R4 + C1*C3*R1*R4) - m*m*(C1*C3*R3*R3 + C2*C3*R3*R3) + + m*(C1*C3*R1*R3 + C1*C3*R3*R3 + C2*C3*R3*R3) + + l*(C1*C2*R1*R2 + C1*C2*R2*R4 + C1*C3*R2*R4) + + l*m*(C1*C3*R2*R3 + C2*C3*R2*R3) + + (C1*C2*R1*R3 + C1*C2*R3*R4 + C1*C3*R3*R4); + + b3 = l*m*(C1*C2*C3*R1*R2*R3 + C1*C2*C3*R2*R3*R4) + - m*m*(C1*C2*C3*R1*R3*R3 + C1*C2*C3*R3*R3*R4) + + m*(C1*C2*C3*R1*R3*R3 + C1*C2*C3*R3*R3*R4) + + t*C1*C2*C3*R1*R3*R4 - t*m*C1*C2*C3*R1*R3*R4 + + t*l*C1*C2*C3*R1*R2*R4; + + a0 = 1; + + a1 = (C1*R1 + C1*R3 + C2*R3 + C2*R4 + C3*R4) + + m*C3*R3 + l*(C1*R2 + C2*R2); + + a2 = m*(C1*C3*R1*R3 - C2*C3*R3*R4 + C1*C3*R3*R3 + C2*C3*R3*R3) + + l*m*(C1*C3*R2*R3 + C2*C3*R2*R3) + - m*m*(C1*C3*R3*R3 + C2*C3*R3*R3) + + l*(C1*C2*R2*R4 + C1*C2*R1*R2 + C1*C3*R2*R4 + C2*C3*R2*R4) + + (C1*C2*R1*R4 + C1*C3*R1*R4 + C1*C2*R3*R4 + C1*C2*R1*R3 + C1*C3*R3*R4 + C2*C3*R3*R4); + + a3 = l*m*(C1*C2*C3*R1*R2*R3 + C1*C2*C3*R2*R3*R4) + - m*m*(C1*C2*C3*R1*R3*R3 + C1*C2*C3*R3*R3*R4) + + m*(C1*C2*C3*R3*R3*R4 + C1*C2*C3*R1*R3*R3 - C1*C2*C3*R1*R3*R4) + + l*C1*C2*C3*R1*R2*R4 + + C1*C2*C3*R1*R3*R4; + + c = 2*float(ma.SR); + + B0 = -b1*c - b2*pow(c,2) - b3*pow(c,3); + B1 = -b1*c + b2*pow(c,2) + 3*b3*pow(c,3); + B2 = b1*c + b2*pow(c,2) - 3*b3*pow(c,3); + B3 = b1*c - b2*pow(c,2) + b3*pow(c,3); + A0 = -a0 - a1*c - a2*pow(c,2) - a3*pow(c,3); + A1 = -3*a0 - a1*c + a2*pow(c,2) + 3*a3*pow(c,3); + A2 = -3*a0 + a1*c + a2*pow(c,2) - 3*a3*pow(c,3); + A3 = -a0 + a1*c - a2*pow(c,2) + a3*pow(c,3); +}; + +ts = environment { + k = *(1e3); + M = *(1e6); + nF = *(1e-9); + pF = *(1e-12); + + /* Fender */ + + bassman = environment { /* 59 Bassman 5F6-A */ + R1 = 250:k; + R2 = 1:M; + R3 = 25:k; + R4 = 56:k; + C1 = 250:pF; + C2 = 20:nF; + C3 = 20:nF; + }; + + mesa = environment { /* Mesa Boogie Mark */ + R1 = 250:k; + R2 = 250:k; + R3 = 25:k; + R4 = 100:k; + C1 = 250:pF; + C2 = 100:nF; + C3 = 47:nF; + }; + + twin = environment { /* 69 Twin Reverb AA270 */ + R1 = 250:k; + R2 = 250:k; + R3 = 10:k; + R4 = 100:k; + C1 = 120:pF; + C2 = 100:nF; + C3 = 47:nF; + }; + + princeton = environment { /* 64 Princeton AA1164 */ + R1 = 250:k; + R2 = 250:k; + R3 = 4.8:k; + R4 = 100:k; + C1 = 250:pF; + C2 = 100:nF; + C3 = 47:nF; + }; + + /* Marshall */ + + jcm800 = environment { /* 59/81 JCM-800 Lead 100 2203 */ + R1 = 220:k; + R2 = 1:M; + R3 = 22:k; + R4 = 33:k; + C1 = 470:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + /* 90 JCM-900 Master 2100: same as JCM-800 */ + + jcm2000 = environment { /* 81 2000 Lead */ + R1 = 250:k; + R2 = 1:M; + R3 = 25:k; + R4 = 56:k; /* a 10 k fixed + 100 k pot in series actually */ + C1 = 500:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + jtm45 = environment { /* JTM 45 */ + R1 = 250:k; + R2 = 1:M; + R3 = 25:k; + R4 = 33:k; + C1 = 270:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + /* parameter order is R1 - R4, C1 - C3 */ + mlead = environment { /* 67 Major Lead 200 */ + R1 = 250:k; + R2 = 1:M; + R3 = 25:k; + R4 = 33:k; + C1 = 500:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + m2199 = environment { /* undated M2199 30W solid state */ + R1 = 250:k; + R2 = 250:k; + R3 = 25:k; + R4 = 56:k; + C1 = 250:pF; + C2 = 47:nF; + C3 = 47:nF; + }; + + /* Vox */ + ac30 = environment { /* 59/86 AC-30 */ + /* R3 is fixed (circuit differs anyway) */ + R1 = 1:M; + R2 = 1:M; + R3 = 10:k; + R4 = 100:k; + C1 = 50:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + ac15 = environment { /* VOX AC-15 */ + R1 = 220:k; + R2 = 220:k; + R3 = 220:k; + R4 = 100:k; + C1 = 470:pF; + C2 = 100:nF; + C3 = 47:nF; + }; + + soldano = environment { /* Soldano SLO 100 */ + R1 = 250:k; + R2 = 1:M; + R3 = 25:k; + R4 = 47:k; + C1 = 470:pF; + C2 = 20:nF; + C3 = 20:nF; + }; + + sovtek = environment { /* MIG 100 H*/ + R1 = 500:k; + R2 = 1:M; + R3 = 10:k; + R4 = 47:k; + C1 = 470:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + peavey = environment { /* c20*/ + R1 = 250:k; + R2 = 250:k; + R3 = 20:k; + R4 = 68:k; + C1 = 270:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + ibanez = environment { /* gx20 */ + R1 = 250:k; + R2 = 250:k; + R3 = 10:k; + R4 = 100:k; + C1 = 270:pF; + C2 = 100:nF; + C3 = 40:nF; + }; + + roland = environment { /* Cube 60 */ + R1 = 250:k; + R2 = 250:k; + R3 = 10:k; + R4 = 41:k; + C1 = 240:pF; + C2 = 33:nF; + C3 = 82:nF; + }; + + ampeg = environment { /* VL 501 */ + R1 = 250:k; + R2 = 1:M; + R3 = 25:k; + R4 = 32:k; + C1 = 470:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + ampeg_rev = environment { /* reverbrocket*/ + R1 = 250:k; + R2 = 250:k; + R3 = 10:k; + R4 = 100:k; + C1 = 100:pF; + C2 = 100:nF; + C3 = 47:nF; + }; + + bogner = environment { /* Triple Giant Preamp */ + R1 = 250:k; + R2 = 1:M; + R3 = 33:k; + R4 = 51:k; + C1 = 220:pF; + C2 = 15:nF; + C3 = 47:nF; + }; + + groove = environment { /* Trio Preamp */ + R1 = 220:k; + R2 = 1:M; + R3 = 22:k; + R4 = 68:k; + C1 = 470:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + crunch = environment { /* Hughes&Kettner */ + R1 = 220:k; + R2 = 220:k; + R3 = 10:k; + R4 = 100:k; + C1 = 220:pF; + C2 = 47:nF; + C3 = 47:nF; + }; + + fender_blues = environment { /* Fender blues junior */ + R1 = 250:k; + R2 = 250:k; + R3 = 25:k; + R4 = 100:k; + C1 = 250:pF; + C2 = 22:nF; + C3 = 22:nF; + }; + + fender_default = environment { /* Fender */ + R1 = 250:k; + R2 = 250:k; + R3 = 10:k; + R4 = 100:k; + C1 = 250:pF; + C2 = 100:nF; + C3 = 47:nF; + }; + + fender_deville = environment { /* Fender Hot Rod */ + R1 = 250:k; + R2 = 250:k; + R3 = 25:k; + R4 = 130:k; + C1 = 250:pF; + C2 = 100:nF; + C3 = 22:nF; + }; + + gibsen = environment { /* gs12 reverbrocket */ + R1 = 1:M; + R2 = 1:M; + R3 = 94:k; // 47k fixed + R4 = 270:k; + C1 = 25:pF; + C2 = 60:nF; + C3 = 20:nF; + }; + +}; + +bassman(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.bassman;}; +mesa(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.mesa;}; +twin(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.twin;}; +princeton(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.princeton;}; +jcm800(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.jcm800;}; +jcm2000(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.jcm2000;}; +jtm45(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.jtm45;}; +mlead(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.mlead;}; +m2199(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.m2199;}; +ac30(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.ac30;}; +ac15(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.ac15;}; +soldano(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.soldano;}; +sovtek(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.sovtek;}; +peavey(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.peavey;}; +ibanez(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.ibanez;}; +roland(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.roland;}; +ampeg(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.ampeg;}; +ampeg_rev(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.ampeg_rev;}; +bogner(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.bogner;}; +groove(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.groove;}; +crunch(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.crunch;}; +fender_blues(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.fender_blues;}; +fender_default(T,M,L)= tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.fender_default;}; +fender_deville(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.fender_deville;}; +gibsen(T,M,L) = tonestack(t.C1,t.C2,t.C3,t.R1,t.R2,t.R3,t.R4,T,M,L) + with {t = ts.gibsen;}; + diff --git a/dist/examples/LIBRARIES/tubes.lib b/dist/examples/LIBRARIES/tubes.lib new file mode 100644 index 00000000..637c1d3c --- /dev/null +++ b/dist/examples/LIBRARIES/tubes.lib @@ -0,0 +1,5037 @@ +/****************************************************************************** + ** Guitar(ix) tube amp emulations + ** + ** + ** this tubes.library provide the following tube models: + ** T1_12AX7, T2_12AX7, T3_12AX7, T1_12AT7, T2_12AT7, T3_12AT7, + ** T1_12AU7, T2_12AU7, T3_12AU7, T1_6V6, T2_6V6, T3_6V6, + ** T1_6DJ8, T2_6DJ8, T3_6DJ8, T1_6C16, T2_6C16, T3_6C16 + ** + ** + ** USAGE: + ** _ : component("tubes.lib").model : _ + ** where + ** model is on of the models above. + ** + ** EXAMPLE 2 STAGE TUBE PREAMP: + ** process = component("tubes.lib").T1_12AX7 : *(preamp): + ** lowpass(1,6531.0) : component("tubes.lib").T2_12AX7 : *(preamp): + ** lowpass(1,6531.0) : component("tubes.lib").T3_12AX7 : *(gain) with { + ** preamp = vslider("Pregain",-6,-20,20,0.1) : db2linear : smooth(0.999); + ** gain = vslider("Gain", -6, -20.0, 20.0, 0.1) : db2linear : smooth(0.999); + ** }; + ** + ******************************************************************************/ + +fi = library("filters.lib"); + +/******************************************************************************* + * 1-dimensional function tables for linear interpolation +*******************************************************************************/ + +//-- Rdtable from waveform +rtable(table, r) = (table, int(r)):rdtable; + +// Change sign of input signal x; +inverse(x) = abs(x) * invsign(x); + +// function that takes f value and x sign +ccopysign(f, x) = abs(f) * sign(x); + +//-- Get sign and reversed sign of a signal x +sign(x) = x<0, 1, -1 : select2; +invsign(x) = x<0, -1, 1 : select2; + +//-- Interpolate value between i and i+1 in table with coefficient f. +interpolation(table, f, i) = rtable(table, i)*(1-f) + rtable(table,i+1)*f; + +//-- Bound Index with table boundaries +boundIndex(size, index) = index : floor: min(size-1) : max(0); + +//-- Bound factor of interpolation : +//if index<0 return 0 | if index>size-1 return size-1 +boundFactor(size, factor, index) = + select2(0 +//######################################################################################## + +ma = library("maths.lib"); +si = library("signals.lib"); +an = library("analyzers.lib"); +fi = library("filters.lib"); +ef = library("misceffects.lib"); + +declare name "Faust Virtual Analog Filter Effect Library"; +declare version "0.2"; + +//######################################################################################## +/************************************************************************ +FAUST library file, jos section + +Except where noted otherwise, The Faust functions below in this +section are Copyright (C) 2003-2017 by Julius O. Smith III +([jos](http://ccrma.stanford.edu/~jos/)), and released under the +(MIT-style) [STK-4.3](#stk-4.3-license) license. + +All MarkDown comments in this section are Copyright 2016-2017 by Romain +Michon and Julius O. Smith III, and are released under the +[CCA4I](https://creativecommons.org/licenses/by/4.0/) license (TODO: if/when Romain agrees!) + +************************************************************************/ + +//====================================Moog Filters======================================== +//======================================================================================== + +//-------------------------`(ve.)moog_vcf`--------------------------- +// Moog "Voltage Controlled Filter" (VCF) in "analog" form. Moog VCF +// implemented using the same logical block diagram as the classic +// analog circuit. As such, it neglects the one-sample delay associated +// with the feedback path around the four one-poles. +// This extra delay alters the response, especially at high frequencies +// (see reference [1] for details). +// See `moog_vcf_2b` below for a more accurate implementation. +// +// #### Usage +// +// ``` +// _ : moog_vcf(res,fr) : _ +// ``` +// Where: +// +// * `res`: normalized amount of corner-resonance between 0 and 1 +// (0 is no resonance, 1 is maximum) +// * `fr`: corner-resonance frequency in Hz (less than SR/6.3 or so) +// +// #### References +// * +// * +//------------------------------------------------------------ +declare moog_vcf author "Julius O. Smith III"; +declare moog_vcf copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare moog_vcf license "MIT-style STK-4.3 license"; +moog_vcf(res,fr) = (+ : seq(i,4,fi.pole(p)) : *(unitygain(p))) ~ *(mk) +with { + p = 1.0 - fr * 2.0 * ma.PI / ma.SR; // good approximation for fr << SR + unitygain(p) = pow(1.0-p,4.0); // one-pole unity-gain scaling + mk = -4.0*max(0,min(res,0.999999)); // need mk > -4 for stability +}; + +//-----------------------`(ve.)moog_vcf_2b[n]`--------------------------- +// Moog "Voltage Controlled Filter" (VCF) as two biquads. Implementation +// of the ideal Moog VCF transfer function factored into second-order +// sections. As a result, it is more accurate than `moog_vcf` above, but +// its coefficient formulas are more complex when one or both parameters +// are varied. Here, res is the fourth root of that in `moog_vcf`, so, as +// the sampling rate approaches infinity, `moog_vcf(res,fr)` becomes equivalent +// to `moog_vcf_2b[n](res^4,fr)` (when res and fr are constant). +// `moog_vcf_2b` uses two direct-form biquads (`tf2`). +// `moog_vcf_2bn` uses two protected normalized-ladder biquads (`tf2np`). +// +// #### Usage +// +// ``` +// _ : moog_vcf_2b(res,fr) : _ +// _ : moog_vcf_2bn(res,fr) : _ +// ``` +// +// Where: +// +// * `res`: normalized amount of corner-resonance between 0 and 1 +// (0 is min resonance, 1 is maximum) +// * `fr`: corner-resonance frequency in Hz +//------------------------------------------------------------ +declare moog_vcf_2b author "Julius O. Smith III"; +declare moog_vcf_2b copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare moog_vcf_2b license "MIT-style STK-4.3 license"; +moog_vcf_2b(res,fr) = fi.tf2s(0,0,b0,a11,a01,w1) : fi.tf2s(0,0,b0,a12,a02,w1) +with { + s = 1; // minus the open-loop location of all four poles + frl = max(20,min(10000,fr)); // limit fr to reasonable 20-10k Hz range + w1 = 2*ma.PI*frl; // frequency-scaling parameter for bilinear xform + // Equivalent: w1 = 1; s = 2*PI*frl; + kmax = sqrt(2)*0.99999; // 0.99999 gives stability margin (tf2 is unprotected) + k = min(kmax,sqrt(2)*res); // fourth root of Moog VCF feedback gain + b0 = s^2; + s2k = sqrt(2) * k; + a11 = s * (2 + s2k); + a12 = s * (2 - s2k); + a01 = b0 * (1 + s2k + k^2); + a02 = b0 * (1 - s2k + k^2); +}; + +declare moog_vcf_2bn author "Julius O. Smith III"; +declare moog_vcf_2bn copyright "Copyright (C) 2003-2019 by Julius O. Smith III "; +declare moog_vcf_2bn license "MIT-style STK-4.3 license"; +moog_vcf_2bn(res,fr) = fi.tf2snp(0,0,b0,a11,a01,w1) : fi.tf2snp(0,0,b0,a12,a02,w1) +with { + s = 1; // minus the open-loop location of all four poles + w1 = 2*ma.PI*max(fr,20); // frequency-scaling parameter for bilinear xform + k = sqrt(2)*0.99999*res; // fourth root of Moog VCF feedback gain + b0 = s^2; + s2k = sqrt(2) * k; + a11 = s * (2 + s2k); + a12 = s * (2 - s2k); + a01 = b0 * (1 + s2k + k^2); + a02 = b0 * (1 - s2k + k^2); +}; + + +//------------------`(ve.)moogLadder`----------------- +// Virtual analog model of the 4th-order Moog Ladder, which is arguably the +// most well-known ladder filter in analog synthesizers. Several +// 1st-order filters are cascaded in series. Feedback is then used, in part, to +// control the cut-off frequency and the resonance. +// +// #### References +// +// [Zavalishin 2012] (revision 2.1.2, February 2020): +// +// * +// +// This fix is based on Lorenzo Della Cioppa's correction to Pirkle's implementation; see this post: +// https://www.kvraudio.com/forum/viewtopic.php?f=33&t=571909 +// +// #### Usage +// +// ``` +// _ : moogLadder(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: quality factor between .707 (0 feedback coefficient) to 25 (feedback = 4, which is the self-oscillating threshold). +//--------------------------------------------------------------------- +declare moogLadder author "Dario Sanfilippo"; +declare moogLadder license "MIT-style STK-4.3 license"; +moogLadder(normFreq, Q, x) = loop ~ si.bus(4) : (!,!,!,!,_) +with { + loop(s1, s2, s3, s4) = v1 + lp1 , // define s1 + v2 + lp2 , // define s2 + v3 + lp3 , // define s3 + v4 + lp4 , // define s4 + lp4 // system output + with { + T = 1.0 / ma.SR; + cf = normFreq * .5 * ma.SR; + k = 4.0 * (Q - 0.707) / (25.0 - 0.707); + omegaWarp = tan(ma.PI * cf * T); + g = omegaWarp / (1.0 + omegaWarp); + G = g * g * g * g; // ladder's G in generalised form y = G * xi + S + S = g * g * g * (s1 * (1 - g)) + g * g * (s2 * (1 - g)) + g * (s3 * (1 - g)) + (s4 * (1 - g)); // ladder's S in generalised form y = G * xi + S + u = (x - k * S) / (1.0 + k * G); // input to the first LP stage: u = (x - kS) / (1 + kG) + v1 = g * (u - s1); // v-signals in TPT integrator (Zavalishin, Figure 3.30) + v2 = g * (lp1 - s2); // second stage + v3 = g * (lp2 - s3); // third stage + v4 = g * (lp3 - s4); // fourth stage + lp1 = v1 + s1; // define outputs + lp2 = v2 + s2; + lp3 = v3 + s3; + lp4 = v4 + s4; + }; +}; + + +//------------------`(ve.)moogHalfLadder`----------------- +// Virtual analog model of the 2nd-order Moog Half Ladder (simplified version of +// `(ve.)moogLadder`). Several 1st-order filters are cascaded in series. +// Feedback is then used, in part, to control the cut-off frequency and the +// resonance. +// +// This filter was implemented in Faust by Eric Tarr during the +// [2019 Embedded DSP With Faust Workshop](https://ccrma.stanford.edu/workshops/faust-embedded-19/). +// +// #### References +// +// * +// * +// +// #### Usage +// +// ``` +// _ : moogHalfLadder(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare moogHalfLadder author "Eric Tarr"; +declare moogHalfLadder license "MIT-style STK-4.3 license"; +moogHalfLadder(normFreq,Q) = _ <: (s1,s2,s3,y) : !,!,!,_ +letrec{ + 's1 = -(s3*B3*k):-(s2*B2*k):-(s1*B1*k):*(alpha0):-(s1):*(alpha*2):+(s1); + 's2 = -(s3*B3*k):-(s2*B2*k):-(s1*B1*k):*(alpha0):-(s1):*(alpha):+(s1):-(s2):*(alpha*2):+(s2); + 's3 = -(s3*B3*k):-(s2*B2*k):-(s1*B1*k):*(alpha0):-(s1):*(alpha):+(s1):-(s2):*(alpha):+(s2):-(s3):*(alpha*2):+(s3); + 'y = -(s3*B3*k):-(s2*B2*k):-(s1*B1*k):*(alpha0):-(s1):*(alpha):+(s1):-(s2):*(alpha):+(s2) <:_*-1,((-(s3):*(alpha):+(s3))*2):>_; +} +with{ + freq = 2*(10^(3*normFreq+1)); + k = 2.0*(Q - 0.707)/(25.0 - 0.707); + wd = 2*ma.PI*freq; + T = 1/ma.SR; + wa = (2/T)*tan(wd*T/2); + g = wa*T/2; + G = g/(1.0 + g); + alpha = G; + GA = 2*G-1; // All-pass gain + B1 = GA*G/(1+g); + B2 = GA/(1+g); + B3 = 2/(1+g); + alpha0 = 1/(1 + k*GA*G*G); +}; + + +//------------------`(ve.)diodeLadder`----------------- +// 4th order virtual analog diode ladder filter. In addition to the individual +// states used within each independent 1st-order filter, there are also additional +// feedback paths found in the block diagram. These feedback paths are labeled +// as connecting states. Rather than separately storing these connecting states +// in the Faust implementation, they are simply implicitly calculated by +// tracing back to the other states (`s1`,`s2`,`s3`,`s4`) each recursive step. +// +// This filter was implemented in Faust by Eric Tarr during the +// [2019 Embedded DSP With Faust Workshop](https://ccrma.stanford.edu/workshops/faust-embedded-19/). +// +// #### References +// +// * +// * +// +// #### Usage +// +// ``` +// _ : diodeLadder(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare diodeLadder author "Eric Tarr"; +declare diodeLadder license "MIT-style STK-4.3 license"; +diodeLadder(normFreq,Q) = ef.cubicnl(1,0)*1.5 <:(s1,s2,s3,s4,y) : !,!,!,!,_ +letrec{ + 's1 = _-(s4*B4*SG4*k) : + _-((s4*B4*d3+s3)*B3*SG3*k) : + _-(((s4*B4*d3+s3)*B3*d2 + s2)*B2*SG3*k) : + _-((((s4*B4*d3+s3)*B3*d2 + s2)*B2*d1 + s1)*B1*SG1*k) : + _*alpha0: _*gam1 : _+((s4*B4*d3+s3)*B3*d2 + s2)*B2 : //_+S2 + _+((((s4*B4*d3+s3)*B3*d2 + s2)*B2)*d1 + s1)*B1*G2 : // _ + (S2 ... + _*a1 : _-s1 :_*alpha*2 : _+s1; + + 's2 = _-(s4*B4*SG4*k) : + _-((s4*B4*d3+s3)*B3*SG3*k) : + _-(((s4*B4*d3+s3)*B3*d2 + s2)*B2*SG3*k): + _-((((s4*B4*d3+s3)*B3*d2 + s2)*B2*d1 + s1)*B1*SG1*k) : + _*alpha0: _*gam1 : _+((s4*B4*d3+s3)*B3*d2 + s2)*B2 : //_+S2 + _+((((s4*B4*d3+s3)*B3*d2 + s2)*B2)*d1 + s1)*B1*G2 : // _ + (S2 ... + _*a1 : _-s1 :_*alpha : _+s1 : _*gam2 : + _+(s4*B4*d3 + s3)*B3 : //_+S3 : + _+(((s4*B4*d3 + s3)*B3)*d2 + s2)*B2*G3 : //_+(S3...) + _*a2 : _-s2 : _*alpha*2 : _+s2; + + 's3 = _-(s4*B4*SG4*k) : + _-((s4*B4*d3+s3)*B3*SG3*k) : + _-(((s4*B4*d3+s3)*B3*d2 + s2)*B2*SG3*k) : + _-((((s4*B4*d3+s3)*B3*d2 + s2)*B2*d1 + s1)*B1*SG1*k) : + _*alpha0 : _*gam1 : _+((s4*B4*d3+s3)*B3*d2 + s2)*B2 : //_+S2 + _+((((s4*B4*d3+s3)*B3*d2 + s2)*B2)*d1+s1)*B1*G2 : // _ + (S2 ... + _*a1 : _-s1 :_*alpha : _+s1 : _*gam2 : + _+(s4*B4*d3 + s3)*B3 : //_+S3 : + _+(((s4*B4*d3 + s3)*B3)*d2 + s2)*B2*G3 : //_+(S3...) + _*a2 : _-s2 : _*alpha : _+s2 : _*gam3: + _+s4*B4 : // _ + S4 + _+((s4*B4)*d3 + s3)*B3*G4: // _ + S4 ... + _*a3 : _-s3 : _*alpha*2 : _+s3; + + 's4 = _-(s4*B4*SG4*k) : + _-((s4*B4*d3+s3)*B3*SG3*k) : + _-(((s4*B4*d3+s3)*B3*d2 + s2)*B2*SG3*k) : + _-((((s4*B4*d3+s3)*B3*d2 + s2)*B2*d1 + s1 )*B1*SG1*k) : + _*alpha0 : _*gam1 : _+((s4*B4*d3+s3)*B3*d2 + s2)*B2 : //_+S2 + _+((((s4*B4*d3+s3)*B3*d2 + s2)*B2)*d1 + s1)*B1*G2 : // _ + (S2 ... + _*a1 : _-s1 :_*alpha : _+s1 : _*gam2 : + _+(s4*B4*d3 + s3)*B3 : //_+S3 : + _+(((s4*B4*d3 + s3)*B3) *d2+s2)*B2*G3 : //_+(S3...) + _*a2 : _-s2 : _*alpha : _+s2 : _*gam3 : + _+s4*B4 : // _ + S4 + _+((s4*B4)*d3 + s3)*B3*G4: // _ + S4 ... + _*a3 : _-s3 : _*alpha : _+s3 : _*gam4 : _*a4 : _-s4 : _*alpha*2 : _+s4; + + // Output signal + 'y = _-(s4*B4*SG4*k) : + _-((s4*B4*d3+s3)*B3*SG3*k) : + _-(((s4*B4*d3+s3)*B3*d2 + s2)*B2*SG3*k) : + _-((((s4*B4*d3+s3)*B3*d2 + s2)*B2*d1 + s1 )*B1*SG1*k) : + _*alpha0: _*gam1 : _+((s4*B4*d3+s3)*B3*d2 + s2)*B2 : //_+S2 + _+((((s4*B4*d3+s3)*B3*d2 + s2)*B2)*d1 + s1)*B1*G2 : // _ + (S2 ... + _*a1 : _-s1 :_*alpha : _+s1 : _*gam2 : + _+(s4*B4*d3 + s3)*B3 : //_+S3 : + _+(((s4*B4*d3 + s3)*B3)*d2 + s2)*B2*G3 : //_+(S3...) + _*a2 : _-s2 : _*alpha : _+s2 : _*gam3 : + _+s4*B4 : // _ + S4 + _+((s4*B4)*d3 + s3)*B3*G4: // _ + S4 ... + _*a3 : _-s3 : _*alpha : _+s3 : _*gam4 : _*a4 : _-s4 : _*alpha : _+s4; +} +with{ + freq = 2*(10^(3*normFreq+1)); + k = (17 - (normFreq^10)*9.7)*(Q - 0.707)/(25.0 - 0.707); + wd = 2*ma.PI*freq; + T = 1/ma.SR; + wa = (2/T)*tan(wd*T/2); + g = wa*T/2; + G4 = 0.5*g/(1 + g); + G3 = 0.5*g/(1 + g - 0.5*g*G4); + G2 = 0.5*g/(1 + g - 0.5*g*G3); + G1 = g/(1.0 + g - g*G2); + Gamma = G1*G2*G3*G4; + SG1 = G4*G3*G2; // feedback gain pre-calculated + SG2 = G4*G3; + SG3 = G4; + SG4 = 1; + alpha = g/(1+g); + alpha0 = 1/(1+k*Gamma); + gam1 = 1+G1*G2; + gam2 = 1+G2*G3; + gam3 = 1+G3*G4; + gam4 = 1; + a1 = 1; // a0 for 1st LPF + a2 = 0.5; // a0 for 2nd LPF + a3 = 0.5; + a4 = 0.5; + B1 = 1/(1+g-g*G2); // Beta for 1st block + B2 = 1/(1+g-0.5*g*G3); + B3 = 1/(1+g-0.5*g*G4); + B4 = 1/(1+g); + d1 = g; // delta for 1st block + d2 = 0.5*g; + d3 = 0.5*g; + //d4 = 0; +}; + + +//===================================Korg 35 Filters====================================== +// The following filters are virtual analog models of the Korg 35 low-pass +// filter and high-pass filter found in the MS-10 and MS-20 synthesizers. +// The virtual analog models for the LPF and HPF are different, making these +// filters more interesting than simply tapping different states of the same +// circuit. +// +// These filters were implemented in Faust by Eric Tarr during the +// [2019 Embedded DSP With Faust Workshop](https://ccrma.stanford.edu/workshops/faust-embedded-19/). +// +// #### Filter history: +// +// +//======================================================================================== + +//------------------`(ve.)korg35LPF`----------------- +// Virtual analog models of the Korg 35 low-pass filter found in the MS-10 and +// MS-20 synthesizers. +// +// #### Usage +// +// ``` +// _ : korg35LPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare korg35LPF author "Eric Tarr"; +declare korg35LPF license "MIT-style STK-4.3 license"; +korg35LPF(normFreq,Q) = _ <: (s1,s2,s3,y) : !,!,!,_ +letrec{ + 's1 = _-s1:_*(alpha*2):_+s1; + 's2 = _-s1:_*alpha:_+s1:_+(s3*B3):_+(s2*B2):_*alpha0:_-s3:_*alpha:_+s3:_*K:_-s2:_*(alpha*2):_+s2; + 's3 = _-s1:_*alpha:_+s1:_+(s3*B3):_+(s2*B2):_*alpha0:_-s3:_*(alpha*2):_+s3; + 'y = _-s1:_*alpha:_+s1:_+(s3*B3):_+(s2*B2) :_*alpha0:_-s3:_*alpha:_+s3; +} +with{ + freq = 2*(10^(3*normFreq+1)); + K = 2.0*(Q - 0.707)/(10.0 - 0.707); + wd = 2*ma.PI*freq; + T = 1/ma.SR; + wa = (2/T)*tan(wd*T/2); + g = wa*T/2; + G = g/(1.0 + g); + alpha = G; + B3 = (K - K*G)/(1 + g); + B2 = -1/(1 + g); + alpha0 = 1/(1 - K*G + K*G*G); +}; + + +//------------------`(ve.)korg35HPF`----------------- +// Virtual analog models of the Korg 35 high-pass filter found in the MS-10 and +// MS-20 synthesizers. +// +// #### Usage +// +// ``` +// _ : korg35HPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare korg35HPF author "Eric Tarr"; +declare korg35HPF license "MIT-style STK-4.3 license"; +korg35HPF(normFreq,Q) = _ <: (s1,s2,s3,y) : !,!,!,_ +letrec{ + 's1 = _-s1:_*(alpha*2):_+s1; + 's2 = _<:(_-s1:_*alpha:_+s1)*-1,_:>_+(s3*B3):_+(s2*B2):_*alpha0:_*K:_-s2:_*alpha*2:_+s2; + 's3 = _<:(_-s1:_*alpha:_+s1)*-1,_:>_+(s3*B3):_+(s2*B2):_*alpha0:_*K:_<:(_-s2:_*alpha:_+s2)*-1,_:>_-s3:_*alpha*2:_+s3; + 'y = _<:(_-s1:_*alpha:_+s1)*-1,_:>_+(s3*B3):_+(s2*B2):_*alpha0; +} +with{ + freq = 2*(10^(3*normFreq+1)); + K = 2.0*(Q - 0.707)/(10.0 - 0.707); + wd = 2*ma.PI*freq; + T = 1/ma.SR; + wa = (2/T)*tan(wd*T/2); + g = wa*T/2; + G = g/(1.0 + g); + alpha = G; + B3 = 1.0/(1.0 + g); + B2 = -1.0*G/(1.0 + g); + alpha0 = 1/(1 - K*G + K*G*G); +}; + + +//==================================Oberheim Filters====================================== +// The following filter (4 types) is an implementation of the virtual analog +// model described in Section 7.2 of the Will Pirkle book, "Designing Software +// Synthesizer Plug-ins in C++". It is based on the block diagram in Figure 7.5. +// +// The Oberheim filter is a state-variable filter with soft-clipping distortion +// within the circuit. +// +// In many VA filters, distortion is accomplished using the "tanh" function. +// For this Faust implementation, that distortion function was replaced with +// the `(ef.)cubicnl` function. +//======================================================================================== + +//------------------`(ve.)oberheim`----------------- +// Generic multi-outputs Oberheim filter that produces the BSF, BPF, HPF and LPF outputs (see description above). +// +// #### Usage +// +// ``` +// _ : oberheim(normFreq,Q) : _,_,_,_ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare oberheim author "Eric Tarr"; +declare oberheim license "MIT-style STK-4.3 license"; +oberheim(normFreq,Q) = _<:(s1,s2,ybsf,ybpf,yhpf,ylpf) : !,!,_,_,_,_ +letrec{ + 's1 = _-s2:_-(s1*FBs1):_*alpha0:_*g<:_,(_+s1:ef.cubicnl(0.0,0)):>_; + 's2 = _-s2:_-(s1*FBs1):_*alpha0:_*g:_+s1:ef.cubicnl(0.0,0):_*g*2:_+s2; + // Compute the BSF, BPF, HPF, LPF outputs + 'ybsf = _-s2:_-(s1*FBs1):_*alpha0<:(_*g:_+s1:ef.cubicnl(0.0,0):_*g:_+s2),_:>_; + 'ybpf = _-s2:_-(s1*FBs1):_*alpha0:_*g:_+s1:ef.cubicnl(0.0,0); + 'yhpf = _-s2:_-(s1*FBs1):_*alpha0; + 'ylpf = _-s2:_-(s1*FBs1):_*alpha0:_*g :_+s1:ef.cubicnl(0.0,0):_*g:_+s2; +} +with{ + freq = 2*(10^(3*normFreq+1)); + wd = 2*ma.PI*freq; + T = 1/ma.SR; + wa = (2/T)*tan(wd*T/2); + g = wa*T/2; + G = g/(1.0 + g); + R = 1/(2*Q); + FBs1 = (2*R+g); + alpha0 = 1/(1 + 2*R*g + g*g); +}; + + +//------------------`(ve.)oberheimBSF`----------------- +// Band-Stop Oberheim filter (see description above). +// Specialize the generic implementation: keep the first BSF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : oberheimBSF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare oberheimBSF author "Eric Tarr"; +declare oberheimBSF license "MIT-style STK-4.3 license"; +oberheimBSF(normFreq,Q) = oberheim(normFreq,Q):_,!,!,!; + + +//------------------`(ve.)oberheimBPF`----------------- +// Band-Pass Oberheim filter (see description above). +// Specialize the generic implementation: keep the second BPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : oberheimBPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare oberheimBPF author "Eric Tarr"; +declare oberheimBPF license "MIT-style STK-4.3 license"; +oberheimBPF(normFreq,Q) = oberheim(normFreq,Q):!,_,!,!; + + +//------------------`(ve.)oberheimHPF`----------------- +// High-Pass Oberheim filter (see description above). +// Specialize the generic implementation: keep the third HPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : oberheimHPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare oberheimHPF author "Eric Tarr"; +declare oberheimHPF license "MIT-style STK-4.3 license"; +oberheimHPF(normFreq,Q) = oberheim(normFreq,Q):!,!,_,!; + + +//------------------`(ve.)oberheimLPF`----------------- +// Low-Pass Oberheim filter (see description above). +// Specialize the generic implementation: keep the fourth LPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : oberheimLPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare oberheimLPF author "Eric Tarr"; +declare oberheimLPF license "MIT-style STK-4.3 license"; +oberheimLPF(normFreq,Q) = oberheim(normFreq,Q):!,!,!,_; + + +//================================Sallen Key Filters====================================== +// The following filters were implemented based on VA models of synthesizer +// filters. +// +// The modeling approach is based on a Topology Preserving Transform (TPT) to +// resolve the delay-free feedback loop in the corresponding analog filters. +// +// The primary processing block used to build other filters (Moog, Korg, etc.) is +// based on a 1st-order Sallen-Key filter. +// +// The filters included in this script are 1st-order LPF/HPF and 2nd-order +// state-variable filters capable of LPF, HPF, and BPF. +// +// #### Resources: +// +// * Vadim Zavalishin (2018) "The Art of VA Filter Design", v2.1.0 +// +// * Will Pirkle (2014) "Resolving Delay-Free Loops in Recursive Filters Using +// the Modified Härmä Method", AES 137 +// * Description and diagrams of 1st- and 2nd-order TPT filters: +// +//======================================================================================== + + +//------------------`(ve.)sallenKeyOnePole`----------------- +// Sallen-Key generic One Pole filter that produces the LPF and HPF outputs (see description above). +// +// For the Faust implementation of this filter, recursion (`letrec`) is used +// for storing filter "states". The output (e.g. `y`) is calculated by using +// the input signal and the previous states of the filter. +// During the current recursive step, the states of the filter (e.g. `s`) for +// the next step are also calculated. +// Admittedly, this is not an efficient way to implement a filter because it +// requires independently calculating the output and each state during each +// recursive step. However, it works as a way to store and use "states" +// within the constraints of Faust. + +// The simplest example is the 1st-order LPF (shown on the cover of Zavalishin +// 2018 and Fig 4.3 of ). Here, the input +// signal is split in parallel for the calculation of the output signal, `y`, and +// the state `s`. The value of the state is only used for feedback to the next +// step of recursion. It is blocked (!) from also being routed to the output. +// A trick used for calculating the state `s` is to observe that the input to +// the delay block is the sum of two signal: what appears to be a feedforward +// path and a feedback path. In reality, the signals being summed are identical +// (signal*2) plus the value of the current state. +// +// #### Usage +// +// ``` +// _ : sallenKeyOnePole(normFreq) : _,_ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) + +declare sallenKeyOnePole author "Eric Tarr"; +declare sallenKeyOnePole license "MIT-style STK-4.3 license"; +sallenKeyOnePole(normFreq) = _<:(s,ylpf,-(ylpf)) : !,_,_ +letrec { + 's = -(s):*(2*G):+(s); + 'ylpf = -(s):*(G):+(s); +} +with{ + freq = 2*(10^(3*normFreq+1)); + wd = 2*ma.PI*freq; + T = 1/ma.SR; + wa = (2/T)*tan(wd*T/2); + g = wa*T/2; + G = g/(1.0 + g); +}; + + +//------------------`(ve.)sallenKeyOnePoleLPF`----------------- +// Sallen-Key One Pole lowpass filter (see description above). +// Specialize the generic implementation: keep the first LPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : sallenKeyOnePoleLPF(normFreq) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) + +declare sallenKeyOnePoleLPF author "Eric Tarr"; +declare sallenKeyOnePoleLPF license "MIT-style STK-4.3 license"; +sallenKeyOnePoleLPF(normFreq) = sallenKeyOnePole(normFreq) : _,!; + + +//------------------`(ve.)sallenKeyOnePoleHPF`----------------- +// Sallen-Key One Pole Highpass filter (see description above). The dry input +// signal is routed in parallel to the output. The LPF'd signal is subtracted +// from the input so that the HPF remains. +// Specialize the generic implementation: keep the second HPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : sallenKeyOnePoleHPF(normFreq) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +//--------------------------------------------------------------------- +declare sallenKeyOnePoleHPF author "Eric Tarr"; +declare sallenKeyOnePoleHPF license "MIT-style STK-4.3 license"; +sallenKeyOnePoleHPF(normFreq) = sallenKeyOnePole(normFreq) : !,_; + + +//------------------`(ve.)sallenKey2ndOrder`----------------- +// Sallen-Key generic 2nd order filter that produces the LPF, BPF and HPF outputs. +// +// This is a 2nd-order Sallen-Key state-variable filter. The idea is that by +// "tapping" into different points in the circuit, different filters +// (LPF,BPF,HPF) can be achieved. See Figure 4.6 of +// +// +// This is also a good example of the next step for generalizing the Faust +// programming approach used for all these VA filters. In this case, there are +// three things to calculate each recursive step (`y`,`s1`,`s2`). For each thing, the +// circuit is only calculated up to that point. +// +// Comparing the LPF to BPF, the output signal (`y`) is calculated similarly. +// Except, the output of the BPF stops earlier in the circuit. Similarly, the +// states (`s1` and `s2`) only differ in that `s2` includes a couple more terms +// beyond what is used for `s1`. +// +// #### Usage +// +// ``` +// _ : sallenKey2ndOrder(normFreq,Q) : _,_,_ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare sallenKey2ndOrder author "Eric Tarr"; +declare sallenKey2ndOrder license "MIT-style STK-4.3 license"; +sallenKey2ndOrder(normFreq,Q) = _<:(s1,s2,ylpf,ybpf,yhpf) : !,!,_,_,_ +letrec{ + 's1 = -(s2):-(s1*FBs1):*(alpha0):*(g*2):+(s1); + 's2 = -(s2):-(s1*FBs1):*(alpha0):*(g):+(s1):*(g*2):+(s2); + // Compute the LPF, BPF, HPF outputs + 'ylpf = -(s2):-(s1*FBs1):*(alpha0):*(g*2):+(s1):*(g):+(s2); + 'ybpf = -(s2):-(s1*FBs1):*(alpha0):*(g):+(s1); + 'yhpf = -(s2):-(s1*FBs1):*(alpha0); +} +with{ + freq = 2*(10^(3*normFreq+1)); + wd = 2*ma.PI*freq; + T = 1/ma.SR; + wa = (2/T)*tan(wd*T/2); + g = wa*T/2; + G = g/(1.0 + g); + R = 1/(2*Q); + FBs1 = (2*R+g); + alpha0 = 1/(1 + 2*R*g + g*g); +}; + +//------------------`(ve.)sallenKey2ndOrderLPF`----------------- +// Sallen-Key 2nd order lowpass filter (see description above). +// Specialize the generic implementation: keep the first LPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : sallenKey2ndOrderLPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare sallenKey2ndOrderLPF author "Eric Tarr"; +declare sallenKey2ndOrderLPF license "MIT-style STK-4.3 license"; +sallenKey2ndOrderLPF(normFreq,Q) = sallenKey2ndOrder(normFreq,Q) : _,!,!; + + +//------------------`(ve.)sallenKey2ndOrderBPF`----------------- +// Sallen-Key 2nd order bandpass filter (see description above). +// Specialize the generic implementation: keep the second BPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : sallenKey2ndOrderBPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare sallenKey2ndOrderBPF author "Eric Tarr"; +declare sallenKey2ndOrderBPF license "MIT-style STK-4.3 license"; +sallenKey2ndOrderBPF(normFreq,Q) = sallenKey2ndOrder(normFreq,Q) : !,_,!; + + +//------------------`(ve.)sallenKey2ndOrderHPF`----------------- +// Sallen-Key 2nd order highpass filter (see description above). +// Specialize the generic implementation: keep the third HPF output, +// the compiler will only generate the needed code. +// +// #### Usage +// +// ``` +// _ : sallenKey2ndOrderHPF(normFreq,Q) : _ +// ``` +// +// Where: +// +// * `normFreq`: normalized frequency (0-1) +// * `Q`: q +//--------------------------------------------------------------------- +declare sallenKey2ndOrderHPF author "Eric Tarr"; +declare sallenKey2ndOrderHPF license "MIT-style STK-4.3 license"; +sallenKey2ndOrderHPF(normFreq,Q) = sallenKey2ndOrder(normFreq,Q) : !,!,_; + + +//=========================================Effects======================================== +//======================================================================================== + +//--------------------------`(ve.)wah4`------------------------------- +// Wah effect, 4th order. +// `wah4` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : wah4(fr) : _ +// ``` +// +// Where: +// +// * `fr`: resonance frequency in Hz +// +// #### Reference +// +// +//------------------------------------------------------------ +wah4(fr) = 4*moog_vcf((3.2/4),fr:si.smooth(0.999)); + +//------------------------`(ve.)autowah`----------------------------- +// Auto-wah effect. +// `autowah` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : autowah(level) : _ +// ``` +// +// Where: +// +// * `level`: amount of effect desired (0 to 1). +//------------------------------------------------------------ +autowah(level,x) = level * crybaby(an.amp_follower(0.1,x),x) + (1.0-level)*x; + +//--------------------------`(ve.)crybaby`----------------------------- +// Digitized CryBaby wah pedal. +// `crybaby` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : crybaby(wah) : _ +// ``` +// +// Where: +// +// * `wah`: "pedal angle" from 0 to 1 +// +// #### Reference +// +// +//------------------------------------------------------------ +crybaby(wah) = *(gs) : fi.tf2(1,-1,0,a1s,a2s) +with { + Q = pow(2.0,(2.0*(1.0-wah)+1.0)); // Resonance "quality factor" + fr = 450.0*pow(2.0,2.3*wah); // Resonance tuning + g = 0.1*pow(4.0,wah); // gain (optional) + + // Biquad fit using z = exp(s T) ~ 1 + sT for low frequencies: + frn = fr/ma.SR; // Normalized pole frequency (cycles per sample) + R = 1 - ma.PI*frn/Q; // pole radius + theta = 2*ma.PI*frn; // pole angle + a1 = 0-2.0*R*cos(theta); // biquad coeff + a2 = R*R; // biquad coeff + + // dezippering of slider-driven signals: + s = 0.999; // smoothing parameter (one-pole pole location) + a1s = a1 : si.smooth(s); + a2s = a2 : si.smooth(s); + gs = g : si.smooth(s); + + //tf2 = component("filters.lib").tf2; +}; + +// end jos section +/************************************************************************ +************************************************************************ +FAUST library file, GRAME section + +Except where noted otherwise, Copyright (C) 2003-2017 by GRAME, +Centre National de Creation Musicale. +---------------------------------------------------------------------- +GRAME LICENSE + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +//----------------------------`(ve.)vocoder`------------------------- +// A very simple vocoder where the spectrum of the modulation signal +// is analyzed using a filter bank. +// `vocoder` is a standard Faust function. +// +// #### Usage +// +// ``` +// _ : vocoder(nBands,att,rel,BWRatio,source,excitation) : _ +// ``` +// +// Where: +// +// * `nBands`: Number of vocoder bands +// * `att`: Attack time in seconds +// * `rel`: Release time in seconds +// * `BWRatio`: Coefficient to adjust the bandwidth of each band (0.1 - 2) +// * `source`: Modulation signal +// * `excitation`: Excitation/Carrier signal +//------------------------------------------------------------ +declare oneVocoderBand author "Romain Michon"; +oneVocoderBand(band,bandsNumb,bwRatio,bandGain,x) = x : fi.resonbp(bandFreq,bandQ,bandGain) with { + bandFreq = 25*pow(2,(band+1)*(9/bandsNumb)); + BW = (bandFreq - 25*pow(2,(band)*(9/bandsNumb)))*bwRatio; + bandQ = bandFreq/BW; +}; + +vocoder(nBands,att,rel,BWRatio,source,excitation) = source <: par(i,nBands,oneVocoderBand(i,nBands,BWRatio,1) : + an.amp_follower_ar(att,rel) : _,excitation : oneVocoderBand(i,nBands,BWRatio)) :> _ ; + +//######################################################################################## +/************************************************************************ +FAUST library file, further contributions section + +All contributions below should indicate both the contributor and terms +of license. If no such indication is found, "git blame" will say who +last edited each line, and that person can be emailed to inquire about +license disposition, if their license choice is not already indicated +elsewhere among the libraries. It is expected that all software will be +released under LGPL, STK-4.3, MIT, BSD, or a similar FOSS license. +************************************************************************/ + +// end further further contributions section diff --git a/dist/examples/LIBRARIES/version.lib b/dist/examples/LIBRARIES/version.lib new file mode 100644 index 00000000..b5f3f45b --- /dev/null +++ b/dist/examples/LIBRARIES/version.lib @@ -0,0 +1,22 @@ +//################################ version.lib ########################################## +// Semantic versioning for the Faust libraries. Its official prefix is `vl`. +// +// #### References +// * +//######################################################################################## + +//---------------------------`(vl.)version`--------------------------- +// Return the version number of the Faust standard libraries as a MAJOR, MINOR, PATCH versioning triplet. +// +// #### Usage +// +// ``` +// version : _,_,_ +// ``` +// +//------------------------------------------------------------ +version = 2, // MAJOR version when we make incompatible API changes, + 15, // MINOR version when we add functionality in a backwards compatible manner, + 0; // PATCH version when we make backwards compatible bug fixes. + + diff --git a/dist/examples/LIBRARIES/wdmodels.lib b/dist/examples/LIBRARIES/wdmodels.lib new file mode 100644 index 00000000..5796fd98 --- /dev/null +++ b/dist/examples/LIBRARIES/wdmodels.lib @@ -0,0 +1,2276 @@ +//#################################### wdmodels.lib ############################################################################## +// A library of basic adaptors and methods to help construct Wave Digital Filter models in Faust. Its official prefix is `wd`. + +// ## Library Readme + +// This library is intended for use for creating Wave Digital (WD) based models of audio circuitry for real-time audio processing within the Faust programming language. The goal is to provide a framework to create real-time virtual-analog audio effects and synthesizers using WD models without the use of C++. Furthermore, we seek to provide access to the technique of WD modeling to those without extensive knowledge of advanced digital signal processing techniques. Finally, we hope to provide a library which can integrate with all aspects of Faust, thus creating a platform for virtual circuit bending. +// The library itself is written in Faust to maintain portability. +// +// This library is heavily based on Kurt Werner's Dissertation, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters." I have tried to maintain consistent notation between the adaptors appearing within thesis and my adaptor code. The majority of the adaptors found in chapter 1 and chapter 3 are currently supported. +// +// For inquires about use of this library in a commercial product, please contact dirk [dot] roosenburg [dot] 30 [at] gmail [dot] com. +// This documentation is taken directly from the [readme](https://github.com/droosenb/faust-wdf-library). Please refer to it for a more updated version. +// +// Many of the more in depth comments within the library include jargon. I plan to create videos detailing the theory of WD models. +// For now I recommend Kurt Werner's PhD, [Virtual analog modeling of Audio circuitry using Wave Digital Filters](https://searchworks.stanford.edu/view/11891203). +// I have tried to maintain consistent syntax and notation to the thesis. +// This library currently includes the majority of the adaptors covered in chapter 1 and some from chapter 3. +// +// +// ## Using this Library +// +// Use of this library expects some level of familiarity with WDF techniques, especially simplification and decomposition of electronic circuits into WDF connection trees. I plan to create video to cover both these techniques and use of the library. +// +// ### Quick Start +// +// To get a quick overview of the library, start with the `secondOrderFilters.dsp` code found in [examples](https://github.com/droosenb/faust-wdf-library/tree/main/examples). +// Note that the `wdmodels.lib` library is now embedded in the [online Faust IDE](https://faustide.grame.fr/). +// +// ### A Simple RC Filter Model +// +// Creating a model using this library consists fo three steps. First, declare a set of components. +// Second, model the relationship between them using a tree. Finally, build the tree using the libraries build functions. +// +// First, a set of components is declared using adaptors from the library. +// This list of components is created based on analysis of the circuit using WDF techniques, +// though generally each circuit element (resistor, capacitor, diode, etc.) can be expected to appear +// within the component set. For example, first order RC lowpass filter would require an unadapted voltage source, +// a 47k resistor, and a 10nF capacitor which outputs the voltage across itself. These can be declared with: +// +// ``` +// vs1(i) = wd.u_voltage(i, no.noise); +// r1(i) = wd.resistor(i, 47*10^3); +// c1(i) = wd.capacitor_Vout(i, 10*10^-9); +// ``` +// +// Note that the first argument, i, is left un-parametrized. Components must be declared in this form, as the build algorithm expects to receive adaptors which have exactly one parameter. +// +// Also note that we have chosen to declare a white noise function as the input to our voltage source. +// We could potentially declare this as a direct input to our model, but to do so is more complicated +// process which cannot be covered within this tutorial. For information on how to do this see +// [Declaring Model Parameters as Inputs](#declaring-model-parameters-as-inputs) or see various implementations +// in [examples](https://github.com/droosenb/faust-wdf-library/tree/main/examples). +// +// Second, the declared components and interconnection/structural adaptors (i.e. series, parallel, etc) are arranged +// into the connection tree which is produced from performing WD analysis on the modeled circuit. +// For example, to produce our first order RC lowpass circuit model, the following tree is declared: +// +// `tree_lowpass = vs1 : wd.series : (r1, c1);` +// +// For more information on how to represent trees in Faust, see [Trees in Faust](#trees-in-faust). +// +// Finally, the tree is built using the the `buildtree` function. To build and compute our first order +// RC lowpass circuit model, we use: +// +// `process = wd.buildtree(tree_lowpass);` +// +// More information about build functions, see [Model Building Functions](#model-building-functions). +// +// ### Building a Model +// +// After creating a connection tree which consists of WD adaptors, the connection tree must be passed +// to a build function in order to build the model. +// +// ##### Automatic model building +// +// `buildtree(connection_tree)` +// +// The simplest build function for use with basic models. This automatically implements `buildup`, `builddown`, +// and `buildout` to create a working model. However, it gives minimum control to the user and cannot +// currently be used on trees which have parameters declared as inputs. +// +// ##### Manual model building +// +// Wave Digital Filters are an explicit state-space model, meaning they use a previous system state +// in order to calculate the current output. This is achieved in Faust by using a single global feedback operator. +// The models feed-forward terms are generated using `builddown` and the models feedback terms are generated +// using `buildup`. Thus, the most common model implementation (the method used by `buildtree`) is: +// +// `builddown(connection_tree)~buildup(connection_tree) : buildout(connection_tree)` +// +// Since the `~` operator in Faust will leave feedback terms hanging as outputs, `buildout` is a function provided for convenience. +// It automatically truncates the hanging outputs by identifying leaf components which have an intended output +// and generating an output matrix. +// +// Building the model manually allows for greater user control and is often very helpful in testing. +// Also provided for testing are the `getres` and `parres` functions, which can be used to determine +// the upward-facing port resistance of an element. +// +// ### Declaring Model Parameters as Inputs +// +// When possible, parameters of components should be declared explicitly, meaning they are dependent on a function with no inputs. +// This might be something as simple as integer(declaring a static component), a function dependent on a UI input (declaring a component with variable value), +// or even a time-dependent function like an oscillator (declaring an audio input or circuit bending). +// +// However, it is often necessary to declare parameters as input. To achieve this there are two possible methods. +// The first and recommended option is to create a separate model function and declare parameters which will later +// be implemented as inputs. This allows inputs to be explicitly declared as component parameters. +// For example, one might use: +// +// ``` +// model(in1) = buildtree(tree) +// with { +// ... +// vin(i) = wd.u_voltage(i, in1); +// ... +// tree = vin : ...; +// }; +// ``` +// +// In order to simulate an audio input to the circuit. +// +// Note that the tree and components must be declared inside a `with {...}` statement, or the model's parameters will not be accessible. +// +// ##### The Empty Signal Operator +// +// The Empty signal operator, `_` should NEVER be used to declare a parameter as in input in a wave-digital model. +// +// Using it will result on breaking the internal routing of the model and thus breaks the model. +// Instead, use explicit declaration as shown directly above. +// +// ### Trees in Faust +// +// Since WD models use connection trees to represent relationships of elements, a comprehensive way to represent trees is critical. +// As there is no current convention for creating trees in Faust, I've developed a method using the existing series and parallel/list +// methods in Faust. +// +// The series operator ` : ` is used to separate parent and child elements. For example the tree: +// +// ``` +// A +// | +// B +// ``` +// +// is represented by `A : B` in Faust. +// +// To denote a parent element with multiple child elements, simply use a list `(a1, a2, ... an)` of children connected to a single parent. ` +// For example the tree: +// +// ``` +// A +// / \ +// B C +// +// ``` +// is represented by: +// +// `A : (B, C)` +// +// Finally, for a tree with many levels, simply break the tree into subtrees following the above rules and connect +// the subtree as if it was an individual node. For example the tree: +// +// ``` +// A +// / \ +// B C +// / / \ +// X Y Z +// ``` +// +// can be represented by: +// +// ``` +// B_sub = B : X; //B subtree +// C_sub = C : (Y, Z); //C subtree +// tree = A : (B_sub, C_sub); //full tree +// ``` +// +// or more simply, using parentheses: +// +// `A : ((B : X), (C : (Y, Z)))` + +// ### How Adaptors are Structured + +// In wave digital filters, adaptors can be described by the form `b = Sa` where `b` is a vector of output waves `b = (b0, b1, b2, ... bn)`, `a` is a vector of input waves`a = (a0, a1, a2, ... an)`, and `S` is an n x n scattering matrix. +// `S` is dependent on `R`, a list of port resistances `(R0, R1, R2, ... Rn)`. +// +// The output wave vector `b` can be divided into downward-going and upward-going waves +// (downward-going waves travel down the connection tree, upward-going waves travel up). +// For adapted adaptors, with the zeroth port being the upward-facing port, the downward-going wave vector is `(b1, b2, ... bn)` and the upward-going wave vector is `(b0)`. +// For unadapted adaptors, there are no upward-going waves, so the downward-going wave vector is simply `b = (b0, b1, b2, ... bn)`. +// +// In order for adaptors to be interpretable by the compiler, they must be structured in a specific way. +// Each adaptor is divided into three cases by their first parameter. This parameter, while accessible by the user, should only be set by the compiler/builder. +// +// All other parameters are value declarations (for components), inputs (for voltage or current ins), or parameter controls (for potentiometers/variable capacitors/variable inductors). +// +// ##### First case - downward going waves +// +// `(0, params) => downward-going(R1, ... Rn, a0, a1, ... an)` +// outputs: `(b1, b2, ... bn)` +// this function takes any number of port resistances, the downward going wave, and any number of upward going waves as inputs. +// These values/waves are used to calculate the downward going waves coming from this adaptor. +// +// ##### Second case +// +// `(1, params) => upward-going(R1, ... Rn, a1, ... an)` +// outputs : `(b0)` +// this function takes any number of port resistances and any number of upward going waves as inputs. +// These values/waves are used to calculate the upward going wave coming from this adaptor. +// +// ##### Third case +// +// `(2, params) => port-resistance(R1, ... Rn)` +// outputs: `(R0)` +// this function takes any number of port resistances as inputs. +// These values are used to calculate the upward going port resistance of the element. +// +// ##### Unadapted Adaptors +// +// Unadapted adaptor's names will always begin `u_` +// An unadapted adaptor MUST be used as the root of the WD connection tree. +// Unadapted adaptors can ONLY be used as a root of the WD connection tree. +// While unadapted adaptors contain all three cases, the second and third are purely structural. +// Only the first case should contain computational information. +// +// ### How the Build Functions Work +// +// Expect this section to be added soon! It's currently in progress. +// +// ### Acknowledgements +// +// Many thanks to Kurt Werner for helping me to understand wave digital filter models. Without his publications and consultations, the library would not exist. +// Thanks also to my advisors, Rob Owen and Eli Stine whose input was critical to the development of the library. +// Finally, thanks to Romain Michon, Stephane Letz, and the Faust Slack for contributing to testing, development, and inspiration when creating the library. +// +// #### References +// * +//################################################################################################################################ + +ba = library("basics.lib"); +ro = library("routes.lib"); +ma = library("maths.lib"); +si = library("signals.lib"); + +declare name "Faust Wave Digital Model Library"; +declare version "0.2.1"; + + +//=============================Algebraic One Port Adaptors================================= +//========================================================================================= + +//----------------------`(wd.)resistor`-------------------------- +// Adapted Resistor. +// +// A basic node implementing a resistor for use within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// +// #### Usage +// +// ``` +// r1(i) = resistor(i, R); +// buildtree( A : r1 ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `R` : Resistance/Impedance of the resistor being modeled in Ohms. +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.1 +//---------------------------------------------------------- +declare resistor author "Dirk Roosenburg"; +declare resistor copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare resistor license "MIT-style STK-4.3 license"; +resistor = +case{ + (0, R) => !, 0; + (1, R) => _; + (2, R) => R0 + with{ + R0 = R; + }; +}; + + +//----------------------`(wd.)resistor_Vout`-------------------------- +// Adapted Resistor + voltage Out. +// +// A basic adaptor implementing a resistor for use within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// The resistor will also pass the voltage across itself as an output of the model. +// +// #### Usage +// +// ``` +// rout(i) = resistor_Vout(i, R); +// buildtree( A : rout ) : _ +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `R` : Resistance/Impedance of the resistor being modeled in Ohms. +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.1 +//---------------------------------------------------------- +declare resistor_Vout author "Dirk Roosenburg"; +declare resistor_Vout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare resistor_Vout license "MIT-style STK-4.3 license"; +resistor_Vout = +case{ + (0, R) => 0, _*.5; + (1, R) => _, !; + (2, R) => R0 + with{ + R0 = R; + }; +}with{ + rho = 1; +}; + + +//----------------------`(wd.)resistor_Iout`-------------------------- +// Resistor + current Out. +// +// A basic adaptor implementing a resistor for use within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// The resistor will also pass the current through itself as an output of the model. +// +// #### Usage +// +// ``` +// rout(i) = resistor_Iout(i, R); +// buildtree( A : rout ) : _ +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `R` : Resistance/Impedance of the resistor being modeled in Ohms. +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.1 +//---------------------------------------------------------- +declare resistor_Iout author "Dirk Roosenburg"; +declare resistor_Iout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare resistor_Iout license "MIT-style STK-4.3 license"; +resistor_Iout = +case{ + (0, R) => 0, _*.5/R; + (1, R) => _, !; + (2, R) => R0 + with{ + R0 = R; + }; +}; + + +//----------------------`(wd.)u_voltage`-------------------------- +// Unadapted Ideal Voltage Source. +// +// An adaptor implementing an ideal voltage source within Wave Digital Filter connection trees. +// +// It should be used as the root/top element of the connection tree. +// Can be used for either DC (constant) or AC (signal) voltage sources. +// +// #### Usage +// +// ``` +// v1(i) = u_Voltage(i, ein); +// buildtree( v1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `ein` : Voltage/Potential across ideal voltage source in Volts +// +// Note: only usable as the root of a tree. +// The adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.2 +//---------------------------------------------------------- +declare u_voltage author "Dirk Roosenburg"; +declare u_voltage copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_voltage license "MIT-style STK-4.3 license"; +u_voltage = +case{ + (0 , ein) => b0 + with{ + b0(R0, a0) = 2*R0^(rho-1)*ein -a0; + }; + (1, ein) => !, !; + (2, ein) => 0; +}with{ + rho = 1; +}; + + +//----------------------`(wd.)u_current`-------------------------- +// Unadapted Ideal Current Source. +// +// An unadapted adaptor implementing an ideal current source within Wave Digital Filter connection trees. +// +// It should be used as the root/top element of the connection tree. +// Can be used for either DC (constant) or AC (signal) current sources. +// +// #### Usage +// +// ``` +// i1(i) = u_current(i, jin); +// buildtree( i1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `jin` : Current through the ideal current source in Amps +// +// Note: only usable as the root of a tree. +// The adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.3 +//---------------------------------------------------------- +declare u_current author "Dirk Roosenburg"; +declare u_current copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_current license "MIT-style STK-4.3 license"; +u_current = +case{ + (0 , jin) => b0 + with{ + b0(R0, a0) = 2*R0^(rho)*jin + a0; + }; + (1, jin) => !, !; + (2, jin) => 0; +}with{ + rho = 1; +}; + +//----------------------`(wd.)resVoltage`-------------------------- +// Adapted Resistive Voltage Source. +// +// An adaptor implementing a resistive voltage source within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// It is comprised of an ideal voltage source in series with a resistor. +// Can be used for either DC (constant) or AC (signal) voltage sources. +// +// #### Usage +// +// ``` +// v1(i) = resVoltage(i, R, ein); +// buildtree( A : v1 ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `R` : Resistance/Impedance of the series resistor in Ohms +// * `ein` : Voltage/Potential of the ideal voltage source in Volts +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.4 +//---------------------------------------------------------- +declare resVoltage author "Dirk Roosenburg"; +declare resVoltage copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare resVoltage license "MIT-style STK-4.3 license"; +resVoltage = +case{ + (0, R, ein) => !, R^(1-rho)*ein; + (1, R, ein) => _; + (2, R, ein) => R0 + with { + R0 = R; + }; +}with{ + rho = 1; +}; + +//----------------------`(wd.)resVoltage_Vout`-------------------------- +// Adapted Resistive Voltage Source + voltage output. +// +// An adaptor implementing an adapted resistive voltage source within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// It is comprised of an ideal voltage source in series with a resistor. +// Can be used for either DC (constant) or AC (signal) voltage sources. +// The resistive voltage source will also pass the voltage across it as an output of the model. +// +// #### Usage +// +// ``` +// vout(i) = resVoltage_Vout(i, R, ein); +// buildtree( A : vout ) : _ +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `R` : Resistance/Impedance of the series resistor in Ohms +// * `ein` : Voltage/Potential across ideal voltage source in Volts +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.4 +//---------------------------------------------------------- +declare resVoltage_Vout author "Dirk Roosenburg"; +declare resVoltage_Vout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare resVoltage_Vout license "MIT-style STK-4.3 license"; +resVoltage_Vout = +case{ + (0, R, ein) => R^(1-rho)*ein, _*.5 + R^(1-rho)*ein*.5; + (1, R, ein) => _, !; + (2, R, ein) => R0 + with { + R0 = R; + }; +}with{ + rho = 1; +}; + +//----------------------`(wd.)u_resVoltage`-------------------------- +// Unadapted Resistive Voltage Source. +// +// An unadapted adaptor implementing a resistive voltage source within Wave Digital Filter connection trees. +// +// It should be used as the root/top element of the connection tree. +// It is comprised of an ideal voltage source in series with a resistor. +// Can be used for either DC (constant) or AC (signal) voltage sources. +// +// #### Usage +// +// ``` +// v1(i) = u_resVoltage(i, R, ein); +// buildtree( v1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `R` : Resistance/Impedance of the series resistor in Ohms +// * `ein` : Voltage/Potential across ideal voltage source in Volts +// +// Note: only usable as the root of a tree. +// The adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.4 +//---------------------------------------------------------- +declare u_resVoltage author "Dirk Roosenburg"; +declare u_resVoltage copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_resVoltage license "MIT-style STK-4.3 license"; +u_resVoltage = +case { + (0, R, ein) => b0 + with{ + b0(R0, a0) = a0*(R - R0)/(R+R0) + ein*(2*R0^rho)/(R + R0); + }; + (1, R, ein) => !, !; + (2, R, ein) => 0; + +}with{ + rho = 1; +}; + + +//----------------------`(wd.)resCurrent`-------------------------- +// Adapted Resistive Current Source. +// +// An adaptor implementing a resistive current source within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// It is comprised of an ideal current source in parallel with a resistor. +// Can be used for either DC (constant) or AC (signal) current sources. +// +// #### Usage +// +// ``` +// i1(i) = resCurrent(i, R, jin); +// buildtree( A : i1 ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `R` : Resistance/Impedance of the parallel resistor in Ohms +// * `jin` : Current through the ideal current source in Amps +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.5 +//---------------------------------------------------------- +declare resCurrent author "Dirk Roosenburg"; +declare resCurrent copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare resCurrent license "MIT-style STK-4.3 license"; +resCurrent = +case { + (0, R, jin) => !, R^(rho)*jin; + (1, R, jin) => _; + (2, R, jin) => R0 + with { + R0 = R; + }; +}with{ + rho = 1; //assume voltage waves +}; + +//----------------------`(wd.)u_resCurrent`-------------------------- +// Unadapted Resistive Current Source. +// +// An unadapted adaptor implementing a resistive current source within Wave Digital Filter connection trees. +// +// It should be used as the root/top element of the connection tree. +// It is comprised of an ideal current source in parallel with a resistor. +// Can be used for either DC (constant) or AC (signal) current sources. +// +// #### Usage +// +// ``` +// i1(i) = u_resCurrent(i, R, jin); +// buildtree( i1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `R` : Resistance/Impedance of the series resistor in Ohms +// * `jin` : Current through the ideal current source in Amps +// +// Note: only usable as the root of a tree. +// The adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.5 +//---------------------------------------------------------- +declare u_resCurrent author "Dirk Roosenburg"; +declare u_resCurrent copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_resCurrent license "MIT-style STK-4.3 license"; +u_resCurrent = +case { + (0, R, jin) => b0 + with{ + b0(R0, a0) = a0*(R - R0)/(R + R0) + jin*(2*R*R0^rho)/(R + R0); + }; + (1, R, jin) => !, !; + (2, R, jin) => 0; + +}with{ + rho = 1; //assume voltage waves +}; + +//TODO +//add short circuit (1.2.6), add open circuit (1.2.7) + +//----------------------`(wd.)u_switch`-------------------------- +// Unadapted Ideal Switch. +// +// An unadapted adaptor implementing an ideal switch for Wave Digital Filter connection trees. +// +// It should be used as the root/top element of the connection tree +// +// #### Usage +// +// ``` +// s1(i) = u_resCurrent(i, lambda); +// buildtree( s1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `lambda` : switch state control. -1 for closed switch, 1 for open switch. +// +// Note: only usable as the root of a tree. +// The adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.2.8 +//---------------------------------------------------------- +declare u_switch author "Dirk Roosenburg"; +declare u_switch copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_switch license "MIT-style STK-4.3 license"; +u_switch = +case { + (0, lambda) => b0 + with{ + b0(R0, a0) = a0*lambda; + }; + (1, lambda) => !, !; + (2, lambda) => 0; +}; + +//=============================Reactive One Port Adaptors================================= +//======================================================================================== +//TODO - add mobius transform and alpha transform digitizations + +//----------------------`(wd.)capacitor`-------------------------- +// Adapted Capacitor. +// +// A basic adaptor implementing a capacitor for use within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// This capacitor model was digitized using the bi-linear transform. +// +// #### Usage +// +// ``` +// c1(i) = capacitor(i, R); +// buildtree( A : c1 ) : _ +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared. +// * `R` : Capacitance/Impedance of the capacitor being modeled in Farads. +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.3.1 +//---------------------------------------------------------- +declare capacitor author "Dirk Roosenburg"; +declare capacitor copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare capacitor license "MIT-style STK-4.3 license"; +capacitor = +case{ + (0, R) => _*1; + (1, R) => _; + (2, R) => R0 + with { + R0 = t/(2*R); + }; +}with{ + t = 1/ma.SR; //sampling interval +}; + +//----------------------`(wd.)capacitor_Vout`-------------------------- +// Adapted Capacitor + voltage out. +// +// A basic adaptor implementing a capacitor for use within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// The capacitor will also pass the voltage across itself as an output of the model. +// This capacitor model was digitized using the bi-linear transform. +// +// #### Usage +// +// ``` +// cout(i) = capacitor_Vout(i, R); +// buildtree( A : cout ) : _ +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `R` : Capacitance/Impedence of the capacitor being modeled in Farads +// +// Note: the adaptor must be declared as a seperate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.3.1 +//---------------------------------------------------------- +declare capacitor_Vout author "Dirk Roosenburg"; +declare capacitor_Vout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare capacitor_Vout license "MIT-style STK-4.3 license"; +capacitor_Vout = +case{ + (0, R) => b0 + with{ + b0(a1) = a1*1, a1*.5 + (a1')*.5; + }; + (1, R) => _, !; + (2, R) => R0 + with { + R0 = t/(2*R); + }; +}with{ + t = 1/ma.SR; //sampling interval +}; + +//----------------------`(wd.)inductor`-------------------------- +// Unadapted Inductor. +// +// A basic adaptor implementing an inductor for use within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// This inductor model was digitized using the bi-linear transform. +// +// #### Usage +// +// ``` +// l1(i) = inductor(i, R); +// buildtree( A : l1 ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `R` : Inductance/Impedance of the inductor being modeled in Henries +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.3.2 +//---------------------------------------------------------- +declare inductor author "Dirk Roosenburg"; +declare inductor copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare inductor license "MIT-style STK-4.3 license"; +inductor = +case{ + (0, R) => _*(-1); + (1, R) => _; + (2, R) => R0 + with { + R0 = (2*R)/t; + }; +}with{ + t = 1/ma.SR; //sampling interval +}; + +//----------------------`(wd.)inductor_Vout`-------------------------- +// Unadapted Inductor + Voltage out. +// +// A basic adaptor implementing an inductor for use within Wave Digital Filter connection trees. +// +// It should be used as a leaf/terminating element of the connection tree. +// The inductor will also pass the voltage across itself as an output of the model. +// This inductor model was digitized using the bi-linear transform. +// +// #### Usage +// +// ``` +// lout(i) = inductor_Vout(i, R); +// buildtree( A : lout ) : _ +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `R` : Inductance/Impedance of the inductor being modeled in Henries +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.3.2 +//---------------------------------------------------------- +declare inductor_Vout author "Dirk Roosenburg"; +declare inductor_Vout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare inductor_Vout license "MIT-style STK-4.3 license"; +inductor_Vout = +case{ + (0, R) => b0 + with{ + b0(a1) = a1*(-1), a1*.5 - (a1')*.5; + }; + (1, R) => _, !; + (2, R) => R0 + with { + R0 = (2*R)/t; + }; +}with{ + t = 1/ma.SR; //sampling interval +}; + +//===============================Nonlinear One Port Adaptors============================== +//======================================================================================== + +//----------------------`(wd.)u_idealDiode`-------------------------- +// Unadapted Ideal Diode. +// +// An unadapted adaptor implementing an ideal diode for Wave Digital Filter connection trees. +// +// It should be used as the root/top element of the connection tree. +// +// #### Usage +// +// ``` +// buildtree( u_idealDiode : B ); +// ``` +// +// Note: only usable as the root of a tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 3.2.3 +//---------------------------------------------------------- +declare u_idealDiode author "Dirk Roosenburg"; +declare u_idealDiode copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_idealDiode license "MIT-style STK-4.3 license"; +u_idealDiode = +case{ + (0) => b1 + with{ + b1(R1, a0) = a0 : abs : *(-1); + }; + (1) => !, !; + (2) => 0; +}; + +//----------------------`(wd.)u_chua`-------------------------- +// Unadapted Chua Diode. +// +// An adaptor implementing the chua diode / non-linear resistor within Wave Digital Filter connection trees. +// +// It should be used as the root/top element of the connection tree. +// +// #### Usage +// +// ``` +// chua1(i) = u_chua(i, G1, G2, V0); +// buildtree( chua1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `G1` : resistance parameter 1 of the chua diode +// * `G2` : resistance parameter 2 of the chua diode +// * `V0` : voltage parameter of the chua diode +// +// Note: only usable as the root of a tree. +// The adaptor must be declared as a separate function before integration into the connection tree. +// Correct implementation is shown above. +// +// #### Reference +// +// Meerkotter and Scholz, "Digital Simulation of Nonlinear Circuits by Wave Digital Filter Principles" +//---------------------------------------------------------- +declare u_chua author "Dirk Roosenburg"; +declare u_chua copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_chua license "MIT-style STK-4.3 license"; +u_chua = +case{ + (0, G1, G2, V0) => b1 + with{ + b1(R1, a0) = g_1*a0 + 1/2*(g_2 - g_1)*(((a0 + a_0) : abs) - ((a0 - a_0): abs)) + with{ + g_1 = (1-G1*R1)/(1+G1*R1); + g_2 = (1-G2*R1)/(1+G2*R1); + a_0 = V0*(1+G2*R1); + }; + }; + (1, G1, G2, V0) => !, !; + (2, G1, G2, V0) => 0; +}; + + +//----------------------`(wd.)lambert`-------------------------- +// An implementation of the lambert function. +// It uses Halley's method of iteration to approximate the output. +// Included in the WD library for use in non-linear diode models. +// Adapted from K M Brigg's c++ lambert function approximation. +// +// #### Usage +// +// ``` +// lambert(n, itr) : _ +// ``` +// +// Where: +// * `n`: value at which the lambert function will be evaluated +// * `itr`: number of iterations before output +// +//---------------------------------------------------------- +declare lambert author "Dirk Roosenburg"; +declare lambert copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare lambert license "MIT-style STK-4.3 license"; +lambert(z, itr) = ba.if((z<(-em1+.0001)), less_approx, greater_approx) +with{ + less_approx = -1.0 + +2.331643981597124203363536062168*r + -1.812187885639363490240191647568*q + +1.936631114492359755363277457668*r*q + -2.353551201881614516821543561516*q2 + with{ + q = z+em1; + r = sqrt(q); + q2 = q*q; + }; + eps=4.0e-16; + em1=0.3678794411714423215955237701614608; + greater_approx = z : init : seq(i, itr, approx) + with{ + init(w) = ba.if((z<1), init1, init2) + with{ + init1 = -1.0+p*(1.0+p*(-0.333333333333333333333+p*0.152777777777777777777777)) + with{ + p = sqrt(2.0*(2.7182818284590452353602874713526625*z+1.0)); + }; + init2 = log(abs(z)); + }; + approx(w) = w-t + with{ + e = exp(w); + t = (w*e-z)/(e*p-.5*(p+1.0)*(w*e-z)/p); + p = w+1; + }; + }; +}; + + +//----------------------`(wd.)u_diodePair`-------------------------- +// Unadapted pair of diodes facing in opposite directions. +// +// An unadapted adaptor implementing two antiparallel diodes for Wave Digital Filter connection trees. +// The behavior is approximated using Schottkey's ideal diode law. +// +// #### Usage +// +// ``` +// d1(i) = u_diodePair(i, Is, Vt); +// buildtree( d1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `Is` : saturation current of the diodes +// * `Vt` : thermal resistances of the diodes +// +// Note: only usable as the root of a tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner et al. "An Improved and Generalized Diode Clipper Model for Wave Digital Filters" +//---------------------------------------------------------- +declare u_diodePair author "Dirk Roosenburg"; +declare u_diodePair copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_diodePair license "MIT-style STK-4.3 license"; +u_diodePair = +case{ + (0, Is, Vt) => b1 + with{ + b1(R1, a1) = a1 + 2*R1*Is - 2*Vt*lambert((R1*Is/Vt*(((a1+R1*Is)/Vt), 3) : exp)); + }; + (1, Is, Vt) => !, !; + (2, Is, Vt) => 0; +}; + + +//----------------------`(wd.)u_diodeSingle`-------------------------- +// Unadapted single diode. +// +// An unadapted adaptor implementing a single diode for Wave Digital Filter connection trees. +// The behavior is approximated using Schottkey's ideal diode law. +// +// #### Usage +// +// ``` +// d1(i) = u_diodeSingle(i, Is, Vt); +// buildtree( d1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `Is` : saturation current of the diodes +// * `Vt` : thermal resistances of the diodes +// +// Note: only usable as the root of a tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner et al. "An Improved and Generalized Diode Clipper Model for Wave Digital Filters" +//---------------------------------------------------------- +declare u_diodeSingle author "Dirk Roosenburg"; +declare u_diodeSingle copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_diodeSingle license "MIT-style STK-4.3 license"; +u_diodeSingle = +case{ + (0, Is, Vt) => b1 + with{ + b1(R1, a1) = ma.signum(a1)*((a1 : abs) + 2*R1*Is - 2*Vt*(lambert((R1*Is/Vt*((((a1 : abs)+R1*Is)/Vt) : exp)),3) + lambert((-R1*Is/Vt*(((-1*(a1 : abs)+R1*Is)/Vt) : exp)),3))); + }; + (1, Is, Vt) => !, !; + (2, Is, Vt) => 0; +}; + +//----------------------`(wd.)u_diodeAntiparallel`-------------------------- +// Unadapted set of antiparallel diodes with M diodes facing forwards and N diodes facing backwards. +// +// An unadapted adaptor implementing antiparallel diodes for Wave Digital Filter connection trees. +// The behavior is approximated using Schottkey's ideal diode law. +// +// #### Usage +// +// ``` +// d1(i) = u_diodeAntiparallel(i, Is, Vt); +// buildtree( d1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `Is` : saturation current of the diodes +// * `Vt` : thermal resistances of the diodes +// +// Note: only usable as the root of a tree. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner et al. "An Improved and Generalized Diode Clipper Model for Wave Digital Filters" +//---------------------------------------------------------- +declare u_diodeAntiparallel author "Dirk Roosenburg"; +declare u_diodeAntiparallel copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_diodeAntiparallel license "MIT-style STK-4.3 license"; +u_diodeAntiparallel = +case{ + (0, Is, Vt, M, N) => b1 + with{ + b1(R1, a1) = a1 - 2*lam*Vt*(mu0* lambert(((R1*Is)/(mu0*Vt) * exp((lam*a1)/(mu0*Vt))), 3) + + mu1* lambert(((-R1*Is)/(mu1*Vt) * exp((-lam*a1)/(mu1*Vt))), 3)) + with{ + lam = ma.signum(a1); + mu0 = ba.if((a1 < 0), N, M); + mu1 = ba.if((a1 > 0), M, N); + }; + }; + (1, Is, Vt, M, N) => !, !; + (2, Is, Vt, M, N) => 0; +}; + + +//=============================Two Port Adaptors========================================== +//======================================================================================== + + +//----------------------`(wd.)u_parallel2Port`-------------------------- +// Unadapted 2-port parallel connection. +// +// An unadapted adaptor implementing a 2-port parallel connection between adaptors for Wave Digital Filter connection trees. +// Elements connected to this adaptor will behave as if connected in parallel in circuit. +// +// #### Usage +// +// ``` +// buildtree( u_parallel2Port : (A, B) ); +// ``` +// +// Note: only usable as the root of a tree. +// This adaptor has no user-accessible parameters. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.1 +//---------------------------------------------------------- +declare u_parallel2Port author "Dirk Roosenburg"; +declare u_parallel2Port copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_parallel2Port license "MIT-style STK-4.3 license"; +u_parallel2Port = +case{ + (0) => u_par + with{ + u_par = si.bus(4) <: b0, b1; + b0(R0, R1, a0, a1) = (-a0*(R0-R1) + a1*(2*R0^rho*R1^(1-rho)))/(R0+R1); + b1(R0, R1, a0, a1) = (a1*(R0-R1) + a0*(2*R0^(1-rho)*R1^rho))/(R0+R1); + }; + (1) => !, !, !, !; + (2) => 0; +}with{ + rho = 1; //assume voltage waves +}; + + +//----------------------`(wd.)parallel2Port`-------------------------- +// Adapted 2-port parallel connection. +// +// An adaptor implementing a 2-port parallel connection between adaptors for Wave Digital Filter connection trees. +// Elements connected to this adaptor will behave as if connected in parallel in circuit. +// +// #### Usage +// +// ``` +// buildtree( A : parallel2Port : B ); +// ``` +// +// Note: this adaptor has no user-accessible parameters. +// It should be used within the connection tree with one previous and one forward adaptor. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.1 +//---------------------------------------------------------- +declare parallel2Port author "Dirk Roosenburg"; +declare parallel2Port copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare parallel2Port license "MIT-style STK-4.3 license"; +parallel2Port = +case{ + (0) => par_down + with{ + par_down = b1; + b1(R1, a0, a1) = a0; + }; + (1) => par_up + with{ + par_up = b0; + b0(R1, a1) = a1; + }; + (2) => R0 + with{ + R0(R1) = R1; + }; +}; + +//----------------------`(wd.)u_series2Port`-------------------------- +// Unadapted 2-port series connection. +// +// An unadapted adaptor implementing a 2-port series connection between adaptors for Wave Digital Filter connection trees. +// Elements connected to this adaptor will behave as if connected in series in circuit. +// +// #### Usage +// +// ``` +// buildtree( u_series2Port : (A, B) ); +// ``` +// +// Note: only usable as the root of a tree. +// This adaptor has no user-accessible parameters. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.1 +//---------------------------------------------------------- +declare u_series2Port author "Dirk Roosenburg"; +declare u_series2Port copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_series2Port license "MIT-style STK-4.3 license"; +u_series2Port = +case{ + (0) => u_ser + with{ + u_ser = si.bus(4) <: b0, b1; + b0(R0, R1, a0, a1) = (-a0*(R0-R1) - a1*(2*R0^rho*R1^(1-rho)))/(R0+R1); + b1(R0, R1, a0, a1) = (a1*(R0-R1) - a0*(2*R0^(1-rho)*R1^rho))/(R0+R1); + }; + (1) => !, !, !, !; + (2) => 0; +}with{ + rho = 1; //assume voltage waves +}; + + +//----------------------`(wd.)series2Port`-------------------------- +// Adapted 2-port series connection. +// +// An adaptor implementing a 2-port series connection between adaptors for Wave Digital Filter connection trees. +// Elements connected to this adaptor will behave as if connected in series in circuit. +// +// #### Usage +// +// ``` +// buildtree( A : series2Port : B ); +// ``` +// +// Note: this adaptor has no user-accessible parameters. +// It should be used within the connection tree with one previous and one forward adaptor. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.1 +//---------------------------------------------------------- +declare series2Port author "Dirk Roosenburg"; +declare series2Port copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare series2Port license "MIT-style STK-4.3 license"; +series2Port = +case{ + (0) => ser_down + with{ + ser_down = b1; + b1(R1, a0, a1) = -a0; + }; + (1) => ser_up + with{ + ser_up = b0; + b0(R1, a1) = -a1; + }; + (2) => R0 + with{ + R0(R1) = R1; + }; +}; + + +//----------------------`(wd.)parallelCurrent`-------------------------- +// Adapted 2-port parallel connection + ideal current source. +// +// An adaptor implementing a 2-port series connection and internal idealized current source between adaptors for Wave Digital Filter connection trees. +// This adaptor connects the two connected elements and an additional ideal current source in parallel. +// +// #### Usage +// +// ``` +// i1(i) = parallelCurrent(i, jin); +// buildtree(A : i1 : B); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `jin` : Current through the ideal current source in Amps +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// It should be used within a connection tree with one previous and one forward adaptor. +// Correct implementation is shown above. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.2 +//---------------------------------------------------------- +declare parallelCurrent author "Dirk Roosenburg"; +declare parallelCurrent copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare parallelCurrent license "MIT-style STK-4.3 license"; +parallelCurrent = +case{ + (0, jin) => par_current_down + with{ + par_current_down = b1; + b1(R1, a0, a1) = a0 + R1^rho*jin; + }; + (1, jin) => par_current_up + with{ + par_current_up = b0; + b0(R1, a1) = a1 + R1^rho*jin; + }; + (2, jin) => R0 + with{ + R0(R1) = R1; + }; +}with{ + rho = 1; //assume voltage waves +}; + + +//----------------------`(wd.)seriesVoltage`-------------------------- +// Adapted 2-port series connection + ideal voltage source. +// +// An adaptor implementing a 2-port series connection and internal ideal voltage source between adaptors for Wave Digital Filter connection trees. +// This adaptor connects the two connected adaptors and an additional ideal voltage source in series. +// +// #### Usage +// +// ``` +// v1(i) = seriesVoltage(i, vin) +// buildtree( A : v1 : B ); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `vin` : voltage across the ideal current source in Volts +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// It should be used within the connection tree with one previous and one forward adaptor. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.2 +//---------------------------------------------------------- +declare seriesVoltage author "Dirk Roosenburg"; +declare seriesVoltage copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare seriesVoltage license "MIT-style STK-4.3 license"; +seriesVoltage = +case{ + (0, vin) => ser_down + with{ + ser_down = b1; + b1(R1, a0, a1) = -a0 - R1^(rho-1)*vin; + }; + (1, vin) => ser_up + with{ + ser_up = b0; + b0(R1, a1) = -a1 - R1^(rho-1)*vin; + }; + (2, vin) => R0 + with{ + R0(R1) = R1; + }; +}with{ + rho = 1; //assume voltage waves +}; + +//----------------------`(wd.)u_transformer`-------------------------- +// Unadapted ideal transformer. +// +// An adaptor implementing an ideal transformer for Wave Digital Filter connection trees. +// The first downward-facing port corresponds to the primary winding connections, and the second downward-facing port to the secondary winding connections. +// +// #### Usage +// +// ``` +// t1(i) = u_transformer(i, tr); +// buildtree(t1 : (A , B)); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `tr` : the turn ratio between the windings on the primary and secondary coils +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// It may only be used as the root of the connection tree with two forward nodes. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.3 +//---------------------------------------------------------- +declare u_transformer author "Dirk Roosenburg"; +declare u_transformer copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_transformer license "MIT-style STK-4.3 license"; +u_transformer(i, n) = u_genericNode(i, transformer_scatter) +with{ + matrix(M,N,f) = si.bus(N) <: ro.interleave(N,M) : par(n,N, par(m,M,*(f(m+1,n+1)))) :> si.bus(M); + + transformer_scatter(R0, R1) = matrix(2, 2, s) + with{ + s(1,1) =-1*(R0-n^2*R1)/(R0+n^2*R1); + s(1,2) = (2*n*R0^rho*R1^(1-rho))/(R0+n^2*R1); + s(2,1) = (2*n*R0^(1-rho)*R1^rho)/(R0+n^2*R1); + s(2,2) = (R0-n^2*R1)/(R0+n^2*R1); + s(i,j) = 10; + + rho = 1; //assume voltage waves + }; +}; + +//----------------------`(wd.)transformer`-------------------------- +// Adapted ideal transformer. +// +// An adaptor implementing an ideal transformer for Wave Digital Filter connection trees. +// The upward-facing port corresponds to the primary winding connections, and the downward-facing port to the secondary winding connections +// +// #### Usage +// +// ``` +// t1(i) = transformer(i, tr); +// buildtree(A : t1 : B); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `tr` : the turn ratio between the windings on the primary and secondary coils +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// It should be used within the connection tree with one backward and one forward nodes. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.3 +//---------------------------------------------------------- +declare transformer author "Dirk Roosenburg"; +declare transformer copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare transformer license "MIT-style STK-4.3 license"; +transformer(i, n) = genericNode(i, transformer_scatter, transformer_upPortRes) +with{ + matrix(M,N,f) = si.bus(N) <: ro.interleave(N,M) : par(n,N, par(m,M,*(f(m+1,n+1)))) :> si.bus(M); + + transformer_upPortRes(R1) = n^2*R1; //equation for upward-facing port resistance + + transformer_scatter(R1) = matrix(2, 2, s) + with{ + s(1,1) =-1*(R0-n^2*R1)/(R0+n^2*R1); + s(1,2) = (2*n*R0^rho*R1^(1-rho))/(R0+n^2*R1); + s(2,1) = (2*n*R0^(1-rho)*R1^rho)/(R0+n^2*R1); + s(2,2) = (R0-n^2*R1)/(R0+n^2*R1); + s(i,j) = 10; + + rho = 1; //assume voltage waves + + R0 = n^2*R1; //adapting condition + }; +}; + + +//----------------------`(wd.)u_transformerActive`-------------------------- +// Unadapted ideal active transformer. +// +// An adaptor implementing an ideal transformer for Wave Digital Filter connection trees. +// The first downward-facing port corresponds to the primary winding connections, and the second downward-facing port to the secondary winding connections. +// +// #### Usage +// +// ``` +// t1(i) = u_transformerActive(i, gamma1, gamma2); +// buildtree(t1 : (A , B)); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `gamma1` : the turn ratio describing the voltage relationship between the primary and secondary coils +// * `gamma2` : the turn ratio describing the current relationship between the primary and secondary coils +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// It may only be used as the root of the connection tree with two forward nodes. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.3 +//---------------------------------------------------------- +declare u_transformerActive author "Dirk Roosenburg"; +declare u_transformerActive copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_transformerActive license "MIT-style STK-4.3 license"; +u_transformerActive(i, gamma1, gamma2) = u_genericNode(i, transformerActive_scatter) +with{ + matrix(M,N,f) = si.bus(N) <: ro.interleave(N,M) : par(n,N, par(m,M,*(f(m+1,n+1)))) :> si.bus(M); + + transformerActive_scatter(R0, R1) = matrix(2, 2, s) + with{ + s(1,1) =-1*(R0-gamma1*gamma2*R1)/(R0+gamma1*gamma2*R1); + s(1,2) = (2*gamma1*R0^rho*R1^(1-rho))/(R0+gamma1*gamma2*R1); + s(2,1) = (2*gamma2*R0^(1-rho)*R1^rho)/(R0+gamma1*gamma2*R1); + s(2,2) = (R0-gamma1*gamma2*R1)/(R0+gamma1*gamma2*R1); + s(i,j) = 10; + + rho = 1; //assume voltage waves + }; +}; + + +//----------------------`(wd.)transformerActive`-------------------------- +// Adapted ideal active transformer. +// +// An adaptor implementing an ideal active transformer for Wave Digital Filter connection trees. +// The upward-facing port corresponds to the primary winding connections, and the downward-facing port to the secondary winding connections +// +// #### Usage +// +// ``` +// t1(i) = transformerActive(i, gamma1, gamma2); +// buildtree(A : t1 : B); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `gamma1` : the turn ratio describing the voltage relationship between the primary and secondary coils +// * `gamma2` : the turn ratio describing the current relationship between the primary and secondary coils +// +// Note: the adaptor must be declared as a separate function before integration into the connection tree. +// It should be used within the connection tree with two forward nodes. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.4.3 +//---------------------------------------------------------- +declare transformerActive author "Dirk Roosenburg"; +declare transformerActive copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare transformerActive license "MIT-style STK-4.3 license"; +transformerActive(i, gamma1, gamma2) = genericNode(i, transformerActive_scatter, transformerActive_upPortRes) +with{ + matrix(M,N,f) = si.bus(N) <: ro.interleave(N,M) : par(n,N, par(m,M,*(f(m+1,n+1)))) :> si.bus(M); + + transformerActive_upPortRes(R1) = gamma1*gamma2*R1; //equation for upward-facing port resistance + + transformerActive_scatter(R1) = matrix(2, 2, s) + with{ + s(1,1) =-1*(R0-gamma1*gamma2*R1)/(R0+gamma1*gamma2*R1); + s(1,2) = (2*gamma1*R0^rho*R1^(1-rho))/(R0+gamma1*gamma2*R1); + s(2,1) = (2*gamma2*R0^(1-rho)*R1^rho)/(R0+gamma1*gamma2*R1); + s(2,2) = (R0-gamma1*gamma2*R1)/(R0+gamma1*gamma2*R1); + s(i,j) = 10; + + rho = 1; //assume voltage waves + + R0 = gamma1*gamma2*R1; //adapting condition + }; +}; + + +//===============================Three Port Adaptors====================================== +//======================================================================================== + + +//----------------------`(wd.)parallel`-------------------------- +// Adapted 3-port parallel connection. +// +// An adaptor implementing a 3-port parallel connection between adaptors for Wave Digital Filter connection trees. +// This adaptor is used to connect adaptors simulating components connected in parallel in the circuit. +// +// #### Usage +// +// ``` +// buildtree( A : parallel : (B, C) ); +// ``` +// +// Note: this adaptor has no user-accessible parameters. +// It should be used within the connection tree with one previous and two forward adaptors. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.5.1 +//---------------------------------------------------------- +declare parallel author "Dirk Roosenburg"; +declare parallel copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare parallel license "MIT-style STK-4.3 license"; +parallel= +case{ + (0) => par_down + with{ + par_down = si.bus(5) <: b1, b2; + b1(R1, R2, a0, a1, a2) = a0 + a1 * -R1/(R1 + R2) + a2 * R1/(R1 + R2); + b2(R1, R2, a0, a1, a2) = a0 + a1 * R2/(R1 + R2) + a2 * -R2/(R1 + R2); + }; + (1) => par_up + with{ + par_up = b0; + b0(R1, R2, a1, a2) = a1 * R2/(R1 + R2) + a2 * R1/(R1 + R2); + }; + (2) => R0 + with{ + R0(R1, R2) = 1/(1/R1+1/R2); + }; + +}; + + +//----------------------`(wd.)series`-------------------------- +// Adapted 3-port series connection. +// +// An adaptor implementing a 3-port series connection between adaptors for Wave Digital Filter connection trees. +// This adaptor is used to connect adaptors simulating components connected in series in the circuit. +// +// #### Usage +// +// ``` +// +// tree = A : (series : (B, C)); +// ``` +// +// Note: this adaptor has no user-accessible parameters. +// It should be used within the connection tree with one previous and two forward adaptors. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 1.5.2 +//---------------------------------------------------------- +declare series author "Dirk Roosenburg"; +declare series copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare series license "MIT-style STK-4.3 license"; +series = +case{ + + (0) => ser_down + with{ + ser_down = si.bus(5)<: b1, b2; + b1(R1, R2, a0, a1, a2) = a0 * -R1/(R1+R2) + a1 * R2/(R1+R2) + a2 *-R1/(R1+R2); + b2(R1, R2, a0, a1, a2) = a0 * -R2/(R1+R2) + a1 * -R2/(R1+R2) + a2 * R1/(R1+R2); + }; + (1) => ser_up + with{ + ser_up = b0; + b0(R1, R2, a1, a2) = -a1 - a2; + }; + (2) => R0 + with{ + R0(R1, R2) = R1 + R2; + }; +}; + +//====================================R-Type Adaptors===================================== +//======================================================================================== + + +//----------------------`(wd.)u_sixportPassive`-------------------------- +// Unadapted six-port rigid connection. +// +// An adaptor implementing a six-port passive rigid connection between elements. +// It implements the simplest possible rigid connection found in the Fender Bassman Tonestack circuit. +// +// +// #### Usage +// +// ``` +// +// tree = u_sixportPassive : (A, B, C, D, E, F)); +// ``` +// +// Note: this adaptor has no user-accessible parameters. +// It should be used within the connection tree with six forward adaptors. +// +// #### Reference +// +// K. Werner, "Virtual Analog Modeling of Audio Circuitry Using Wave Digital Filters", 2.1.5 +//---------------------------------------------------------- +declare u_sixportPassive author "Dirk Roosenburg"; +declare u_sixportPassive copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_sixportPassive license "MIT-style STK-4.3 license"; +u_sixportPassive(i) = genericNode(i, sixport_scatter) +with{ + sixport_scatter(Ra, Rb, Rc, Rd, Re, Rf) = matrix(6, 6, mtx) + with{ + mtx = + case{ + (1, 1) => ((-Ra)*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (1, 2) => (2*Ra*((Rc + Re)*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (1, 3) => (2*Ra*(Rb*Rd + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (1, 4) => (-1)*((2*Ra*(Rb*(Rc + Re) + Rc*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (1, 5) => (2*Ra*(Rb*Rd - Rc*Rf))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (1, 6) => (-1)*((2*Ra*(Rc*Re + Rb*(Rc + Rd + Re)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (2, 1) => (2*Rb*((Rc + Re)*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (2, 2) => (Ra*(Rd*Re - Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) - Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (2, 3) => (-1)*((2*Rb*(Ra*Re + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (2, 4) => (-2*Ra*Rb*Re + 2*Rb*Rc*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (2, 5) => (2*Rb*(Ra*(Rc + Rd) + Rc*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (2, 6) => (-1)*((2*Rb*(Rc*Rd + Ra*(Rc + Rd + Re)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (3, 1) => (2*Rc*(Rb*Rd + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (3, 2) => (-1)*((2*Rc*(Ra*Re + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (3, 3) => 1 - (2*Rc*(Rd*Re + Rd*Rf + Re*Rf + Rb*(Rd + Rf) + Ra*(Rb + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (3, 4) => (-1)*((2*Rc*(Rb*Rf + Ra*(Rb + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (3, 5) => (-1)*((2*Rc*(Ra*(Rb + Rf) + Rb*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (3, 6) => (2*Rc*(Rb*Rd - Ra*Re))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (4, 1) => (-1)*((2*Rd*(Rb*(Rc + Re) + Rc*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (4, 2) => (-2*Ra*Rd*Re + 2*Rc*Rd*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (4, 3) => (-1)*((2*Rd*(Rb*Rf + Ra*(Rb + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (4, 4) => 1 - (2*Rd*(Rc*(Re + Rf) + Ra*(Rb + Re + Rf) + Rb*(Rc + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (4, 5) => (-1)*((2*Rd*((Rb + Rc)*Rf + Ra*(Rb + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (4, 6) => (-1)*((2*Rd*((Ra + Rc)*Re + Rb*(Rc + Re)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (5, 1) => (2*Re*(Rb*Rd - Rc*Rf))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (5, 2) => (2*Re*(Ra*(Rc + Rd) + Rc*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (5, 3) => (-1)*((2*Re*(Ra*(Rb + Rf) + Rb*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (5, 4) => (-1)*((2*Re*((Rb + Rc)*Rf + Ra*(Rb + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (5, 5) => 1 - (2*Re*((Rb + Rc)*(Rd + Rf) + Ra*(Rb + Rc + Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (5, 6) => (2*((Rb + Rc)*Rd + Ra*(Rc + Rd))*Re)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (6, 1) => (-1)*((2*(Rc*Re + Rb*(Rc + Rd + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (6, 2) => (-1)*((2*(Rc*Rd + Ra*(Rc + Rd + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (6, 3) => (2*(Rb*Rd - Ra*Re)*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (6, 4) => (-1)*((2*((Ra + Rc)*Re + Rb*(Rc + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))); + (6, 5) => (2*((Rb + Rc)*Rd + Ra*(Rc + Rd))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (6, 6) => 1 - (2*(Rc*(Rd + Re) + Ra*(Rc + Rd + Re) + Rb*(Rc + Rd + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))); + (i, j) => 10; + }; + matrix(M,N,f) = si.bus(N) <: ro.interleave(N,M) : par(n,N, par(m,M,*(f(m+1,n+1)))) :> si.bus(M); + }; +}; + +//===============================Node Creating Functions================================== +//======================================================================================== + +//----------------------`(wd.)genericNode`-------------------------- +// Function for generating an adapted node from another faust function or scattering matrix. +// +// This function generates a node which is suitable for use in the connection tree structure. +// `genericNode` separates the function that it is passed into upward-going and downward-going waves. +// +// #### Usage +// +// ``` +// n1(i) = genericNode(i, scatter, upRes); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `scatter` : the function which describes the the node's scattering behavior +// * `upRes` : the function which describes the node's upward-facing port-resistance +// +// Note: `scatter` must be a function with n inputs, n outputs, and n-1 parameter inputs. +// input/output 1 will be used as the adapted upward-facing port of the node, ports 2 to n will all be downward-facing. +// The first input/output pair is assumed to already be adapted - i.e. the output 1 is not dependent on input 1. +// The parameter inputs will receive the port resistances of the downward-facing ports. +// +// `upRes` must be a function with n-1 parameter inputs and 1 output. +// The parameter inputs will receive the port resistances of the downward-facing ports. +// The output should give the upward-facing port resistance of the node based on the upward-facing port resistances of the input. +// +// If used on a leaf element (n=1), the model will automatically introduce a one-sample delay. +// Thus, the output of the node at sample t based on the input, a[t], should be the output one sample ahead, b[t+1]. +// This may require transformation of the output signal. +// +//---------------------------------------------------------- +declare genericNode author "Dirk Roosenburg"; +declare genericNode copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare genericNode license "MIT-style STK-4.3 license"; +genericNode = +case{ + (0, scatter, upRes) => down(inputs(scatter)) + with{ + down(1) = scatter; //leaf node case + down(n) = scatter : !, bus(outputs(scatter)-1); //internal node case + }; + (1, scatter, upRes) => up(inputs(scatter)) + with{ + up(1) = _; //leaf node case + up(n) = bus(inputs(upRes)), 0 , bus(outputs(scatter)-1) : scatter : _, block(outputs(scatter)-1); //internal node case + }; + (2, scatter, upRes) => upRes; +} +with{ + bus(0) = 0:!; + bus(x) = si.bus(x); + block(0) = 0:!; + block(x) = si.block(x); +}; + + +//----------------------`(wd.)genericNode_Vout`-------------------------- +// Function for generating a terminating/leaf node which gives the voltage across itself as a model output. +// +// This function generates a node which is suitable for use in the connection tree structure. +// It also calculates the voltage across the element and gives it as a model output. +// +// #### Usage +// +// ``` +// n1(i) = genericNode_Vout(i, scatter, upRes); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `scatter` : the function which describes the the node's scattering behavior +// * `upRes` : the function which describes the node's upward-facing port-resistance +// +// Note: `scatter` must be a function with 1 input and 1 output. +// It should give the output from the node based on the incident wave. +// +// The model will automatically introduce a one-sample delay to the output of the function +// Thus, the output of the node at sample t based on the input, a[t], should be the output one sample ahead, b[t+1]. +// This may require transformation of the output signal. +// +// `upRes` must be a function with no inputs and 1 output. +// The output should give the upward-facing port resistance of the node. +// +//---------------------------------------------------------- +declare genericNode_Vout author "Dirk Roosenburg"; +declare genericNode_Vout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare genericNode_Vout license "MIT-style STK-4.3 license"; +genericNode_Vout = +case{ + (0, scatter, upRes) => _ <: b, voltage + with{ + b(a) = a : scatter; + voltage(a) = 1/2*(a + b(a)'); + }; + (1, scatter, upRes) => _, !; + (2, scatter, upRes) => upRes; +}; + +//----------------------`(wd.)genericNode_Iout`-------------------------- +// Function for generating a terminating/leaf node which gives the current through itself as a model output. +// +// This function generates a node which is suitable for use in the connection tree structure. +// It also calculates the current through the element and gives it as a model output. +// +// #### Usage +// +// ``` +// n1(i) = genericNode_Iout(i, scatter, upRes); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `scatter` : the function which describes the the node's scattering behavior +// * `upRes` : the function which describes the node's upward-facing port-resistance +// +// Note: `scatter` must be a function with 1 input and 1 output. +// It should give the output from the node based on the incident wave. +// +// The model will automatically introduce a one-sample delay to the output of the function. +// Thus, the output of the node at sample t based on the input, a[t], should be the output one sample ahead, b[t+1]. +// This may require transformation of the output signal. +// +// `upRes` must be a function with no inputs and 1 output. +// The output should give the upward-facing port resistance of the node. +// +//---------------------------------------------------------- +declare genericNode_Iout author "Dirk Roosenburg"; +declare genericNode_Iout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare genericNode_Iout license "MIT-style STK-4.3 license"; +genericNode_Iout = +case{ + (0, scatter, upRes) => _ <: b, current + with{ + b(a) = a : scatter; + current(a) = 1/2/upRes*(a - b(a)'); + }; + (1, scatter, upRes) => _, !; + (2, scatter, upRes) => upRes; +}; + + +//----------------------`(wd.)u_genericNode`-------------------------- +// Function for generating an unadapted node from another Faust function or scattering matrix. +// +// This function generates a node which is suitable for use as the root of the connection tree structure. +// +// #### Usage +// +// ``` +// n1(i) = u_genericNode(i, scatter); +// ``` +// +// Where: +// +// * `i`: index used by model-building functions. Should never be user declared +// * `scatter` : the function which describes the the node's scattering behavior +// +// Note: +// `scatter` must be a function with n inputs, n outputs, and n parameter inputs. +// each input/output pair will be used as a downward-facing port of the node +// the parameter inputs will receive the port resistances of the downward-facing ports. +// +//---------------------------------------------------------- +declare u_genericNode author "Dirk Roosenburg"; +declare u_genericNode copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare u_genericNode license "MIT-style STK-4.3 license"; +u_genericNode = +case{ + (0, scatter) => scatter; + (1, scatter) => block(inputs(scatter)); + (2, scatter) => 1234; +} +with{ + block(0) = 0:!; + block(x) = si.block(x); +}; + + +//===============================Model Building Functions================================= +//======================================================================================== + + +//----------------------`(wd.)builddown`-------------------------- +// Function for building the structure for calculating waves traveling down the WD connection tree. +// +// It recursively steps through the given tree, parametrizes the adaptors, and builds an algorithm. +// It is used in conjunction with the buildup() function to create a model. +// +// #### Usage +// +// ``` +// builddown(A : B)~buildup(A : B); +// ``` +// +// Where: +// `(A : B)` : is a connection tree composed of WD adaptors +//---------------------------------------------------------- +declare builddown author "Dirk Roosenburg"; +declare builddown copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare builddown license "MIT-style STK-4.3 license"; +builddown(A : As) = ((upPortRes, addins(inputs(A(0)) - outputs(upPortRes))) : A(0)) , addins(inputs(pardown(As)) - outputs(A(0))) : route(mtxsum(s_mtx(As)), mtxsum(s_mtx(As)), gencross(0, 0, 0, 0, 0, s_mtx(As))) : pardown(As) +with{ + + //substitute for si.bus which can accept an argument of 0 + addins = + case{ + (0) => 0 : !; + (x) => si.bus(x); + }; + + //recursively build in parallel + pardown = + case{ + ((Ax, Axx)) => builddown(Ax), pardown(Axx); + (Ax) => builddown(Ax); + }; + + //generate a list of inputs from the next stage down the tree + s_mtx = + case{ + ((Ax, Axx)) => inputs(builddown(Ax)), s_mtx(Axx); + (Ax) => inputs(builddown(Ax)); + }; + + //take the sum of the list + mtxsum(t_mtx) = sum(i, ba.count(t_mtx), ba.take(i+1, t_mtx)); + + upPortRes = parres(As); + + //generate a crossover matrix for the route object based on a list of i/o dimensions + gencross = + case{ + (0, 0, 0, 0, 0, (1, 1)) => 1, 1, 2, 2; + (0, 0, 0, 0, 0, (xs, xxs)) => (1, 1), gencross(2, xs+1, ba.count((xs, xxs))-1, 2, mtxsum((xs, xxs)), xxs); + + (0, 0, 0, 0, 0, 0) => 0 : !; + (0, 0, 0, 0, 0, x) => par(i, x, i+1, i+1); + + //((out, next, norm_index, spec_index, sum), (xs, xxs)) + + (msum, msum, count, fcount, msum, xs) => (fcount, msum); //output is a special output + (msum, next, count, fcount, msum, xs) => (msum, msum-count); //escape case, reached end of bus + + (out, out, count, fcount, msum, (xs, xxs)) => (fcount, out), gencross(out+1, xs+out, count-1, fcount+1, msum, xxs); + (out, out, count, fcount, msum, xs) => (fcount, out), gencross(out+1, xs+out, count-1, fcount+1, msum, 0); //output is a special output + + (out, next, count, fcount, msum, xs) => ((count+out), out), gencross(out+1, next, count, fcount, msum, xs); //output is not a special output + }; +}; + +builddown(A) = A(0); + + +//----------------------`(wd.)buildup`-------------------------- +// Function for building the structure for calculating waves traveling up the WD connection tree. +// +// It recursively steps through the given tree, parametrizes the adaptors, and builds an algorithm. +// It is used in conjunction with the builddown() function to create a full structure. +// +// #### Usage +// +// ``` +// builddown(A : B)~buildup(A : B); +// ``` +// +// Where: +// `(A : B)` : is a connection tree composed of WD adaptors +//---------------------------------------------------------- +declare builddown author "Dirk Roosenburg"; +declare builddown copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare builddown license "MIT-style STK-4.3 license"; +buildup(A : As) = upPortRes, (parup(As) : route(mtxsum(s_mtx(As)), mtxsum(s_mtx(As)), gencross_up(0, 0, 0, 0, 0, s_mtx(As))) : split(s_mtx(As))) : A(1), addins(outputs(split(s_mtx(As))) + outputs(upPortRes) - inputs(A(1))) +with{ + + //substitute for si.bus which can accept an argument of 0 + addins = + case{ + (0) => 0 : !; + (x) => si.bus(x); + }; + + //recursively build in parallel + parup = //<: crossover(out_list(Ap)) : split(out_list(Ap)) + case{ + ((Ax, Axx)) => buildup(Ax), parup(Axx); + (Ax) => buildup(Ax); + }; + + //generate a list of outputs from the next stage down the tree + s_mtx = + case{ + ((Ax, Axx)) => outputs(buildup(Ax)), s_mtx(Axx); + (Ax) => outputs(buildup(Ax)); + }; + + //take the sum of a list + mtxsum(t_mtx) = sum(i, ba.count(t_mtx), ba.take(i+1, t_mtx)); + + //split based on a list of i/o dimensions + split(inl) = (si.bus(n) <: si.bus(n), si.bus(n)), (addins(s-n)) + with{ + n = ba.count(inl); + s = inl :> _; + }; + + //generate a crossover matrix based for the route object based on a list of i/o dimensions + gencross_up = + case{ + //corner case which must be coded manually + (0, 0, 0, 0, 0, (1, 1)) => 1, 1, 2, 2; + //user access function + (0, 0, 0, 0, 0, (xs, xxs)) => (1, 1), gencross_up(2, xs+1, ba.count((xs, xxs))-1, 2, mtxsum((xs, xxs)), xxs); + + //more corner cases + (0, 0, 0, 0, 0, 0) => 0: !; + (0, 0, 0, 0, 0, x) => par(i, x, i+1, i+1); + + //((out, next, norm_index, spec_index, sum), (xs, xxs)) + + (msum, msum, count, fcount, msum, xs) => (msum, fcount); //output is a special output + (msum, next, count, fcount, msum, xs) => (msum-count, msum); //escape case, reached end of bus + + (out, out, count, fcount, msum, (xs, xxs)) => (out, fcount), gencross_up(out+1, xs+out, count-1, fcount+1, msum, xxs); + (out, out, count, fcount, msum, xs) => (out, fcount), gencross_up(out+1, xs+out, count-1, fcount+1, msum, 0); //output is a special output + + (out, next, count, fcount, msum, xs) => (out, (count+out)), gencross_up(out+1, next, count, fcount, msum, xs); //output is not a special output + }; + + upPortRes = parres(As); +}; + +buildup(A) = A(1); + +//----------------------`(wd.)getres`-------------------------- +// Function for determining the upward-facing port resistance of a partial WD connection tree. +// +// It recursively steps through the given tree, parametrizes the adaptors, and builds an algorithm. +// It is used by the buildup and builddown functions but is also helpful in testing. +// +// #### Usage +// +// ``` +// getres(A : B)~getres(A : B); +// ``` +// +// Where: +// `(A : B)` : is a partial connection tree composed of WD adaptors +// +// Note: +// This function cannot be used on a complete WD tree. When called on an unadapted adaptor (u_ prefix), it will create errors. +//---------------------------------------------------------- +declare getres author "Dirk Roosenburg"; +declare getres copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare getres license "MIT-style STK-4.3 license"; +getres(A: As) = parres(As) : A(2); +getres(A) = A(2); + + +//----------------------`(wd.)parres`-------------------------- +// Function for determining the upward-facing port resistance of a partial WD connection tree. +// +// It recursively steps through the given tree, parametrizes the adaptors, and builds an algorithm. +// It is used by the buildup and builddown functions but is also helpful in testing. +// This function is a parallelized version of `getres`. +// +// #### Usage +// +// ``` +// parres((A , B))~parres((A , B)); +// ``` +// +// Where: +// `(A , B)` : is a partial connection tree composed of WD adaptors +// +// Note: this function cannot be used on a complete WD tree. When called on an unadapted adaptor (u_ prefix), it will create errors. +//---------------------------------------------------------- +declare parres author "Dirk Roosenburg"; +declare parres copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare parres license "MIT-style STK-4.3 license"; +parres((Ap1, Ap2)) = getres(Ap1) , parres(Ap2); +parres(Ap) = getres(Ap); + + +//----------------------`(wd.)buildout`-------------------------- +// Function for creating the output matrix for a WD model from a WD connection tree. +// +// It recursively steps through the given tree and creates an output matrix passing only outputs. +// +// #### Usage +// +// ``` +// buildout( A : B ); +// ``` +// +// Where: +// `(A : B)` : is a connection tree composed of WD adaptors +// +//---------------------------------------------------------- +declare buildout author "Dirk Roosenburg"; +declare buildout copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare buildout license "MIT-style STK-4.3 license"; +buildout(A: As) = parout(As) +with{ + parout((A, Ap)) = buildout(A), parout(Ap); + parout(A) = buildout(A); +}; +buildout(A) = outmtx(outputs(A(0))) +with{ + outmtx(1) = !; + outmtx(2) = !, _; +}; + + +//----------------------`(wd.)buildtree`-------------------------- +// Function for building the DSP model from a WD connection tree structure. +// +// It recursively steps through the given tree, parametrizes the adaptors, and builds the algorithm. +// +// #### Usage +// +// ``` +// buildtree(A : B); +// ``` +// +// Where: +// `(A : B)` : a connection tree composed of WD adaptors +//---------------------------------------------------------- +declare buildtree author "Dirk Roosenburg"; +declare buildtree copyright "Copyright (C) 2020 by Dirk Roosenburg "; +declare buildtree license "MIT-style STK-4.3 license"; +buildtree((A : B)) = builddown(A : B)~buildup(A : B) : buildout(A : B); + + +/******************************************************************************* +# Licenses + +## STK 4.3 License + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +Any person wishing to distribute modifications to the Software is asked to send +the modifications to the original developer so that they can be incorporated +into the canonical version. For software copyrighted by Dirk Roosenburg, +email your modifications to . This is, however, not a +binding provision of this license. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +## LGPL License + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU Lesser General Public License as published by the Free +Software Foundation; either version 2.1 of the License, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with the GNU C Library; if not, write to the Free Software Foundation, Inc., +59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*******************************************************************************/ diff --git a/dist/examples/LIBRARIES/webaudio.lib b/dist/examples/LIBRARIES/webaudio.lib new file mode 100644 index 00000000..e524991f --- /dev/null +++ b/dist/examples/LIBRARIES/webaudio.lib @@ -0,0 +1,402 @@ +//#################################### webaudio.lib ######################################## +//An implementation of the WebAudio API filters (https://www.w3.org/TR/webaudio/). Its official prefix is `wa`. +// +// This library implement WebAudio filters, using their C++ version as a starting point, +// taken from Mozilla Firefox implementation. +// +// #### References +// * +//######################################################################################## + +/************************************************************************ +************************************************************************ +FAUST library file +Copyright (C) 2019-2020 GRAME, Centre National de Creation Musicale +--------------------------------------------------------------------- +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation; either version 2.1 of the +License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with the GNU C Library; if not, write to the Free +Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a +larger FAUST program which directly or indirectly imports this library +file and still distribute the compiled code generated by the FAUST +compiler, or a modified version of this compiled code, under your own +copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly +grants you the right to freely choose the license for the resulting +compiled code. In particular the resulting compiled code has no obligation +to be LGPL or GPL. For example you are free to choose a commercial or +closed source license or any other license if you decide so. +************************************************************************ +************************************************************************/ + +ma = library("maths.lib"); +fi = library("filters.lib"); + +declare name "Faust WebAudio Filters Library"; +declare author "GRAME"; +declare copyright "GRAME"; +declare version "0.1"; +declare license "LGPL with exception"; + +//--------------------------------------------------- +// biquad coeffs for various filters +// usage : BiquadFilter(f0, dBgain, Q, aDetune).xxx +//--------------------------------------------------- + +BiquadFilter(f0, dBgain, Q, aDetune) = environment +{ + lowpass2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + g = pow(10.0, -0.05 * Q); + w0 = ma.PI * cutoff; + cos_w0 = cos(w0); + alpha = 0.5 * sin(w0) * g; + + b1 = 1.0 - cos_w0; + b0 = 0.5 * b1; + b2 = b0; + a0 = 1.0 + alpha; + a1 = -2.0 * cos_w0; + a2 = 1.0 - alpha; + }; + + highpass2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + g = pow(10.0, -0.05 * Q); + w0 = ma.PI * cutoff; + cos_w0 = cos(w0); + alpha = 0.5 * sin(w0) * g; + + b1 = -1.0 - cos_w0; + b0 = -0.5 * b1; + b2 = b0; + a0 = 1.0 + alpha; + a1 = -2.0 * cos_w0; + a2 = 1.0 - alpha; + }; + + bandpass2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + // Don't let Q go negative, which causes an unstable filter. + Qaux = max(0.01, Q); + + w0 = ma.PI * cutoff; + alpha = sin(w0) / (2 * Qaux); + k = cos(w0); + + b0 = alpha; + b1 = 0; + b2 = -alpha; + a0 = 1 + alpha; + a1 = -2 * k; + a2 = 1 - alpha; + }; + + notch2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + // Don't let Q go negative, which causes an unstable filter. + Qaux = max(0.01, Q); + + w0 = ma.PI * cutoff; + alpha = sin(w0) / (2 * Qaux); + k = cos(w0); + + b0 = 1; + b1 = -2 * k; + b2 = 1; + a0 = 1 + alpha; + a1 = -2 * k; + a2 = 1 - alpha; + }; + + allpass2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + // Don't let Q go negative, which causes an unstable filter. + Qaux = max(0.01, Q); + + w0 = ma.PI * cutoff; + alpha = sin(w0) / (2 * Qaux); + k = cos(w0); + + b0 = 1 - alpha; + b1 = -2 * k; + b2 = 1 + alpha; + a0 = 1 + alpha; + a1 = -2 * k; + a2 = 1 - alpha; + }; + + peaking2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + // Don't let Q go negative, which causes an unstable filter. + Qaux = max(0.01, Q); + + A = pow(10.0, dBgain / 40); + w0 = ma.PI * cutoff; + alpha = sin(w0) / (2 * Qaux); + k = cos(w0); + + b0 = 1 + alpha * A; + b1 = -2 * k; + b2 = 1 - alpha * A; + a0 = 1 + alpha / A; + a1 = -2 * k; + a2 = 1 - alpha / A; + }; + + lowshelf2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + A = pow(10.0, dBgain / 40); + + w0 = ma.PI * cutoff; + S = 1; // filter slope (1 is max value) + alpha = 0.5 * sin(w0) * sqrt((A + 1 / A) * (1 / S - 1) + 2); + k = cos(w0); + k2 = 2 * sqrt(A) * alpha; + aPlusOne = A + 1; + aMinusOne = A - 1; + + b0 = A * (aPlusOne - aMinusOne * k + k2); + b1 = 2 * A * (aMinusOne - aPlusOne * k); + b2 = A * (aPlusOne - aMinusOne * k - k2); + a0 = aPlusOne + aMinusOne * k + k2; + a1 = -2 * (aMinusOne + aPlusOne * k); + a2 = aPlusOne + aMinusOne * k - k2; + }; + + highshelf2 = setNormCoeffs(b0, b1, b2, a0, a1, a2) + with { + A = pow(10.0, dBgain / 40); + + w0 = ma.PI * cutoff; + S = 1; // filter slope (1 is max value) + alpha = 0.5 * sin(w0) * sqrt((A + 1 / A) * (1 / S - 1) + 2); + k = cos(w0); + k2 = 2 * sqrt(A) * alpha; + aPlusOne = A + 1; + aMinusOne = A - 1; + + b0 = A * (aPlusOne - aMinusOne * k + k2); + b1 = 2 * A * (aMinusOne - aPlusOne * k); + b2 = A * (aPlusOne - aMinusOne * k - k2); + a0 = aPlusOne + aMinusOne * k + k2; + a1 = -2 * (aMinusOne + aPlusOne * k); + a2 = aPlusOne + aMinusOne * k - k2; + }; + + // --------------------- implementation ------------------------------ + + // Convert rbj coeffs to fi.tf2 coeffs + setNormCoeffs(b0,b1,b2,a0,a1,a2) = (b0/a0, b1/a0, b2/a0, a1/a0, a2/a0); + + nyquist = ma.SR * 0.5; + nFreq = (f0 / nyquist) * pow(2, aDetune / 1200); + + // Limit cutoff between 0.01 and 0.99. + cutoff = max(0.01, min(nFreq, 0.99)); + +}; + +//------------------------------------------------------------------------- +// Implementation of filters using BiquadFilter and fi.tf2 +//------------------------------------------------------------------------- + +//--------------`(wa.)lowpass2`-------------- +// Standard second-order resonant lowpass filter with 12dB/octave rolloff. +// Frequencies below the cutoff pass through, frequencies above it are attenuated. +// +// #### Usage +// +// ``` +// _ : lowpass2(f0, Q, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `Q`: the quality factor +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +lowpass2(f0, Q, dtune, x) = BiquadFilter(f0, 1, Q, dtune).lowpass2, x : fi.tf2; + + +//--------------`(wa.)highpass2`-------------- +// Standard second-order resonant highpass filter with 12dB/octave rolloff. +// Frequencies below the cutoff are attenuated, frequencies above it pass through. +// +// #### Usage +// +// ``` +// _ : highpass2(f0, Q, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `Q`: the quality factor +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +highpass2(f0, Q, dtune, x) = BiquadFilter(f0, 1, Q, dtune).highpass2, x : fi.tf2; + + +//--------------`(wa.)bandpass2`-------------- +// Standard second-order bandpass filter. +// Frequencies outside the given range of frequencies are attenuated, the frequencies inside it pass through. +// +// #### Usage +// +// ``` +// _ : bandpass2(f0, Q, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `Q`: the quality factor +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +bandpass2(f0, Q, dtune, x) = BiquadFilter(f0, 1, Q, dtune).bandpass2, x : fi.tf2; + + +//--------------`(wa.)notch2`-------------- +// Standard notch filter, also called a band-stop or band-rejection filter. +// It is the opposite of a bandpass filter: frequencies outside the give range of frequencies +// pass through, frequencies inside it are attenuated. +// +// #### Usage +// +// ``` +// _ : notch2(f0, Q, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `Q`: the quality factor +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +notch2(f0, Q, dtune, x) = BiquadFilter(f0, 1, Q, dtune).notch2, x : fi.tf2; + + +//--------------`(wa.)allpass2`-------------- +// Standard second-order allpass filter. It lets all frequencies through, +// but changes the phase-relationship between the various frequencies. +// +// #### Usage +// +// ``` +// _ : allpass2(f0, Q, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `Q`: the quality factor +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +allpass2(f0, Q, dtune, x) = BiquadFilter(f0, 1, Q, dtune).allpass2, x : fi.tf2; + + +//--------------`(wa.)peaking2`-------------- +// Frequencies inside the range get a boost or an attenuation, frequencies outside it are unchanged. +// +// #### Usage +// +// ``` +// _ : peaking2(f0, gain, Q, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `gain`: the gain in dB +// * `Q`: the quality factor +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +peaking2(f0, gain, Q, dtune, x) = BiquadFilter(f0, gain, Q, dtune).peaking2, x : fi.tf2; + + +//--------------`(wa.)lowshelf2`-------------- +// Standard second-order lowshelf filter. +// Frequencies lower than the frequency get a boost, or an attenuation, frequencies over it are unchanged. +// +// ``` +// _ : lowshelf2(f0, gain, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `gain`: the gain in dB +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +lowshelf2(f0, gain, dtune, x) = BiquadFilter(f0, gain, 1, dtune).lowshelf2, x : fi.tf2; + + +//--------------`(wa.)highshelf2`-------------- +// Standard second-order highshelf filter. +// Frequencies higher than the frequency get a boost or an attenuation, frequencies lower than it are unchanged. +// +// ``` +// _ : highshelf2(f0, gain, dtune) : _ +// ``` +// +// Where: +// +// * `f0`: cutoff frequency in Hz +// * `gain`: the gain in dB +// * `dtune`: detuning of the frequency in cents +// +// #### Reference +// +// +//-------------------------------------- + +highshelf2(f0, gain, dtune, x) = BiquadFilter(f0, gain, 1, dtune).highshelf2, x : fi.tf2; + diff --git a/dist/examples/ambisonics/fourSourcesToOcto.dsp b/dist/examples/ambisonics/fourSourcesToOcto.dsp new file mode 100644 index 00000000..be29321c --- /dev/null +++ b/dist/examples/ambisonics/fourSourcesToOcto.dsp @@ -0,0 +1,20 @@ +declare name "fourSourcesToOcto"; +declare version "1.0"; +declare author "CICM"; +declare license "BSD"; +declare copyright "(c)CICM 2013"; + +import("stdfaust.lib"); + +r1 = hslider("Radius1", 1.0, 0, 5, 0.001) : si.smooth(ba.tau2pole(0.02)); +a1 = hslider("Angle1", 0, ma.PI*(-2), ma.PI*2, 0.001) : si.smooth(ba.tau2pole(0.02)); +r2 = hslider("Radius2", 1.0, 0, 5, 0.001) : si.smooth(ba.tau2pole(0.02)); +a2 = hslider("Angle2", 0, ma.PI*(-2), ma.PI*2, 0.001) : si.smooth(ba.tau2pole(0.02)); +r3 = hslider("Radius3", 1.0, 0, 5, 0.001) : si.smooth(ba.tau2pole(0.02)); +a3 = hslider("Angle3", 0, ma.PI*(-2), ma.PI*2, 0.001) : si.smooth(ba.tau2pole(0.02)); +r4 = hslider("Radius4", 1.0, 0, 5, 0.001) : si.smooth(ba.tau2pole(0.02)); +a4 = hslider("Angle4", 0, ma.PI*(-2), ma.PI*2, 0.001) : si.smooth(ba.tau2pole(0.02)); + +process(sig1, sig2, sig3, sig4) = ho.map(3, sig1, r1, a1), ho.map(3, sig2, r2, a2), ho.map(3, sig3, r3, a3), ho.map(3, sig4, r4, a4) :> ho.optimInPhase(3) : ho.decoder(3, 8); + + diff --git a/dist/examples/ambisonics/oneSourceToStereo.dsp b/dist/examples/ambisonics/oneSourceToStereo.dsp new file mode 100644 index 00000000..0b8d1ba9 --- /dev/null +++ b/dist/examples/ambisonics/oneSourceToStereo.dsp @@ -0,0 +1,12 @@ +declare name "oneSourceToStereo"; +declare version "1.0"; +declare author "CICM"; +declare license "BSD"; +declare copyright "(c)CICM 2013"; + +import("stdfaust.lib"); + +r1 = hslider("Radius", 1.0, 0, 5, 0.001) : si.smooth(ba.tau2pole(0.02)); +a1 = hslider("Angle", 0, ma.PI*(-2), ma.PI*2, 0.001) : si.smooth(ba.tau2pole(0.02)); + +process(sig) = ho.map(7, sig, r1, a1) : ho.optimInPhase(7) : ho.decoderStereo(7); diff --git a/dist/examples/analysis/FFT.dsp b/dist/examples/analysis/FFT.dsp new file mode 100644 index 00000000..3589b4c8 --- /dev/null +++ b/dist/examples/analysis/FFT.dsp @@ -0,0 +1,26 @@ +// Radix 2 FFT, decimation in time, real and imag parts interleaved + +declare name "FFT"; // Faust Fourier Transform :-) +declare author "JOS"; +declare license "STK-4.3"; + +import("stdfaust.lib"); + +N=32; // FFT size (power of 2) +// Number of frequency bins (including dc and SR/2) is N/2+1 + +No2 = N>>1; +signal = amp * cosine with { + cosine = select2(k==0, + select2(k==No2, + 2.0*os.oscrc(f(k)), // 2x since negative-frequencies not displayed + 1-1':+~*(-1) // Alternating sequence: 1, -1, 1, -1 + ), + 1.0); // make sure phase is zero (freq jumps around) + f(k) = float(k) * ma.SR / float(N); // only test FFT bin frequencies + k = hslider("[2] FFT Bin Number",N/4,0,No2,0.001) : int <: _,dpy : attach; + dpy = hbargraph("[3] Measured FFT Bin Number",0,No2); + amp = hslider("[4] Amplitude",0.1,0,1,0.001); +}; + +process = signal : dm.fft_spectral_level_demo(N) <: _,_; diff --git a/dist/examples/analysis/dbmeter.dsp b/dist/examples/analysis/dbmeter.dsp new file mode 100644 index 00000000..6b3cb404 --- /dev/null +++ b/dist/examples/analysis/dbmeter.dsp @@ -0,0 +1,19 @@ +declare name "dbmeter"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------- +// A dB Vumeter +//------------------------------------------------- + +import("stdfaust.lib"); + + +vmeter(x) = attach(x, envelop(x) : vbargraph("[unit:dB]", -70, 10)); +hmeter(x) = attach(x, envelop(x) : hbargraph("[unit:dB]", -70, 10)); + +envelop = abs : max(ba.db2linear(-70)) : ba.linear2db : min(10) : max ~ -(80.0/ma.SR); +null(x) = attach(0,x); +process = hgroup("8 channels dB meter", par(i,8, vgroup("%i", vmeter : null))); diff --git a/dist/examples/analysis/spectralLevel.dsp b/dist/examples/analysis/spectralLevel.dsp new file mode 100644 index 00000000..3928d867 --- /dev/null +++ b/dist/examples/analysis/spectralLevel.dsp @@ -0,0 +1,8 @@ +declare name "spectralLevel"; +declare version "0.0"; +declare author "JOS, revised by RM"; +declare description "Demonstrates mth_octave_spectral_level in a standalone GUI."; + +import("stdfaust.lib"); + +process = dm.spectral_level_demo; diff --git a/dist/examples/analysis/spectralTiltLab.dsp b/dist/examples/analysis/spectralTiltLab.dsp new file mode 100644 index 00000000..5c9f3646 --- /dev/null +++ b/dist/examples/analysis/spectralTiltLab.dsp @@ -0,0 +1,20 @@ +// example exercising filters.lib's spectral_tilt_demo + +declare name "spectralTiltLab"; + +import("stdfaust.lib"); + +N = 10; // Number of pole-zero pairs to use + +process = sig(dm.sawtooth_demo) + : stg(ba.bypass1(bp,dm.spectral_tilt_demo(N))) + <: sag(dm.spectral_level_demo) +with { + bp = stg(checkbox("[0] Bypass Spectral Tilt")); + stg(x) = vgroup( + "[1] Spectral Tilt Filter [tooltip: See Faust's filters.lib for spectral_tilt_demo]",x); + sig(x) = vgroup( + "[2] Test Signal [tooltip: See Faust's oscillator.lib for sawtooth_demo]",x); + sag(x) = vgroup( + "[4] Spectrum Analyzer [tooltip: See Faust's filters.lib for spectral_level_demo]",x); +}; diff --git a/dist/examples/analysis/vumeter.dsp b/dist/examples/analysis/vumeter.dsp new file mode 100644 index 00000000..cbaeefa0 --- /dev/null +++ b/dist/examples/analysis/vumeter.dsp @@ -0,0 +1,19 @@ +declare name "vumeter"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------- +// Simple vumeter +//------------------------------------------------- + +import("stdfaust.lib"); + + +vmeter(x) = attach(x, envelop(x) : vbargraph("[2][unit:dB]", -70, +5)); +hmeter(x) = attach(x, envelop(x) : hbargraph("[2][unit:dB]", -70, +5)); + +envelop = abs : max ~ -(1.0/ma.SR) : max(ba.db2linear(-70)) : ba.linear2db; + +process = hmeter,hmeter; diff --git a/dist/examples/bela/AdditiveSynth.dsp b/dist/examples/bela/AdditiveSynth.dsp new file mode 100644 index 00000000..607527e1 --- /dev/null +++ b/dist/examples/bela/AdditiveSynth.dsp @@ -0,0 +1,43 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Additive synthesizer, must be used with OSC message to program sound. +// It as 8 harmonics. Each have it's own volume envelop. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// OSC messages (see BELA console for precise adress) +// For each harmonics (%rang indicate harmonic number, starting at 0) : +// vol%rang : General Volume (vol0 control the volume of the fundamental) +// A%rang : Attack +// D%rang : Decay +// S%rang : Sustain +// R%rang : Release +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// GENERAL +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 10, 0.01); + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +partiel(rang) = os.oscrs(gFreq*(rang+1))*volume + with { + // UI + vol = hslider("vol%rang", 1, 0, 1, 0.001); + + a = 0.01 * hslider("A%rang", 1, 0, 400, 0.001); + d = 0.01 * hslider("D%rang", 1, 0, 400, 0.001); + s = hslider("S%rang", 1, 0, 1, 0.001); + r = 0.01 * hslider("R%rang", 1, 0, 800, 0.001); + + volume = ((en.adsr(a,d,s,r,midigate))*vol) : max (0) : min (1); + }; + +process = par(i, 8, partiel(i)) :> / (8); diff --git a/dist/examples/bela/AdditiveSynth_Analog.dsp b/dist/examples/bela/AdditiveSynth_Analog.dsp new file mode 100644 index 00000000..94754d3c --- /dev/null +++ b/dist/examples/bela/AdditiveSynth_Analog.dsp @@ -0,0 +1,48 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Additive synthesizer, must be used with OSC message to program sound. +// It as 8 harmonics. Each have it's own volume envelope. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_0 : vol0 (volum of fundamental) +// ANALOG_1 : vol1 +// ... +// ANALOG_7 : vol7 +// +// OSC messages (see BELA console for precise adress) +// For each harmonics (%rang indicate harmonic number, starting at 0) : +// A%rang : Attack +// D%rang : Decay +// S%rang : Sustain +// R%rang : Release +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// GENERAL +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 10, 0.01); + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +partiel(rang) = os.oscrs(gFreq*(rang+1))*volume + with { + // UI + vol = hslider("vol%rang[BELA: ANALOG_%rang]", 1, 0, 1, 0.001); + + a = 0.01 * hslider("A%rang", 1, 0, 400, 0.001); + d = 0.01 * hslider("D%rang", 1, 0, 400, 0.001); + s = hslider("S%rang", 1, 0, 1, 0.001); + r = 0.01 * hslider("R%rang", 1, 0, 800, 0.001); + + volume = ((en.adsr(a,d,s,r,midigate))*vol) : max (0) : min (1); + }; + +process = par(i, 8, partiel(i)) :> / (8); diff --git a/dist/examples/bela/FMSynth2.dsp b/dist/examples/bela/FMSynth2.dsp new file mode 100644 index 00000000..287fe64f --- /dev/null +++ b/dist/examples/bela/FMSynth2.dsp @@ -0,0 +1,59 @@ +import("all.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple FM synthesizer. +// 2 oscillators and FM feedback on modulant oscillator +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// +// CC 1 : FM feedback on modulant oscillator. +// CC 14 : Modulator frequency ratio. +// +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// GENERAL, Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 1, 0, 1, 0.01); + +// modwheel: +feedb = (gFreq-1) * (hslider("feedb[midi:ctrl 1]", 0, 0, 1, 0.001) : si.smoo); +modFreqRatio = hslider("ratio[midi:ctrl 14]",2,0,20,0.01) : si.smoo; + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +//=================================== Parameters Mapping ================================= +//======================================================================================== +// Same for volum & modulation: +volA = hslider("A[midi:ctrl 73]",0.01,0.01,4,0.01); +volD = hslider("D[midi:ctrl 76]",0.6,0.01,8,0.01); +volS = hslider("S[midi:ctrl 77]",0.2,0,1,0.01); +volR = hslider("R[midi:ctrl 72]",0.8,0.01,8,0.01); +envelop = en.adsre(volA,volD,volS,volR,midigate); + +// modulator frequency +modFreq = gFreq*modFreqRatio; + +// modulation index +FMdepth = envelop * 1000 * midigain; + +// Out amplitude +vol = envelop; + +//============================================ DSP ======================================= +//======================================================================================== + +FMfeedback(frq) = (+(_,frq):os.osci ) ~ (* (feedb)); +FMall(f) = os.osci(f+(FMdepth*FMfeedback(f*modFreqRatio))); + +process = FMall(gFreq) * vol; diff --git a/dist/examples/bela/FMSynth2_Analog.dsp b/dist/examples/bela/FMSynth2_Analog.dsp new file mode 100644 index 00000000..a3e16151 --- /dev/null +++ b/dist/examples/bela/FMSynth2_Analog.dsp @@ -0,0 +1,57 @@ +import("all.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple FM synthesizer. + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_0 : Modulator frequency ratio +// ANALOG_1 : Attack +// ANALOG_2 : Decay/Release +// ANALOG_3 : Sustain +// +// MIDI: +// CC 1 : FM feedback on modulant oscillator. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// GENERAL, Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 1, 0, 1, 0.01); + +// modwheel: +feedb = (gFreq-1) * (hslider("feedb[midi:ctrl 1]", 0, 0, 1, 0.001) : si.smoo); +modFreqRatio = hslider("ratio[BELA: ANALOG_0]",2,0,20,0.01) : si.smoo; + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +//=================================== Parameters Mapping ================================= +//======================================================================================== +// Same for volume & modulation: +volA = hslider("A[BELA: ANALOG_1]",0.01,0.01,4,0.01); +volDR = hslider("DR[BELA: ANALOG_2]",0.6,0.01,8,0.01); +volS = hslider("S[BELA: ANALOG_3]",0.2,0,1,0.01); +envelop = en.adsre(volA,volDR,volS,volDR,midigate); + +// modulator frequency +modFreq = gFreq * modFreqRatio; + +// modulation index +FMdepth = envelop * 1000 * midigain; + +// Out amplitude +vol = envelop; + +//============================================ DSP ======================================= +//======================================================================================== + +FMfeedback(frq) = (+(_,frq):os.osci) ~ (* (feedb)); +FMall(f) = os.osci(f+ (FMdepth*FMfeedback(f*modFreqRatio))); + +process = FMall(gFreq) * vol; diff --git a/dist/examples/bela/FMSynth2_FX.dsp b/dist/examples/bela/FMSynth2_FX.dsp new file mode 100644 index 00000000..e4255f41 --- /dev/null +++ b/dist/examples/bela/FMSynth2_FX.dsp @@ -0,0 +1,138 @@ +import("all.lib"); + + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple FM synthesizer. +// 2 oscillators and FM feedback on modulant oscillator +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// +// CC 1 : FM feedback on modulant oscillator. +// CC 14 : Modulator frequency ratio. +// +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// GENERAL, Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 1, 0, 1, 0.01); + +// modwheel: +feedb = (gFreq-1) * (hslider("feedb[midi:ctrl 1]", 0, 0, 1, 0.001) : si.smoo); +modFreqRatio = hslider("ratio[midi:ctrl 14]",2,0,20,0.01) : si.smoo; + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +//=================================== Parameters Mapping ================================= +//======================================================================================== +// Same for volum & modulation: +volA = hslider("A[midi:ctrl 73]",0.01,0.01,4,0.01); +volD = hslider("D[midi:ctrl 76]",0.6,0.01,8,0.01); +volS = hslider("S[midi:ctrl 77]",0.2,0,1,0.01); +volR = hslider("R[midi:ctrl 72]",0.8,0.01,8,0.01); +envelop = en.adsre(volA,volD,volS,volR,midigate); + +// modulator frequency +modFreq = gFreq*modFreqRatio; + +// modulation index +FMdepth = envelop * 1000 * midigain; + +// Out amplitude +vol = envelop; + +//============================================ DSP ======================================= +//======================================================================================== + +FMfeedback(frq) = ( +(_,frq):os.osci ) ~ (* (feedb)); +FMall(f) = os.osci(f+ (FMdepth*FMfeedback(f*modFreqRatio))); + +//#################################################################################################// +//##################################### EFFECT SECTION ############################################// +//#################################################################################################// +// Simple FX chain build for a mono synthesizer. +// It control general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// (All are available by OSC) +// +// CC 7 : Volume +// CC 10 : Pan +// +// CC 92 : Distortion Drive +// +// CC 13 : Flanger Delay +// CC 93 : Flanger Dry/Wet +// CC 94 : Flanger Feedback +// +// CC 12 : Reverberation Room size +// CC 91 : Reverberation Dry/Wet +// CC 95 : Reverberation Damp +// CC 90 : Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +volFX = hslider("volume[midi:ctrl 7]",1,0,1,0.001);// Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider("drive[midi:ctrl 92]",0.3,0,1,0.001); + +// Flanger +curdel = hslider("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider("dryWetFlang[midi:ctrl 93]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Pannoramique: +panno = _ : sp.panner(hslider("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[midi:ctrl 12]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[midi:ctrl 91]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effect = _ *(volFX) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +process = FMall(gFreq) * vol; diff --git a/dist/examples/bela/FMSynth2_FX_Analog.dsp b/dist/examples/bela/FMSynth2_FX_Analog.dsp new file mode 100644 index 00000000..2835fa16 --- /dev/null +++ b/dist/examples/bela/FMSynth2_FX_Analog.dsp @@ -0,0 +1,142 @@ +import("all.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple FM synthesizer. +// 2 oscillators and FM feedback on modulant oscillator +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_0 : Modulator frequency ratio +// ANALOG_1 : Attack +// ANALOG_2 : Decay/Release +// ANALOG_3 : Sustain +// +// MIDI: +// CC 1 : FM feedback on modulant oscillator. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// GENERAL, Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 1, 0, 1, 0.01); + +// modwheel: +feedb = (gFreq-1) * (hslider("feedb[midi:ctrl 1]", 0, 0, 1, 0.001) : si.smoo); +modFreqRatio = hslider("ratio[BELA: ANALOG_0]",2,0,20,0.01) : si.smoo; + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +//=================================== Parameters Mapping ================================= +//======================================================================================== +// Same for volume & modulation: +volA = hslider("A[BELA: ANALOG_1]",0.01,0.01,4,0.01); +volDR = hslider("DR[BELA: ANALOG_2]",0.6,0.01,8,0.01); +volS = hslider("S[BELA: ANALOG_3]",0.2,0,1,0.01); +envelop = en.adsre(volA,volDR,volS,volDR,midigate); + +// modulator frequency +modFreq = gFreq * modFreqRatio; + +// modulation index +FMdepth = envelop * 1000 * midigain; + +// Out amplitude +vol = envelop; + +//============================================ DSP ======================================= +//======================================================================================== + +FMfeedback(frq) = (+(_,frq):os.osci) ~ (* (feedb)); +FMall(f) = os.osci(f+ (FMdepth*FMfeedback(f*modFreqRatio))); + +//#################################################################################################// +//##################################### EFFECT SECTION ############################################// +//#################################################################################################// +// +// Simple FX chaine build for a mono synthesizer. +// It controle general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +// This version use ANALOG IN to controle some of the parameters. +// Other parameters continue to be available by MIDI or OSC. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_4 : Distortion Drive +// ANALOG_5 : Flanger Dry/Wet +// ANALOG_6 : Reverberation Dry/Wet +// ANALOG_7 : Reverberation Room size +// +// MIDI: +// CC 7 : Volume +// CC 10 : Pan +// +// CC 13 : Flanger Delay +// CC 13 : Flanger Delay +// CC 94 : Flanger Feedback +// +// CC 95 : Reverberation Damp +// CC 90 : Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +volFX = hslider("volume[midi:ctrl 7]",1,0,1,0.001); // Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider("drive[BELA: ANALOG_4]",0.3,0,1,0.001); + +// Flanger +curdel = hslider("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider("dryWetFlang[BELA: ANALOG_5]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Pannoramique: +panno = _ : sp.panner(hslider("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[BELA: ANALOG_7]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[BELA: ANALOG_6]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effect = _ *(volFX) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +process = FMall(gFreq) * vol; + diff --git a/dist/examples/bela/FXChaine2.dsp b/dist/examples/bela/FXChaine2.dsp new file mode 100644 index 00000000..4b701c22 --- /dev/null +++ b/dist/examples/bela/FXChaine2.dsp @@ -0,0 +1,145 @@ +import("stdfaust.lib"); + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// A complete Stereo FX chain with: +// CHORUS +// PHASER +// DELAY +// REVERB +// +// Designed to use the Analog Input for parameters controls. +// +// CONTROLES //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ANALOG IN: +// ANALOG 0 : Chorus Depth +// ANALOG 1 : Chorus Delay +// ANALOG 2 : Phaser Dry/Wet +// ANALOG 3 : Phaser Frequency ratio +// ANALOG 4 : Delay Dry/Wet +// ANALOG 5 : Delay Time +// ANALOG 6 : Reverberation Dry/Wet +// ANALOG 7 : Reverberation Room size +// +// Available by OSC : (see BELA console for precise adress) +// Rate : Chorus LFO modulation rate (Hz) +// Deviation : Chorus delay time deviation. +// +// InvertSum : Phaser inversion of phaser in sum. (On/Off) +// VibratoMode : Phaser vibrato Mode. (On/Off) +// Speed : Phaser LFO frequency +// NotchDepth : Phaser LFO depth +// Feedback : Phaser Feedback +// NotchWidth : Phaser Notch Width +// MinNotch1 : Phaser Minimal frequency +// MaxNotch1 : Phaser Maximal Frequency +// +// Damp : Reverberation Damp +// Stereo : Reverberation Stereo Width +// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +process = chorus_stereo(dmax,curdel,rate,sigma,do2,voices) : phaserSt : xdelay : reverb; + +// CHORUS (from SAM demo lib) ////////////////////////////////////////////////////////////////////////////////////////////////////////// +voices = 8; // MUST BE EVEN + +pi = 4.0*atan(1.0); +periodic = 1; + +dmax = 8192; +curdel = dmax * vslider("Delay[BELA: ANALOG_1]", 0.5, 0, 1, 1) : si.smooth(0.999); +rateMax = 7.0; // Hz +rateMin = 0.01; +rateT60 = 0.15661; + +rate = vslider("Rate", 0.5, rateMin, rateMax, 0.0001): si.smooth(ba.tau2pole(rateT60/6.91)); +depth = vslider("Depth [BELA: ANALOG_0]", 0.5, 0, 1, 0.001) : si.smooth(ba.tau2pole(depthT60/6.91)); +// (dept = dry/wet) + +depthT60 = 0.15661; +delayPerVoice = 0.5*curdel/voices; +sigma = delayPerVoice * vslider("Deviation",0.5,0,1,0.001) : si.smooth(0.999); + +do2 = depth; // use when depth=1 means "multivibrato" effect (no original => all are modulated) + +chorus_stereo(dmax,curdel,rate,sigma,do2,voices) = + _,_ <: *(1-do2),*(1-do2),(*(do2),*(do2) <: par(i,voices,voice(i)):>_,_) : ro.interleave(2,2) : +,+; + voice(i) = de.fdelay(dmax,min(dmax,del(i)))/(i+1) + with { + angle(i) = 2*pi*(i/2)/voices + (i%2)*pi/2; + voice(i) = de.fdelay(dmax,min(dmax,del(i))) * cos(angle(i)); + + del(i) = curdel*(i+1)/voices + dev(i); + rates(i) = rate/float(i+1); + dev(i) = sigma * + os.oscp(rates(i),i*2*pi/voices); + }; + +// PHASER (from demo lib.) ///////////////////////////////////////////////////////////////////////////////////////////////////////////// +phaserSt = _,_ <: _, _, phaser2_stereo : dry_wetST(dwPhaz) + with { + + invert = checkbox("InvertSum"); + vibr = checkbox("VibratoMode"); // In this mode you can hear any "Doppler" + + phaser2_stereo = pf.phaser2_stereo(Notches,width,frqmin,fratio,frqmax,speed,mdepth,fb,invert); + + Notches = 4; // Compile-time parameter: 2 is typical for analog phaser stomp-boxes + + speed = hslider("Speed", 0.5, 0, 10, 0.001); + depth = hslider("NotchDepth", 1, 0, 1, 0.001); + fb = hslider("Feedback", 0.7, -0.999, 0.999, 0.001); + + width = hslider("NotchWidth",1000, 10, 5000, 1); + frqmin = hslider("MinNotch1",100, 20, 5000, 1); + frqmax = hslider("MaxNotch1",800, 20, 10000, 1) : max(frqmin); + fratio = hslider("NotchFreqRatio[BELA: ANALOG_3]",1.5, 1.1, 4, 0.001); + dwPhaz = vslider("dryWetPhaser[BELA: ANALOG_2]", 0.5, 0, 1, 0.001); + + mdepth = select2(vibr,depth,2); // Improve "ease of use" + }; + +// DELAY (with feedback and crossfeeback) ////////////////////////////////////////////////////////////////////////////////////////////// +delay = ba.sec2samp(hslider("delay[BELA: ANALOG_5]", 1,0,2,0.001)); +preDelL = delay/2; +delL = delay; +delR = delay; + +crossLF = 1200; + +CrossFeedb = 0.6; +dwDel = vslider("dryWetDelay[BELA: ANALOG_4]", 0.5, 0, 1, 0.001); + +routeur(a,b,c,d) = ((a*CrossFeedb):fi.lowpass(2,crossLF))+c, + ((b*CrossFeedb):fi.lowpass(2,crossLF))+d; + +xdelay = _,_ <: _,_,((de.sdelay(65536, 512,preDelL),_): + (routeur : de.sdelay(65536, 512,delL) ,de.sdelay(65536, 512,delR) ) ~ (_,_)) : dry_wetST(dwDel); + +// REVERB (from freeverb_demo) ///////////////////////////////////////////////////////////////////////////////////////////////////////// +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[BELA: ANALOG_7]", 0.5, 0, 1, 0.001)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo",0.5,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[BELA: ANALOG_6]", 0.2, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wetST(dw,x1,x2,y1,y2) = (wet*y1 + dry*x1),(wet*y2 + dry*x2) + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; diff --git a/dist/examples/bela/Faust-complement.lib b/dist/examples/bela/Faust-complement.lib new file mode 100644 index 00000000..c62211da --- /dev/null +++ b/dist/examples/bela/Faust-complement.lib @@ -0,0 +1,47 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// SCANNER = passing smoothly between 'n' input to 1 output. /////////////////////////////////////// + +// Version for a maximum of 4 inputs : +scanner4(nb, position) = -(_,soustraction) : *(_,coef) : cos : max(0) + with { + coef = 3.14159 * ((nb-1)*0.5); + soustraction = select2(position>0, 0, (position/(nb-1))); + }; + +// Version for more than 4 inputs. +scanner(nb, position) = _ <: (_ , scan) : compare + with { + coef = 3.14159 * ((nb-1)*0.5); + soustraction = select2(position>0, 0, (position/(nb-1))); + + minimum = ((1/(nb-1))*(position-1)); // + maximum = ((1/(nb-1))*(position+1)); // + compare(in, sig) = select2(in>minimum, 0, sig) : select2(in; + latch(S,R) = _~(ba.if(S>0.5,1,_) : ba.if(R>0.5, 0, _)); + }; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Count until a number, then wait until Reset to re-start ///////////////////////////////////////// + +counterUpReset(nb, in, reset) = (in:trig), reset : (routage : memo2,_)~_ + with { + trig = _<:_,mem: >; + memo2(a, b) = (ba.if(b>0.5, 0, _))~(+(a)); + compare(value) = ba.if(value>nb, 1, 0); // :trig; + routage(d,e,f) = e, (f, compare(d) : RSLatch : +(f) <: _,_); + }; diff --git a/dist/examples/bela/GrainGenerator.dsp b/dist/examples/bela/GrainGenerator.dsp new file mode 100644 index 00000000..85043c3f --- /dev/null +++ b/dist/examples/bela/GrainGenerator.dsp @@ -0,0 +1,98 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Grain Generator. +// Another granular synthesis example. +// This one is not finished, but ready for more features and improvements... +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ANALOG IN: +// ANALOG 0 : Population: 0 = almost nothing. 1 = Full grain +// ANALOG 1 : Depth of each grain, in ms. +// ANALOG 2 : Position in the table = delay +// ANALOG 3 : Speed = pitch change of the grains +// ANALOG 4 : Feedback +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +import("all.lib"); + +// FOR 4 grains - MONO + +// UI ////////////////////////////////////////// +popul = 1 - hslider("population[BELA: ANALOG_0]", 1, 0, 1, 0.001); // Coef 1 = maximum; 0 = almost nothing (0.95) +taille = hslider("taille[BELA: ANALOG_1]", 100, 4, 200, 0.001 ); // Size in milliseconds +decal = 1 - hslider("decal[BELA: ANALOG_2]",0,0,1,0.001); // Read position compared to table write position + +speed = hslider("speed[BELA: ANALOG_3]", 1, 0.125, 4, 0.001); + +feedback = hslider("feedback[BELA: ANALOG_4]",0,0,2,0.001); + +freq = 1000/taille; +tmpTaille = taille*ma.SR/ 1000; +clocSize = int(tmpTaille + (tmpTaille*popul*10)); // duration between 2 clicks + +// CLK GENERAL ///////////////////////////////// +// 4 clicks for 4 grains generators. +// (idem clk freq/4 and a counter...) +detect1(x) = select2 (x < 10, 0, 1); +detect2(x) = select2 (x > clocSize*1/3, 0, 1) : select2 (x < (clocSize*1/3)+10, 0, _); +detect3(x) = select2 (x > clocSize*2/3, 0, 1) : select2 (x < (clocSize*2/3)+10, 0, _); +detect4(x) = select2 (x > clocSize-10, 0, 1); +cloc = (%(_,clocSize))~(+(1)) <: (detect1: trig),(detect2: trig),(detect3: trig),(detect4: trig); + +// SIGNAUX Ctrls Player //////////////////////// +trig = _<:_,mem: >; +envelop = *(2*PI):+(PI):cos:*(0.5):+(0.5); + +rampe(f, t) = delta : (+ : select2(t,_,delta<0) : max(0)) ~ _ : raz + with { + raz(x) = select2 (x > 1, x, 0); + delta = sh(f,t)/ma.SR; + sh(x,t) = ba.sAndH(t,x); + }; + +rampe2(speed, t) = delta : (+ : select2(t,_,delta<0) : max(0)) ~ _ + with { + delta = sh(speed,t); + sh(x,t) = ba.sAndH(t,x); + }; + +// RWTable ////////////////////////////////////// +unGrain(input, clk) = (linrwtable(wf , rindex) : *(0.2 * EnvGrain)) + with { + SR = 44100; + buffer_sec = 1; + size = int(SR * buffer_sec); + init = 0.; + + EnvGrain = clk : (rampe(freq) : envelop); + + windex = (%(_,size) ) ~ (+(1)); + posTabl = int(ba.sAndH(clk, windex)); + rindex = %(int(rampe2(speed, clk)) + posTabl + int(size * decal), size); + + wf = size, init, int(windex), input; + }; + +// LINEAR_INTERPOLATION_RWTABLE ////////////////////////////////// +// read rwtable with linear interpolation +// wf : waveform to read (wf is defined by (size_buffer,init, windex, input)) +// x : position to read (0 <= x < size(wf)) and float +// nota: rwtable(size, init, windex, input, rindex) + +linrwtable(wf,x) = linterpolation(y0,y1,d) + with { + x0 = int(x); // + x1 = int(x+1); // + d = x-x0; + y0 = rwtable(wf,x0); // + y1 = rwtable(wf,x1); // + linterpolation(v0,v1,c) = v0*(1-c)+v1*c; + }; + +// FINALISATION ///////////////////////////////////////////////////////////////////////////////////// +routeur(a, b, c, d, e) = a, b, a, c, a, d, a, e; + +processus = _, cloc : routeur : (unGrain, unGrain, unGrain, unGrain) :> fi.dcblockerat(20); +process = _,_: ((+(_,_) :processus) ~(*(feedback))),((+(_,_) :processus) ~(*(feedback))); diff --git a/dist/examples/bela/WaveSynth.dsp b/dist/examples/bela/WaveSynth.dsp new file mode 100644 index 00000000..25be16fb --- /dev/null +++ b/dist/examples/bela/WaveSynth.dsp @@ -0,0 +1,67 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple demo of wavetable synthesis. A LFO modulate the interpolation between 4 tables. +// It's possible to add more tables step. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// +// CC 1 : LFO Depth (wave travel modulation) +// CC 14 : LFO Frequency +// CC 70 : Wave travelling +// +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// GENERAL +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 1, 0.01); + +waveTravel = hslider("waveTravel [midi:ctrl]",0,0,1,0.01); + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +// LFO +lfoDepth = hslider("lfoDepth[midi:ctrl 1]",0,0.,1,0.001):si.smoo; +lfoFreq = hslider("lfoFreq[midi:ctrl 14]",0.1,0.01,10,0.001):si.smoo; +moov = ((os.lf_trianglepos(lfoFreq) * lfoDepth) + waveTravel) : min(1) : max(0); + +volA = hslider("A[midi:ctrl 73]",0.01,0.01,4,0.01); +volD = hslider("D[midi:ctrl 76]",0.6,0.01,8,0.01); +volS = hslider("S[midi:ctrl 77]",0.2,0,1,0.01); +volR = hslider("R[midi:ctrl 72]",0.8,0.01,8,0.01); +envelop = en.adsre(volA,volD,volS,volR,midigate); + +// Out Amplitude +vol = envelop * midigain; + +WF(tablesize, rang) = abs((fmod ((1+(float(ba.time)*rang)/float(tablesize)), 4.0))-2) -1.; + +// 4 WF maxi with this version: +scanner(nb, position) = -(_,soustraction) : *(_,coef) : cos : max(0) +with{ + coef = 3.14159 * ((nb-1)*0.5); + soustraction = select2( position>0, 0, (position/(nb-1)) ); +}; + +wfosc(freq) = (rdtable(tablesize, wt1, faze)*(moov : scanner(4,0)))+(rdtable(tablesize, wt2, faze)*(moov : scanner(4,1))) + + (rdtable(tablesize, wt3, faze)*(moov : scanner(4,2)))+(rdtable(tablesize, wt4, faze)*(moov : scanner(4,3))) +with { + tablesize = 1024; + wt1 = WF(tablesize, 16); + wt2 = WF(tablesize, 8); + wt3 = WF(tablesize, 6); + wt4 = WF(tablesize, 4); + faze = int(os.phasor(tablesize,freq)); +}; + +process = wfosc(gFreq) * vol; diff --git a/dist/examples/bela/WaveSynth_Analog.dsp b/dist/examples/bela/WaveSynth_Analog.dsp new file mode 100644 index 00000000..26fce371 --- /dev/null +++ b/dist/examples/bela/WaveSynth_Analog.dsp @@ -0,0 +1,69 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple demo of wavetable synthesis. A LFO modulate the interpolation between 4 tables. +// It's possible to add more tables step. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_0 : Wave travelling +// ANALOG_1 : LFO Frequency +// ANALOG_2 : LFO Depth (wave travel modulation) +// ANALOG_3 : Release +// +// MIDI: +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// GENERAL +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 1, 0.01); + +waveTravel = hslider("waveTravel[BELA: ANALOG_0]",0,0,1,0.01); + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +// LFO +lfoDepth = hslider("lfoDepth[BELA: ANALOG_2]",0,0.,1,0.001):si.smoo; +lfoFreq = hslider("lfoFreq[BELA: ANALOG_1]",0.1,0.01,10,0.001):si.smoo; +moov = ((os.lf_trianglepos(lfoFreq) * lfoDepth) + waveTravel) : min(1) : max(0); + +volA = hslider("A[midi:ctrl 73]",0.01,0.01,4,0.01); +volD = hslider("D[midi:ctrl 76]",0.6,0.01,8,0.01); +volS = hslider("S[midi:ctrl 77]",0.2,0,1,0.01); +volR = hslider("R[BELA: ANALOG_3]",0.8,0.01,8,0.01); +envelop = en.adsre(volA,volD,volS,volR,midigate); + +// Out amplitude +vol = envelop * midigain; + +WF(tablesize, rang) = abs((fmod((1+(float(ba.time)*rang)/float(tablesize)), 4.0))-2) -1.; + +// 4 WF maxi with this version: +scanner(nb, position) = -(_,soustraction) : *(_,coef) : cos : max(0) + with { + coef = 3.14159 * ((nb-1)*0.5); + soustraction = select2( position>0, 0, (position/(nb-1)) ); + }; + +wfosc(freq) = (rdtable(tablesize, wt1, faze)*(moov : scanner(4,0)))+(rdtable(tablesize, wt2, faze)*(moov : scanner(4,1))) + + (rdtable(tablesize, wt3, faze)*(moov : scanner(4,2)))+(rdtable(tablesize, wt4, faze)*(moov : scanner(4,3))) + with { + tablesize = 1024; + wt1 = WF(tablesize, 16); + wt2 = WF(tablesize, 8); + wt3 = WF(tablesize, 6); + wt4 = WF(tablesize, 4); + faze = int(os.phasor(tablesize,freq)); + }; + +process = wfosc(gFreq) * vol; + diff --git a/dist/examples/bela/WaveSynth_FX.dsp b/dist/examples/bela/WaveSynth_FX.dsp new file mode 100644 index 00000000..4380d055 --- /dev/null +++ b/dist/examples/bela/WaveSynth_FX.dsp @@ -0,0 +1,145 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple demo of wavetable synthesis. A LFO modulate the interpolation between 4 tables. +// It's possible to add more tables step. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// +// CC 1 : LFO Depth (wave travel modulation) +// CC 14 : LFO Frequency +// CC 70 : Wave travelling +// +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// GENERAL +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 1, 0.01); + +waveTravel = hslider("waveTravel [midi:ctrl ]",0,0,1,0.01); + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +// LFO +lfoDepth = hslider("lfoDepth[midi:ctrl 1]",0,0.,1,0.001):si.smoo; +lfoFreq = hslider("lfoFreq[midi:ctrl 14]",0.1,0.01,10,0.001):si.smoo; +moov = ((os.lf_trianglepos(lfoFreq) * lfoDepth) + waveTravel) : min(1) : max(0); + +volA = hslider("A[midi:ctrl 73]",0.01,0.01,4,0.01); +volD = hslider("D[midi:ctrl 76]",0.6,0.01,8,0.01); +volS = hslider("S[midi:ctrl 77]",0.2,0,1,0.01); +volR = hslider("R[midi:ctrl 72]",0.8,0.01,8,0.01); +envelop = en.adsre(volA,volD,volS,volR,midigate); + +// Out Amplitude +vol = envelop * midigain; + +WF(tablesize, rang) = abs((fmod ((1+(float(ba.time)*rang)/float(tablesize)), 4.0 ))-2) -1.; + +// 4 WF maxi with this version: +scanner(nb, position) = -(_,soustraction) : *(_,coef) : cos : max(0) + with { + coef = 3.14159 * ((nb-1)*0.5); + soustraction = select2(position>0, 0, (position/(nb-1))); + }; + +wfosc(freq) = (rdtable(tablesize, wt1, faze)*(moov : scanner(4,0)))+(rdtable(tablesize, wt2, faze)*(moov : scanner(4,1))) + + (rdtable(tablesize, wt3, faze)*(moov : scanner(4,2)))+(rdtable(tablesize, wt4, faze)*(moov : scanner(4,3))) + with { + tablesize = 1024; + wt1 = WF(tablesize, 16); + wt2 = WF(tablesize, 8); + wt3 = WF(tablesize, 6); + wt4 = WF(tablesize, 4); + faze = int(os.phasor(tablesize,freq)); + }; + +//#################################################################################################// +//##################################### EFFECT SECTION ############################################// +//#################################################################################################// +// Simple FX chaine build for a mono synthesizer. +// It control general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// (All are available by OSC) +// +// CC 7 : Volume +// CC 10 : Pan +// +// CC 92 : Distortion Drive +// +// CC 13 : Flanger Delay +// CC 93 : Flanger Dry/Wet +// CC 94 : Flanger Feedback +// +// CC 12 : Reverberation Room size +// CC 91 : Reverberation Dry/Wet +// CC 95 : Reverberation Damp +// CC 90 : Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +volFX = hslider("volume[midi:ctrl 7]",1,0,1,0.001);// Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider("drive[midi:ctrl 92]",0.3,0,1,0.001); + +// Flanger +curdel = hslider("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider("dryWetFlang[midi:ctrl 93]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Pannoramique: +panno = _ : sp.panner(hslider("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[midi:ctrl 12]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[midi:ctrl 91]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effect = _ *(volFX) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +process = wfosc(gFreq) * vol; diff --git a/dist/examples/bela/WaveSynth_FX_Analog.dsp b/dist/examples/bela/WaveSynth_FX_Analog.dsp new file mode 100644 index 00000000..59cae9cb --- /dev/null +++ b/dist/examples/bela/WaveSynth_FX_Analog.dsp @@ -0,0 +1,151 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple demo of wavetable synthesis. A LFO modulate the interpolation between 4 tables. +// It's possible to add more tables step. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_0 : Wave travelling +// ANALOG_1 : LFO Frequency +// ANALOG_2 : LFO Depth (wave travel modulation) +// ANALOG_3 : Release +// +// MIDI: +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// GENERAL +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 1, 0.01); + +waveTravel = hslider("waveTravel[BELA: ANALOG_0]",0,0,1,0.01); + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +gFreq = midifreq * bend; + +// LFO +lfoDepth = hslider("lfoDepth[BELA: ANALOG_2]",0,0.,1,0.001):si.smoo; +lfoFreq = hslider("lfoFreq[BELA: ANALOG_1]",0.1,0.01,10,0.001):si.smoo; +moov = ((os.lf_trianglepos(lfoFreq) * lfoDepth) + waveTravel) : min(1) : max(0); + +volA = hslider("A[midi:ctrl 73]",0.01,0.01,4,0.01); +volD = hslider("D[midi:ctrl 76]",0.6,0.01,8,0.01); +volS = hslider("S[midi:ctrl 77]",0.2,0,1,0.01); +volR = hslider("R[BELA: ANALOG_3]",0.8,0.01,8,0.01); +envelop = en.adsre(volA,volD,volS,volR,midigate); + +// Out amplitude +vol = envelop * midigain; + +WF(tablesize, rang) = abs((fmod ((1+(float(ba.time)*rang)/float(tablesize)), 4.0 ))-2) -1.; + +// 4 WF maxi with this version: +scanner(nb, position) = -(_,soustraction) : *(_,coef) : cos : max(0) + with { + coef = 3.14159 * ((nb-1)*0.5); + soustraction = select2( position>0, 0, (position/(nb-1)) ); + }; + +wfosc(freq) = (rdtable(tablesize, wt1, faze)*(moov : scanner(4,0)))+(rdtable(tablesize, wt2, faze)*(moov : scanner(4,1))) + + (rdtable(tablesize, wt3, faze)*(moov : scanner(4,2)))+(rdtable(tablesize, wt4, faze)*(moov : scanner(4,3))) + with { + tablesize = 1024; + wt1 = WF(tablesize, 16); + wt2 = WF(tablesize, 8); + wt3 = WF(tablesize, 6); + wt4 = WF(tablesize, 4); + faze = int(os.phasor(tablesize,freq)); + }; + +//#################################################################################################// +//##################################### EFFECT SECTION ############################################// +//#################################################################################################// +// +// Simple FX chaine build for a mono synthesizer. +// It control general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +// This version use ANALOG IN to controle some of the parameters. +// Other parameters continue to be available by MIDI or OSC. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_4 : Distortion Drive +// ANALOG_5 : Flanger Dry/Wet +// ANALOG_6 : Reverberation Dry/Wet +// ANALOG_7 : Reverberation Room size +// +// MIDI: +// CC 7 : Volume +// CC 10 : Pan +// +// CC 13 : Flanger Delay +// CC 13 : Flanger Delay +// CC 94 : Flanger Feedback +// +// CC 95 : Reverberation Damp +// CC 90 : Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +volFX = hslider("volume[midi:ctrl 7]",1,0,1,0.001);// Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider("drive[BELA: ANALOG_4]",0.3,0,1,0.001); + +// Flanger +curdel = hslider("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider("dryWetFlang[BELA: ANALOG_5]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Panoramic: +panno = _ : sp.panner(hslider("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[BELA: ANALOG_7]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[BELA: ANALOG_6]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effect = _ *(volFX) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +process = wfosc(gFreq) * vol; diff --git a/dist/examples/bela/crossDelay2.dsp b/dist/examples/bela/crossDelay2.dsp new file mode 100644 index 00000000..46fa2107 --- /dev/null +++ b/dist/examples/bela/crossDelay2.dsp @@ -0,0 +1,51 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Stereo Delay with feedback and crossfeedback (L to R and R to L feedback). +// And pitch shifting on feedback. +// A pre-delay without feedback is added for a wider stereo effect. +// +// Designed to use the Analog Input for parameters controls. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ANALOG IN: +// ANALOG 0 : Pre-Delay L +// ANALOG 1 : Pre-Delay R +// ANALOG 2 : Delay L +// ANALOG 3 : Delay R +// ANALOG 4 : Cross feedback +// ANALOG 5 : Feedback +// ANALOG 6 : Pitchshifter L +// ANALOG 7 : Pitchshifter R +// +// Available by OSC : (see BELA console for precise adress) +// Feedback filter: +// crossLF : Crossfeedback Lowpass +// crossHF : Crossfeedback Highpass +// feedbLF : Feedback Lowpass +// feedbHF : Feedback Highpass +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +preDelL = ba.sec2samp(hslider("preDelL[BELA: ANALOG_0]", 1,0,2,0.001)):si.smoo; +preDelR = ba.sec2samp(hslider("preDelR[BELA: ANALOG_1]", 1,0,2,0.001)):si.smoo; +delL = ba.sec2samp(hslider("delL[BELA: ANALOG_2]", 1,0,2,0.001)):si.smoo; +delR = ba.sec2samp(hslider("delR[BELA: ANALOG_3]", 1,0,2,0.001)):si.smoo; + +crossLF = hslider("crossLF", 12000, 20, 20000, 0.001); +crossHF = hslider("crossHF", 60, 20, 20000, 0.001); +feedbLF = hslider("feedbLF", 12000, 20, 20000, 0.001); +feedbHF = hslider("feedbHF", 60, 20, 20000, 0.001); + +CrossFeedb = hslider("CrossFeedb[BELA: ANALOG_4]", 0.0, 0., 1, 0.001):si.smoo; +feedback = hslider("feedback[BELA: ANALOG_5]", 0.0, 0., 1, 0.001):si.smoo; + +pitchL = hslider("shiftL[BELA: ANALOG_6]", 0,-12,12,0.001):si.smoo; +pitchR = hslider("shiftR[BELA: ANALOG_7]", 0,-12,12,0.001):si.smoo; + +routeur(a,b,c,d) = ((a*CrossFeedb):fi.lowpass(2,crossLF):fi.highpass(2,crossHF))+((b*feedback):fi.lowpass(2,feedbLF):fi.highpass(2,feedbHF))+c, + ((b*CrossFeedb):fi.lowpass(2,crossLF):fi.highpass(2,crossHF))+((a*feedback):fi.lowpass(2,feedbLF):fi.highpass(2,feedbHF))+d; + +process = (de.sdelay(65536, 512,preDelL),de.sdelay(65536, 512,preDelR)):(routeur : de.sdelay(65536, 512,delL), de.sdelay(65536, 512,delR))~(ef.transpose(512, 256, pitchL), ef.transpose(512, 256, pitchR)); diff --git a/dist/examples/bela/granulator.dsp b/dist/examples/bela/granulator.dsp new file mode 100644 index 00000000..80cfe173 --- /dev/null +++ b/dist/examples/bela/granulator.dsp @@ -0,0 +1,69 @@ +// FROM FAUST DEMO +// Designed to use the Analog Input for parameter controls. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ANALOG IN: +// ANALOG 0 : Grain Size +// ANALOG 1 : Speed +// ANALOG 2 : Probability +// (others analog inputs are not used) +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +process = vgroup("Granulator", environment { + declare name "Granulator"; + declare author "Adapted from sfIter by Christophe Lebreton"; + + /* =========== DESCRIPTION ============= + + - The granulator takes very small parts of a sound, called GRAINS, and plays them at a varying speed + - Front = Medium size grains + - Back = short grains + - Left Slow rhythm + - Right = Fast rhythm + - Bottom = Regular occurrences + - Head = Irregular occurrences + */ + + import("stdfaust.lib"); + + process = hgroup("Granulator", *(excitation : ampf)); + + excitation = noiseburst(gate,P) * (gain); + ampf = an.amp_follower_ud(duree_env,duree_env); + + //----------------------- NOISEBURST ------------------------- + + noiseburst(gate,P) = no.noise : *(gate : trigger(P)) + with { + upfront(x) = (x-x') > 0; + decay(n,x) = x - (x>0)/n; + release(n) = + ~ decay(n); + trigger(n) = upfront : release(n) : > (0.0); + }; + + //------------------------------------------------------------- + + P = freq; // fundamental period in samples + freq = hslider("[1]GrainSize[BELA: ANALOG_0]", 200,5,2205,1); + // the frequency gives the white noise band width + Pmax = 4096; // maximum P (for de.delay-line allocation) + + // PHASOR_BIN ////////////////////////////// + phasor_bin(init) = (+(float(speed)/float(ma.SR)) : fmod(_,1.0)) ~ *(init); + gate = phasor_bin(1) :-(0.001):pulsar; + gain = 1; + + // PULSAR ////////////////////////////// + // Pulsar allows to create a more or less random 'pulse'(proba). + + pulsar = _<:((_<(ratio_env)):@(100))*(proba>(_,abs(no.noise):ba.latch)); + speed = hslider ("[2]Speed[BELA: ANALOG_1]", 10,1,20,0.0001):fi.lowpass(1,1); + + ratio_env = 0.5; + fade = (0.5); // min > 0 to avoid division by 0 + + proba = hslider ("[3]Probability[BELA: ANALOG_2]", 70,50,100,1) * (0.01):fi.lowpass(1,1); + duree_env = 1/(speed: / (ratio_env*(0.25)*fade)); +}.process); diff --git a/dist/examples/bela/repeater.dsp b/dist/examples/bela/repeater.dsp new file mode 100644 index 00000000..4968b821 --- /dev/null +++ b/dist/examples/bela/repeater.dsp @@ -0,0 +1,74 @@ +// REPEATER: +// Freeze and repeat a small part of input signal 'n' time' +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ANALOG IN: +// ANALOG 0 : Duration (ms) between 2 repeat series (500 to 2000 ms) +// ANALOG 1 : Duration of one repeat (2 to 200 ms) +// ANALOG 2 : Number of repeat +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +import("all.lib"); + +process = _, _ , (pathClock : compteurUpReset2(nbRepet): rampePlayer, _) : routageIO : rec_play_table , rec_play_table; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// General loop duration +MasterTaille =hslider("MasterTaille[BELA: ANALOG_0]", 500, 200, 2000,0.01); +MasterClocSize = int(MasterTaille*ma.SR/ 1000); + +// Depth of repeat fragments +taille = hslider("taille[BELA: ANALOG_1]", 50, 2, 200,0.01); +clocSize = int(taille*ma.SR/ 1000); + +// Number of repeat fragments +nbRepet = int (hslider("nbRepet[BELA: ANALOG_2]",4,1,16,1) ); + +trig = _<:_,mem: >; + +routageIO (a, b, c, d) = a, c, d, b, c, d; +rec_play_table(input, inReadIndex, reset) = (rwtable(wf , rindex):fi.dcblockerat(20)) + with { + SR = 44100; + buffer_sec = 2; + size = int(SR * buffer_sec); + init = 0.; + + windex = (%(_,size))~(+(1):*(1-reset)); + rindex = (%( int(inReadIndex),size)); + + wf = size, init, int(windex), input; + }; + +MasterClock = (%(_,MasterClocSize))~(+(1)) : detect + with { + detect(x) = select2 (x < 100, 0, 1); + }; + +SlaveClock(reset) = (%(_,clocSize))~(+(1):*(1-reset)); +detect1(x) = select2 (x < clocSize/2, 0, 1); + +pathClock = MasterClock <: trig, _ : SlaveClock, _ : detect1, _; + +compteurUpReset2(nb, in, reset) = ((in:trig), reset : (routage : memo2)~_), reset + with { + memo2(a, b) = (ba.if(b>0.5, 0, _) )~(+(a)); + compare(value) = ba.if(value>nb, 1, 0); // :trig; + routage(d,e,f) = e, (f, compare(d) : RSLatch <: +(f)); + }; + +RSLatch(R, S) = latch(S,R) + with { + trig = _<:_,mem: >; + latch(S,R) = _~(ba.if(R>0.5, 0, _) : ba.if(S>0.5,1,_)); + }; + +rampePlayer(reset) = rampe + with { + rst = reset : trig; + rampe = _~(+(1):*(1-rst)); + toZero = _ : ba.if(reset<0.5,0,_); + }; diff --git a/dist/examples/bela/simpleFX.dsp b/dist/examples/bela/simpleFX.dsp new file mode 100644 index 00000000..677491f7 --- /dev/null +++ b/dist/examples/bela/simpleFX.dsp @@ -0,0 +1,80 @@ +import("stdfaust.lib"); +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple FX chaine build for a mono synthesizer. +// It controle general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// (All are available by OSC) +// +// CC 7 : Volume +// CC 10 : Pan +// +// CC 92 : Distortion Drive +// +// CC 13 : Flanger Delay +// CC 93 : Flanger Dry/Wet +// CC 94 : Flanger Feedback +// +// CC 12 : Reverberation Room size +// CC 91 : Reverberation Dry/Wet +// CC 95 : Reverberation Damp +// CC 90 : Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +vol = hslider ("volume[midi:ctrl 7]",1,0,1,0.001);// Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider ("drive[midi:ctrl 92]",0.3,0,1,0.001); + +// Flanger +curdel = hslider ("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider ("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider ("dryWetFlang[midi:ctrl 93]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Panoramique: +panno = _ : sp.panner(hslider ("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[midi:ctrl 12]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[midi:ctrl 91]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effets = _ *(vol) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +process = effets; diff --git a/dist/examples/bela/simpleFX_Analog.dsp b/dist/examples/bela/simpleFX_Analog.dsp new file mode 100644 index 00000000..dbb9010a --- /dev/null +++ b/dist/examples/bela/simpleFX_Analog.dsp @@ -0,0 +1,84 @@ +import("stdfaust.lib"); +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Simple FX chain build for a mono synthesizer. +// It control general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +// This version use ANALOG IN to controle some of the parameters. +// Other parameters continue to be available by MIDI or OSC. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_4 : Distortion Drive +// ANALOG_5 : Flanger Dry/Wet +// ANALOG_6 : Reverberation Dry/Wet +// ANALOG_7 : Reverberation Room size +// +// MIDI: +// CC 7 : Volume +// CC 10 : Pan +// +// CC 13 : Flanger Delay +// CC 13 : Flanger Delay +// CC 94 : Flanger Feedback +// +// CC 95 : Reverberation Damp +// CC 90: Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +vol = hslider("volume[midi:ctrl 7]",1,0,1,0.001);// Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider ("drive[BELA: ANALOG_4]",0.3,0,1,0.001); + +// Flanger +curdel = hslider("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider("dryWetFlang[BELA: ANALOG_5]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Panoramic: +panno = _ : sp.panner(hslider ("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[BELA: ANALOG_7]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[BELA: ANALOG_6]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effets = _ *(vol) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +process = effets; diff --git a/dist/examples/bela/simpleSynth.dsp b/dist/examples/bela/simpleSynth.dsp new file mode 100644 index 00000000..e6932e0c --- /dev/null +++ b/dist/examples/bela/simpleSynth.dsp @@ -0,0 +1,79 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// A very simple subtractive synthesizer with 1 VCO 1 VCF. +// The VCO Waveform is variable between Saw and Square +// The frequency is modulated by an LFO +// The envelope control volum and filter frequency +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// +// CC 70 : waveform (Saw to square) +// CC 71 : Filter resonance (Q) +// CC 74 : Filter Cutoff frequency +// CC 79 : Filter keyboard tracking (0 to X2, default 1) +// CC 75 : Filter Envelope Modulation +// +// Envelope +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +// CC 78 : LFO frequency (0.001Hz to 10Hz) +// CC 1 : LFO Amplitude (Modulation) +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// HUI ////////////////////////////////////////////////// +// Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 0.5, 0.01);// MIDI KEYBOARD + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +// VCO +wfFade = hslider("waveform[midi:ctrl 70]",0.5,0,1,0.001):si.smoo; + +// VCF +res = hslider("resonnance[midi:ctrl 71]",0.5,0,1,0.001):si.smoo; +fr = hslider("fc[midi:ctrl 74]", 15, 15, 12000, 0.001):si.smoo; +track = hslider("tracking[midi:ctrl 79]", 1, 0, 2, 0.001); +envMod = hslider("envMod[midi:ctrl 75]",50,0,100,0.01):si.smoo; + +// ENV +att = 0.01 * (hslider("attack[midi:ctrl 73]",0.1,0.1,400,0.001)); +dec = 0.01 * (hslider("decay[midi:ctrl 76]",60,0.1,400,0.001)); +sust = hslider("sustain[midi:ctrl 77]",0.1,0,1,0.001); +rel = 0.01 * (hslider("release[midi:ctrl 72]",100,0.1,400,0.001)); + +// LFO +lfoFreq = hslider("lfoFreq[midi:ctrl 78]",6,0.001,10,0.001):si.smoo; +modwheel = hslider("modwheel[midi:ctrl 1]",0,0,0.5,0.001):si.smoo; + +// PROCESS ///////////////////////////////////////////// +allfreq = (midifreq * bend) + LFO; +// VCF +cutoff = ((allfreq * track) + fr + (envMod * midigain * env)) : min(ma.SR/8); + +// VCO +oscillo(f) = (os.sawtooth(f)*(1-wfFade))+(os.square(f)*wfFade); + +// VCA +volume = midigain * env; + +// Enveloppe +env = en.adsre(att,dec,sust,rel,midigate); + +// LFO +LFO = os.lf_triangle(lfoFreq)*modwheel*10; + +// SYNTH //////////////////////////////////////////////// +synth = (oscillo(allfreq) :ve.moog_vcf(res,cutoff)) * volume; + +// PROCESS ///////////////////////////////////////////// +process = synth; diff --git a/dist/examples/bela/simpleSynth_Analog.dsp b/dist/examples/bela/simpleSynth_Analog.dsp new file mode 100644 index 00000000..3b9bb070 --- /dev/null +++ b/dist/examples/bela/simpleSynth_Analog.dsp @@ -0,0 +1,81 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// A very simple subtractive synthesizer with 1 VCO 1 VCF. +// The VCO Waveform is variable between Saw and Square +// The frequency is modulated by an LFO +// The envelope control volum and filter frequency +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_0 : waveform (Saw to square) +// ANALOG_1 : Filter Cutoff frequency +// ANALOG_2 : Filter resonance (Q) +// ANALOG_3 : Filter Envelope Modulation +// +// MIDI: +// CC 79 : Filter keyboard tracking (0 to X2, default 1) +// +// Envelope +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +// CC 78 : LFO frequency (0.001Hz to 10Hz) +// CC 1 : LFO Amplitude (Modulation) +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// HUI ////////////////////////////////////////////////// +// Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 0.5, 0.01);// MIDI KEYBOARD + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +// VCO +wfFade = hslider("waveform[BELA: ANALOG_0]",0.5,0,1,0.001):si.smoo; + +// VCF +res = hslider("resonnance[BELA: ANALOG_2]",0.5,0,1,0.001):si.smoo; +fr = hslider("fc[BELA: ANALOG_1]", 15, 15, 12000, 0.001):si.smoo; +track = hslider("tracking[midi:ctrl 79]", 1, 0, 2, 0.001); +envMod = hslider("envMod[BELA: ANALOG_3]",50,0,100,0.01):si.smoo; + +// ENV +att = 0.01 * (hslider("attack[midi:ctrl 73]",0.1,0.1,400,0.001)); +dec = 0.01 * (hslider("decay[midi:ctrl 76]",60,0.1,400,0.001)); +sust = hslider("sustain[midi:ctrl 77]",0.2,0,1,0.001); +rel = 0.01 * (hslider("release[midi:ctrl 72]",100,0.1,400,0.001)); + +// LFO +lfoFreq = hslider("lfoFreq[midi:ctrl 78]",6,0.001,10,0.001):si.smoo; +modwheel = hslider("modwheel[midi:ctrl 1]",0,0,0.5,0.001):si.smoo; + +// PROCESS ///////////////////////////////////////////// +allfreq = (midifreq * bend) + LFO; +// VCF +cutoff = ((allfreq * track) + fr + (envMod * midigain * env)) : min(ma.SR/8); + +// VCO +oscillo(f) = (os.sawtooth(f)*(1-wfFade))+(os.square(f)*wfFade); + +// VCA +volume = midigain * env; + +// Enveloppe +env = en.adsre(att,dec,sust,rel,midigate); + +// LFO +LFO = os.lf_triangle(lfoFreq)*modwheel*10; + +// SYNTH //////////////////////////////////////////////// +synth = (oscillo(allfreq) :ve.moog_vcf(res,cutoff)) * volume; + +// PROCESS ///////////////////////////////////////////// +process = synth; diff --git a/dist/examples/bela/simpleSynth_FX.dsp b/dist/examples/bela/simpleSynth_FX.dsp new file mode 100644 index 00000000..2e83ff28 --- /dev/null +++ b/dist/examples/bela/simpleSynth_FX.dsp @@ -0,0 +1,158 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// A very simple subtractive synthesizer with 1 VCO 1 VCF. +// The VCO Waveform is variable between Saw and Square +// The frequency is modulated by an LFO +// The envelope control volum and filter frequency +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// +// CC 70 : waveform (Saw to square) +// CC 71 : Filter resonance (Q) +// CC 74 : Filter Cutoff frequency +// CC 79 : Filter keyboard tracking (0 to X2, default 1) +// CC 75 : Filter Envelope Modulation +// +// Envelope +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +// CC 78 : LFO frequency (0.001Hz to 10Hz) +// CC 1 : LFO Amplitude (Modulation) +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// HUI ////////////////////////////////////////////////// +// Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 0.5, 0.01);// MIDI KEYBOARD + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +// VCO +wfFade = hslider("waveform[midi:ctrl 70]",0.5,0,1,0.001):si.smoo; + +// VCF +res = hslider("resonnance[midi:ctrl 71]",0.5,0,1,0.001):si.smoo; +fr = hslider("fc[midi:ctrl 74]", 15, 15, 12000, 0.001):si.smoo; +track = hslider("tracking[midi:ctrl 79]", 1, 0, 2, 0.001); +envMod = hslider("envMod[midi:ctrl 75]",50,0,100,0.01):si.smoo; + +// ENV +att = 0.01 * (hslider("attack[midi:ctrl 73]",0.1,0.1,400,0.001)); +dec = 0.01 * (hslider("decay[midi:ctrl 76]",60,0.1,400,0.001)); +sust = hslider("sustain[midi:ctrl 77]",0.1,0,1,0.001); +rel = 0.01 * (hslider("release[midi:ctrl 72]",100,0.1,400,0.001)); + +// LFO +lfoFreq = hslider("lfoFreq[midi:ctrl 78]",6,0.001,10,0.001):si.smoo; +modwheel = hslider("modwheel[midi:ctrl 1]",0,0,0.5,0.001):si.smoo; + +// PROCESS ///////////////////////////////////////////// +allfreq = (midifreq * bend) + LFO; + +// VCF +cutoff = ((allfreq * track) + fr + (envMod * midigain * env)) : min(ma.SR/8); + +// VCO +oscillo(f) = (os.sawtooth(f)*(1-wfFade))+(os.square(f)*wfFade); + +// VCA +volume = midigain * env; + +// Enveloppe +env = en.adsre(att,dec,sust,rel,midigate); + +// LFO +LFO = os.lf_triangle(lfoFreq)*modwheel*10; + +// SYNTH //////////////////////////////////////////////// +synth = (oscillo(allfreq) :ve.moog_vcf(res,cutoff)) * volume; + +//#################################################################################################// +//##################################### EFFECT SECTION ############################################// +//#################################################################################################// +// Simple FX chaine build for a mono synthesizer. +// It controle general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// MIDI IMPLEMENTATION: +// (All are available by OSC) +// +// CC 7 : Volume +// CC 10 : Pan +// +// CC 92 : Distortion Drive +// +// CC 13 : Flanger Delay +// CC 93 : Flanger Dry/Wet +// CC 94 : Flanger Feedback +// +// CC 12 : Reverberation Room size +// CC 91 : Reverberation Dry/Wet +// CC 95 : Reverberation Damp +// CC 90 : Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +volFX = hslider("volume[midi:ctrl 7]",1,0,1,0.001);// Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider("drive[midi:ctrl 92]",0.3,0,1,0.001); + +// Flanger +curdel = hslider("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider("dryWetFlang[midi:ctrl 93]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Pannoramique: +panno = _ : sp.panner(hslider("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[midi:ctrl 12]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[midi:ctrl 91]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effect = _ *(volFX) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +// PROCESS ///////////////////////////////////////////// +process = synth; diff --git a/dist/examples/bela/simpleSynth_FX_Analog.dsp b/dist/examples/bela/simpleSynth_FX_Analog.dsp new file mode 100644 index 00000000..3ccbfffe --- /dev/null +++ b/dist/examples/bela/simpleSynth_FX_Analog.dsp @@ -0,0 +1,165 @@ +import("stdfaust.lib"); + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// A very simple subtractive synthesizer with 1 VCO 1 VCF. +// The VCO Waveform is variable between Saw and Square +// The frequency is modulated by an LFO +// The envelope control volum and filter frequency +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_0 : waveform (Saw to square) +// ANALOG_1 : Filter Cutoff frequency +// ANALOG_2 : Filter resonance (Q) +// ANALOG_3 : Filter Envelope Modulation +// +// MIDI: +// CC 79 : Filter keyboard tracking (0 to X2, default 1) +// +// Envelope +// CC 73 : Attack +// CC 76 : Decay +// CC 77 : Sustain +// CC 72 : Release +// +// CC 78 : LFO frequency (0.001Hz to 10Hz) +// CC 1 : LFO Amplitude (Modulation) +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// HUI ////////////////////////////////////////////////// +// Keyboard +midigate = button("gate"); +midifreq = nentry("freq[unit:Hz]", 440, 20, 20000, 1); +midigain = nentry("gain", 0.5, 0, 0.5, 0.01);// MIDI KEYBOARD + +// pitchwheel +bend = ba.semi2ratio(hslider("bend [midi:pitchwheel]",0,-2,2,0.01)); + +// VCO +wfFade = hslider("waveform[BELA: ANALOG_0]",0.5,0,1,0.001):si.smoo; + +// VCF +res = hslider("resonnance[BELA: ANALOG_2]",0.5,0,1,0.001):si.smoo; +fr = hslider("fc[BELA: ANALOG_1]", 15, 15, 12000, 0.001):si.smoo; +track = hslider("tracking[midi:ctrl 79]", 1, 0, 2, 0.001); +envMod = hslider("envMod[BELA: ANALOG_3]",50,0,100,0.01):si.smoo; + +// ENV +att = 0.01 * (hslider("attack[midi:ctrl 73]",0.1,0.1,400,0.001)); +dec = 0.01 * (hslider("decay[midi:ctrl 76]",60,0.1,400,0.001)); +sust = hslider ("sustain[midi:ctrl 77]",0.2,0,1,0.001); +rel = 0.01 * (hslider("release[midi:ctrl 72]",100,0.1,400,0.001)); + +// LFO +lfoFreq = hslider("lfoFreq[midi:ctrl 78]",6,0.001,10,0.001):si.smoo; +modwheel = hslider("modwheel[midi:ctrl 1]",0,0,0.5,0.001):si.smoo; + +// PROCESS ///////////////////////////////////////////// +allfreq = (midifreq * bend) + LFO; +// VCF +cutoff = ((allfreq * track) + fr + (envMod * midigain * env)) : min(ma.SR/8); + +// VCO +oscillo(f) = (os.sawtooth(f)*(1-wfFade))+(os.square(f)*wfFade); + +// VCA +volume = midigain * env; + +// Enveloppe +env = en.adsre(att,dec,sust,rel,midigate); + +// LFO +LFO = os.lf_triangle(lfoFreq)*modwheel*10; + +// SYNTH //////////////////////////////////////////////// +synth = (oscillo(allfreq) :ve.moog_vcf(res,cutoff)) * volume; + +//#################################################################################################// +//##################################### EFFECT SECTION ############################################// +//#################################################################################################// +// +// Simple FX chaine build for a mono synthesizer. +// It controle general volume and pan. +// FX Chaine is: +// Drive +// Flanger +// Reverberation +// +// This version use ANALOG IN to controle some of the parameters. +// Other parameters continue to be available by MIDI or OSC. +// +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ANALOG IMPLEMENTATION: +// +// ANALOG_4 : Distortion Drive +// ANALOG_5 : Flanger Dry/Wet +// ANALOG_6 : Reverberation Dry/Wet +// ANALOG_7 : Reverberation Room size +// +// MIDI: +// CC 7 : Volume +// CC 10 : Pan +// +// CC 13 : Flanger Delay +// CC 13 : Flanger Delay +// CC 94 : Flanger Feedback +// +// CC 95 : Reverberation Damp +// CC 90 : Reverberation Stereo Width +// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +// VOLUME: +volFX = hslider("volume[midi:ctrl 7]",1,0,1,0.001);// Should be 7 according to MIDI CC norm. + +// EFFECTS ///////////////////////////////////////////// +drive = hslider("drive[BELA: ANALOG_4]",0.3,0,1,0.001); + + +// Flanger +curdel = hslider("flangDel[midi:ctrl 13]",4,0.001,10,0.001); +fb = hslider("flangFeedback[midi:ctrl 94]",0.7,0,1,0.001); +fldw = hslider("dryWetFlang[BELA: ANALOG_5]",0.5,0,1,0.001); +flanger = efx + with { + fldel = (curdel + (os.lf_triangle(1) * 2) ) : min(10); + efx = _ <: _, pf.flanger_mono(10,fldel,1,fb,0) : dry_wet(fldw); + }; + +// Pannoramique: +panno = _ : sp.panner(hslider("pan[midi:ctrl 10]",0.5,0,1,0.001)) : _,_; + +// REVERB (from freeverb_demo) +reverb = _,_ <: (*(g)*fixedgain,*(g)*fixedgain : + re.stereo_freeverb(combfeed, allpassfeed, damping, spatSpread)), + *(1-g), *(1-g) :> _,_ + with { + scaleroom = 0.28; + offsetroom = 0.7; + allpassfeed = 0.5; + scaledamp = 0.4; + fixedgain = 0.1; + origSR = 44100; + + damping = vslider("Damp[midi:ctrl 95]",0.5, 0, 1, 0.025)*scaledamp*origSR/ma.SR; + combfeed = vslider("RoomSize[BELA: ANALOG_7]", 0.7, 0, 1, 0.025)*scaleroom*origSR/ma.SR + offsetroom; + spatSpread = vslider("Stereo[midi:ctrl 90]",0.6,0,1,0.01)*46*ma.SR/origSR; + g = vslider("dryWetReverb[BELA: ANALOG_6]", 0.4, 0, 1, 0.001); + // (g = Dry/Wet) + }; + +// Dry-Wet (from C. LEBRETON) +dry_wet(dw,x,y) = wet*y + dry*x + with { + wet = 0.5*(dw+1.0); + dry = 1.0-wet; + }; + +// ALL +effect = _ *(volFX) : ef.cubicnl_nodc(drive, 0.1) : flanger : panno : reverb; + +// PROCESS ///////////////////////////////////////////// +process = synth; diff --git a/dist/examples/delayEcho/echo.dsp b/dist/examples/delayEcho/echo.dsp new file mode 100644 index 00000000..760b458d --- /dev/null +++ b/dist/examples/delayEcho/echo.dsp @@ -0,0 +1,15 @@ +// WARNING: This a "legacy example based on a deprecated library". Check misceffects.lib +// for more accurate examples of echo functions + +declare name "echo"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; +//----------------------------------------------- +// A Simple Echo +//----------------------------------------------- + +import("stdfaust.lib"); + +process = vgroup("echo-simple", ef.echo1s); diff --git a/dist/examples/delayEcho/quadEcho.dsp b/dist/examples/delayEcho/quadEcho.dsp new file mode 100644 index 00000000..afbbdc53 --- /dev/null +++ b/dist/examples/delayEcho/quadEcho.dsp @@ -0,0 +1,21 @@ +// WARNING: This a "legacy example based on a deprecated library". Check misceffects.lib +// for more accurate examples of echo functions + +declare name "quadEcho"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2007"; + +//----------------------------------------------- +// A 1 second quadriphonic Echo +//----------------------------------------------- + +import("stdfaust.lib"); + +process = vgroup("stereo echo", multi(ef.echo1s, 4)) + with{ + multi(f,1) = f; + multi(f,n) = f,multi(f,n-1); + }; + diff --git a/dist/examples/delayEcho/smoothDelay.dsp b/dist/examples/delayEcho/smoothDelay.dsp new file mode 100644 index 00000000..90b74727 --- /dev/null +++ b/dist/examples/delayEcho/smoothDelay.dsp @@ -0,0 +1,27 @@ +declare name "smoothDelay"; +declare author "Yann Orlarey"; +declare copyright "Grame"; +declare version "1.0"; +declare license "STK-4.3"; + +//--------------------------process---------------------------- +// +// A stereo smooth delay with a feedback control +// +// This example shows how to use sdelay, a delay that doesn't +// click and doesn't transpose when the delay time is changed +//------------------------------------------------------------- + +import("stdfaust.lib"); + +process = par(i, 2, voice) + with + { + voice = (+ : de.sdelay(N, interp, dtime)) ~ *(fback); + N = int(2^19); + interp = hslider("interpolation[unit:ms][style:knob]",10,1,100,0.1)*ma.SR/1000.0; + dtime = hslider("delay[unit:ms][style:knob]", 0, 0, 5000, 0.1)*ma.SR/1000.0; + fback = hslider("feedback[style:knob]",0,0,100,0.1)/100.0; + }; + + diff --git a/dist/examples/delayEcho/stereoEcho.dsp b/dist/examples/delayEcho/stereoEcho.dsp new file mode 100644 index 00000000..d57d7e81 --- /dev/null +++ b/dist/examples/delayEcho/stereoEcho.dsp @@ -0,0 +1,16 @@ +// WARNING: This a "legacy example based on a deprecated library". Check misceffects.lib +// for more accurate examples of echo functions + +declare name "stereoEcho"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2007"; + +//----------------------------------------------- +// A 1 second Stereo Echo +//----------------------------------------------- + +import("stdfaust.lib"); + +process = vgroup("stereo echo", (ef.echo1s, ef.echo1s)); diff --git a/dist/examples/delayEcho/tapiir.dsp b/dist/examples/delayEcho/tapiir.dsp new file mode 100644 index 00000000..e4ead082 --- /dev/null +++ b/dist/examples/delayEcho/tapiir.dsp @@ -0,0 +1,44 @@ +declare name "tapiir"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//====================================================== +// +// TAPIIR +// (from Maarten de Boer's Tapiir) +// +//====================================================== + +import("stdfaust.lib"); + +dsize = 524288; + +// user interface +//--------------- +tap(n) = vslider("tap %n", 0,0,1,0.1); +in(n) = vslider("input %n", 1,0,1,0.1); +gain = vslider("gain", 1,0,1,0.1); +del = vslider("delay (sec)", 0, 0, 5, 0.01) * ma.SR; + +// mixer and matrix +//----------------------------------------------------------- +mixer(taps,lines) = par(i,taps,*(tap(i))), par(i,lines,*(in(i))) :> *(gain); + +matrix(taps,lines) = (si.bus(lines+taps) + <: tgroup("", + par(i, taps, hgroup("Tap %i", mixer(taps,lines) : de.delay(dsize,del)))) + ) ~ si.bus(taps); + +// tapiir +//-------- +tapiir(taps,lines) = vgroup("Tapiir", + si.bus(lines) + <: (matrix(taps,lines), si.bus(lines)) + <: vgroup( "outputs", par( i, lines, hgroup("output %i", mixer(taps,lines)) ) ) + ); + +process = tapiir(6,2); + + diff --git a/dist/examples/dynamic/compressor.dsp b/dist/examples/dynamic/compressor.dsp new file mode 100644 index 00000000..545eca27 --- /dev/null +++ b/dist/examples/dynamic/compressor.dsp @@ -0,0 +1,8 @@ +declare name "compressor"; +declare version "0.0"; +declare author "JOS, revised by RM"; +declare description "Compressor demo application"; + +import("stdfaust.lib"); + +process = dm.compressor_demo; diff --git a/dist/examples/dynamic/distortion.dsp b/dist/examples/dynamic/distortion.dsp new file mode 100644 index 00000000..24852baf --- /dev/null +++ b/dist/examples/dynamic/distortion.dsp @@ -0,0 +1,8 @@ +declare name "distortion"; +declare version "0.0"; +declare author "JOS, revised by RM"; +declare description "Distortion demo application."; + +import("stdfaust.lib"); + +process = dm.cubicnl_demo; diff --git a/dist/examples/dynamic/gateCompressor.dsp b/dist/examples/dynamic/gateCompressor.dsp new file mode 100644 index 00000000..40382798 --- /dev/null +++ b/dist/examples/dynamic/gateCompressor.dsp @@ -0,0 +1,12 @@ +declare name "gateCompressor"; + +import("stdfaust.lib"); + +process = +// ol.sawtooth_demo <: +// el.gate_demo : ef.compressor_demo :> fi.spectral_level_demo <: _,_; + vgroup("[1]", dm.sawtooth_demo) <: + vgroup("[2]", dm.gate_demo) : + vgroup("[3]", dm.compressor_demo) :> + vgroup("[4]", dm.spectral_level_demo) <: + _,_; diff --git a/dist/examples/dynamic/noiseGate.dsp b/dist/examples/dynamic/noiseGate.dsp new file mode 100644 index 00000000..8d76d5ac --- /dev/null +++ b/dist/examples/dynamic/noiseGate.dsp @@ -0,0 +1,8 @@ +declare name "noiseGate"; +declare version "0.0"; +declare author "JOS, revised by RM"; +declare description "Gate demo application."; + +import("stdfaust.lib"); + +process = dm.gate_demo; diff --git a/dist/examples/dynamic/volume.dsp b/dist/examples/dynamic/volume.dsp new file mode 100644 index 00000000..c8d986e5 --- /dev/null +++ b/dist/examples/dynamic/volume.dsp @@ -0,0 +1,15 @@ +declare name "volume"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//----------------------------------------------- +// Volume control in dB +//----------------------------------------------- + +import("stdfaust.lib"); + +gain = vslider("[1]", 0, -70, +4, 0.1) : ba.db2linear : si.smoo; + +process = *(gain); diff --git a/dist/examples/fft/fft_bandpass.dsp b/dist/examples/fft/fft_bandpass.dsp new file mode 100644 index 00000000..c7d8d194 --- /dev/null +++ b/dist/examples/fft/fft_bandpass.dsp @@ -0,0 +1,11 @@ +import("stdfaust.lib"); +fftSize = hslider("fftSize", 1024, 2, 16384, 1); // global variable set by the processor itself +center = hslider("center", 440, 0, 24000, 0.1); // Band-pass center frequency in Hz +width = hslider("width", 100, 0, 12000, 0.1); // Band-pass width in Hz +centerBin = center / (ma.SR / fftSize); // fft bin of the center freq +widthBin = width / (ma.SR / fftSize); // fft bins of band-pass width +fftproc(rIn, iIn, bin) = out with { // 3 inputs for each audio channel: real, imaginary, current bin + inRange = (bin > centerBin - widthBin) & (bin < centerBin + widthBin); // is the current bin in range? + out = rIn * inRange, iIn * inRange; // 2 outputs for ifft: real, imaginary +}; +process = fftproc; diff --git a/dist/examples/fft/fft_centroid.dsp b/dist/examples/fft/fft_centroid.dsp new file mode 100644 index 00000000..7b432d47 --- /dev/null +++ b/dist/examples/fft/fft_centroid.dsp @@ -0,0 +1,19 @@ +import("stdfaust.lib"); + +fftSize = hslider("fftSize", 1024, 2, 16384, 1); // global variable set by the processor itself +fftHopSize = hslider("fftHopSize", 1024, 2, 16384, 1); // global variable set by the processor itself +bufferSize = fftSize / 2 + 1; // Bins from 0Hz to Nyquist freq +freqPerBin = ma.SR / fftSize; +binToFreq = *(freqPerBin); +freqToBin = /(freqPerBin); + +cartopol(x, y) = x * x + y * y : sqrt, atan2(y, x); // cartesian to polar +poltocar(r, theta) = r * cos(theta), r * sin(theta); // polar to cartesian + +fftproc(rIn, iIn, bin) = out, out with { // 3 inputs for each audio channel: real, imaginary, current bin + mag = rIn * rIn + iIn * iIn : sqrt; + centroid = mag : *(bin) : + ~ *(bin > 0); + weight = mag : + ~ *(bin > 0); + out = centroid / weight * freqPerBin : ba.sAndH(bin == bufferSize - 1); +}; +process = fftproc; diff --git a/dist/examples/fft/fft_delay.dsp b/dist/examples/fft/fft_delay.dsp new file mode 100644 index 00000000..adc90160 --- /dev/null +++ b/dist/examples/fft/fft_delay.dsp @@ -0,0 +1,22 @@ +import("stdfaust.lib"); + +fftSize = hslider("fftSize", 1024, 2, 16384, 1); // global variable set by the processor itself +fftHopSize = hslider("fftHopSize", 1024, 2, 16384, 1); // global variable set by the processor itself +bufferSize = fftSize / 2 + 1; // Bins from 0Hz to Nyquist freq +freqPerBin = ma.SR / fftSize; + +cartopol(x, y) = x * x + y * y : sqrt, atan2(y, x); // cartesian to polar +poltocar(r, theta) = r * cos(theta), r * sin(theta); // polar to cartesian + +feedback = hslider("feedback", 0, 0, 1, 0.01); +delay = hslider("delay", 1, 0, 10, 0.01); +delayFrames = int(ma.SR * delay / fftHopSize) : max(1); +delaySmps = delayFrames * bufferSize : min(ma.SR * 10); + +delayLine = + ~ (@(delaySmps - 1) : *(feedback)); + +fftproc(rIn, iIn, bin) = out with { // 3 inputs for each audio channel: real, imaginary, current bin + + out = (rIn : delayLine), (iIn : delayLine); +}; +process = fftproc; diff --git a/dist/examples/fft/fft_gain.dsp b/dist/examples/fft/fft_gain.dsp new file mode 100644 index 00000000..138cb020 --- /dev/null +++ b/dist/examples/fft/fft_gain.dsp @@ -0,0 +1,2 @@ +gain = hslider("gain", 1, 0, 1, 0.01); +process = *(gain), *(gain); \ No newline at end of file diff --git a/dist/examples/fft/fft_remove_phase.dsp b/dist/examples/fft/fft_remove_phase.dsp new file mode 100644 index 00000000..b867b87a --- /dev/null +++ b/dist/examples/fft/fft_remove_phase.dsp @@ -0,0 +1,17 @@ +import("stdfaust.lib"); + +fftSize = hslider("fftSize", 1024, 2, 16384, 1); // global variable set by the processor itself +fftHopSize = hslider("fftHopSize", 1024, 2, 16384, 1); // global variable set by the processor itself +bufferSize = fftSize / 2 + 1; // Bins from 0Hz to Nyquist freq +freqPerBin = ma.SR / fftSize; +binToFreq = *(freqPerBin); +freqToBin = /(freqPerBin); + +cartopol(x, y) = x * x + y * y : sqrt, atan2(y, x); // cartesian to polar +poltocar(r, theta) = r * cos(theta), r * sin(theta); // polar to cartesian + +fftproc(rIn, iIn, bin) = out, out with { // 3 inputs for each audio channel: real, imaginary, current bin + mag = rIn * rIn + iIn * iIn : sqrt; + out = poltocar(mag, 0); +}; +process = fftproc; diff --git a/dist/examples/fft/fft_synth.dsp b/dist/examples/fft/fft_synth.dsp new file mode 100644 index 00000000..01a181c4 --- /dev/null +++ b/dist/examples/fft/fft_synth.dsp @@ -0,0 +1,4 @@ +process(r, i, b) = a, a, a, a with { + k = (b == 0) : + ~ %(20); + a = (b == k) * 0.01; +}; \ No newline at end of file diff --git a/dist/examples/filtering/APF.dsp b/dist/examples/filtering/APF.dsp new file mode 100644 index 00000000..8228d333 --- /dev/null +++ b/dist/examples/filtering/APF.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "APF"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = APF(x,F,G,Q); + diff --git a/dist/examples/filtering/BPF.dsp b/dist/examples/filtering/BPF.dsp new file mode 100644 index 00000000..7d817e29 --- /dev/null +++ b/dist/examples/filtering/BPF.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "BPF"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = BPF(x,F,G,Q); + diff --git a/dist/examples/filtering/DNN.dsp b/dist/examples/filtering/DNN.dsp new file mode 100644 index 00000000..cd3c4b9b --- /dev/null +++ b/dist/examples/filtering/DNN.dsp @@ -0,0 +1,25 @@ +// Forward Deep Neural Net (DNN), any number of layers of any size each + +declare name "DNN"; +declare author "JOS"; +declare license "STK-4.3"; + +import("stdfaust.lib"); + +layerSizes = (8,5,8); // autoencoder with 8 in & out, 5-state hidden layer +w(m,n,k) = m*100+n*10+k; // placeholder weights: m=layer, n=fromNode, k=destNode + +M = ba.count(layerSizes); +N(l) = ba.take(l+1,layerSizes); // Nodes per layer + +process = seq(m, M-1, layer(m)) +// look at weights: +// process = par(m,M,par(n,N(m),par(k,N(m),w(m,n,k)))) +with { + layer(m) = weights(m) :> nonlinearities(m); + nonlinearities(m) = bus(N(m)*N(m+1)) :> par(n,N(m+1),nl(n)); + weights(m) = bus(N(m)) <: par(n,N(m),(bus(N(m+1))<:wts(m,n))); + wts(m,n) = bus(N(m+1)) : par(k,N(m+1),*(w(m,n,k))); + nl(n,x) = x * (x>0); // ReLU + bus(N) = par(k,N,_); +}; diff --git a/dist/examples/filtering/HPF.dsp b/dist/examples/filtering/HPF.dsp new file mode 100644 index 00000000..df04a35d --- /dev/null +++ b/dist/examples/filtering/HPF.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "HPF"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = HPF(x,F,G,Q); + diff --git a/dist/examples/filtering/LPF.dsp b/dist/examples/filtering/LPF.dsp new file mode 100644 index 00000000..e1351be3 --- /dev/null +++ b/dist/examples/filtering/LPF.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "LPF"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = LPF(x,F,G,Q); + diff --git a/dist/examples/filtering/bandFilter.dsp b/dist/examples/filtering/bandFilter.dsp new file mode 100644 index 00000000..d2f12a2b --- /dev/null +++ b/dist/examples/filtering/bandFilter.dsp @@ -0,0 +1,44 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "bandFilter"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +import("stdfaust.lib"); + +//---------------------second order filter-------------------------- +// filter(Q,F,G) +// Q : quality factor [1..100] +// F : frequency (Hz) +// G : gain [0..1] +//------------------------------------------------------------------ + +filter(Q,F,G) = fi.TF2( (1 + K/Q + K*K) / D, + 2 * (K*K - 1) / D, + (1 - K/Q + K*K) / D, + 2 * (K*K - 1) / D, + (1 - V*K/Q + K*K) / D + ) + with { + V = ba.db2linear(G); + K = tan(ma.PI*F/ma.SR); + D = 1 + V*K/Q + K*K; + }; + +//--------------- Band Filter with user interface ------------------ +// bandfilter(F) +// F : default frequency (Hz) +// +//------------------------------------------------------------------ + +bandfilter(F) = filter( nentry("Q factor [style:knob]",50,0.1,100,0.1), + nentry("freq [unit:Hz][style:knob]", F, 20, 20000, 1), + 0 - vslider("gain [unit:dB]", 0, -50, 50, 0.1) + ); + +//------------------------- Process -------------------------------- + +process = vgroup("Bandfilter", bandfilter(1000)); diff --git a/dist/examples/filtering/cryBaby.dsp b/dist/examples/filtering/cryBaby.dsp new file mode 100644 index 00000000..16449734 --- /dev/null +++ b/dist/examples/filtering/cryBaby.dsp @@ -0,0 +1,4 @@ +declare name "cryBaby"; +declare description "Application demonstrating the CryBaby wah pedal emulation"; +import("stdfaust.lib"); +process = dm.crybaby_demo; diff --git a/dist/examples/filtering/diodeLadder.dsp b/dist/examples/filtering/diodeLadder.dsp new file mode 100644 index 00000000..64c5dfa0 --- /dev/null +++ b/dist/examples/filtering/diodeLadder.dsp @@ -0,0 +1,12 @@ +declare name "diodeLadder"; +declare description "Demonstration of diodeLadder"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.7072,25,0.01); +normFreq = hslider("freq",0.1,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); +inputSignal = (no.noise *switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.diodeLadder(normFreq,Q) <:_,_; \ No newline at end of file diff --git a/dist/examples/filtering/filterBank.dsp b/dist/examples/filtering/filterBank.dsp new file mode 100644 index 00000000..20d65660 --- /dev/null +++ b/dist/examples/filtering/filterBank.dsp @@ -0,0 +1,6 @@ +declare name "filterBank"; +declare description "Graphic Equalizer consisting of a filter-bank driving a bank of faders"; + +import("stdfaust.lib"); + +process = dm.filterbank_demo; diff --git a/dist/examples/filtering/graphicEqLab.dsp b/dist/examples/filtering/graphicEqLab.dsp new file mode 100644 index 00000000..cbb2790a --- /dev/null +++ b/dist/examples/filtering/graphicEqLab.dsp @@ -0,0 +1,11 @@ +declare name "graphicEqLab"; +declare description "Signal generators through a filter bank with spectrum analysis display"; + +import("stdfaust.lib"); + +process = +// ol.sawtooth_demo : fl.filterbank_demo : fl.spectral_level_demo <: _,_; + vgroup("[1]",dm.sawtooth_demo) : + vgroup("[2]",dm.filterbank_demo) : + vgroup("[3]",dm.spectral_level_demo) <: + _,_; diff --git a/dist/examples/filtering/highShelf.dsp b/dist/examples/filtering/highShelf.dsp new file mode 100644 index 00000000..332bec6b --- /dev/null +++ b/dist/examples/filtering/highShelf.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "highShelf"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = highShelf(x,F,G,Q); + diff --git a/dist/examples/filtering/korg35HPF.dsp b/dist/examples/filtering/korg35HPF.dsp new file mode 100644 index 00000000..61427d68 --- /dev/null +++ b/dist/examples/filtering/korg35HPF.dsp @@ -0,0 +1,13 @@ +declare name "korg35HPF"; +declare description "Demonstration of the Korg 35 HPF"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise *switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.korg35HPF(normFreq,Q) <:_,_; \ No newline at end of file diff --git a/dist/examples/filtering/korg35LPF.dsp b/dist/examples/filtering/korg35LPF.dsp new file mode 100644 index 00000000..8cf0b922 --- /dev/null +++ b/dist/examples/filtering/korg35LPF.dsp @@ -0,0 +1,13 @@ +declare name "korg35LPF"; +declare description "Demonstration of the Korg 35 LPF"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise *switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.korg35LPF(normFreq,Q) <:_,_; \ No newline at end of file diff --git a/dist/examples/filtering/lfBoost.dsp b/dist/examples/filtering/lfBoost.dsp new file mode 100644 index 00000000..0d16af56 --- /dev/null +++ b/dist/examples/filtering/lfBoost.dsp @@ -0,0 +1,40 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "lfboost"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------------------------ +// DAFX, Digital Audio Effects (Wiley ed.) +// chapter 2 : filters +// section 2.3 : Equalizers +// page 53 : second order shelving filter design +//------------------------------------------------------------------ + +import("stdfaust.lib"); + +//----------------------low frequency boost filter ------------------------------- +// lfboost(F,G) +// F : frequency (in Hz) +// G : gain (in dB) +// +//-------------------------------------------------------------------------------- + +lfboost(F,G) = fi.TF2((1 + sqrt(2*V)*K + V*K*K) / denom, + 2 * (V*K*K - 1) / denom, + (1 - sqrt(2*V)*K + V*K*K) / denom, + 2 * (K*K - 1) / denom, + (1 - sqrt(2)*K + K*K) / denom) + with { + V = ba.db2linear(G); + K = tan(ma.PI*F/ma.SR); + denom = 1 + sqrt(2)*K + K*K; + }; + +//====================low frequency boost process =============================== + +process = vgroup("lowboost", lfboost(nentry("freq [unit:Hz][style:knob]", 100, 20, 150, 1), + vslider("gain [unit:dB]", 0, -20, 20, 0.1))); diff --git a/dist/examples/filtering/lowBoost.dsp b/dist/examples/filtering/lowBoost.dsp new file mode 100644 index 00000000..cdf70b00 --- /dev/null +++ b/dist/examples/filtering/lowBoost.dsp @@ -0,0 +1,40 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "lowboost"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------------------------ +// DAFX, Digital Audio Effects (Wiley ed.) +// chapter 2 : filters +// section 2.3 : Equalizers +// page 53 : second order shelving filter design +//------------------------------------------------------------------ + +import("stdfaust.lib"); + +//------------------- low-frequency shelving boost (table 2.3) -------------------- + +V0(g) = pow(10,g/20.0); +K(fc) = tan(ma.PI*fc/ma.SR); +square(x) = x*x; +denom(fc) = 1 + sqrt(2)*K(fc) + square(K(fc)); + +lfboost(fc, g) = fi.TF2((1 + sqrt(2*V0(g))*K(fc) + V0(g)*square(K(fc))) / denom(fc), + 2 * (V0(g)*square(K(fc)) - 1) / denom(fc), + (1 - sqrt(2*V0(g))*K(fc) + V0(g)*square(K(fc))) / denom(fc), + 2 * (square(K(fc)) - 1) / denom(fc), + (1 - sqrt(2)*K(fc) + square(K(fc))) / denom(fc)); + +//------------------------------ User Interface ----------------------------------- + +freq = hslider("[1]freq [unit:Hz][style:knob]", 1000, 20, 20000, 0.1); +gain = hslider("[2]gain [unit:dB][style:knob]", 0, -20, 20, 0.1); + +//----------------------------------- Process ------------------------------------- + +process = vgroup("low-freq shelving boost", lfboost(freq,gain)); + diff --git a/dist/examples/filtering/lowCut.dsp b/dist/examples/filtering/lowCut.dsp new file mode 100644 index 00000000..c9d12ebb --- /dev/null +++ b/dist/examples/filtering/lowCut.dsp @@ -0,0 +1,40 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "lowcut"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------------------------ +// DAFX, Digital Audio Effects (Wiley ed.) +// chapter 2 : filters +// section 2.3 : Equalizers +// page 53 : second order shelving filter design +//------------------------------------------------------------------ + +import("stdfaust.lib"); + +//------------------- low-frequency shelving cut (table 2.3) -------------------- + +V0(g) = pow(10,g/-20.0); +K(fc) = tan(ma.PI*fc/ma.SR); +squ(x) = x*x; +denom(fc,g) = 1 + sqrt(2*V0(g))*K(fc) + V0(g)*squ(K(fc)); + +lfcut(fc, g) = fi.TF2((1 + sqrt(2)*K(fc) + squ(K(fc))) / denom(fc,g), + 2 * (squ(K(fc)) - 1) / denom(fc,g), + (1 - sqrt(2)*K(fc) + squ(K(fc))) / denom(fc,g), + 2 * (V0(g)*squ(K(fc)) - 1) / denom(fc,g), + (1 - sqrt(2*V0(g))*K(fc) + V0(g)*squ(K(fc))) / denom(fc,g)); + +//------------------------------ User Interface ----------------------------------- + +freq = hslider("freq [unit:Hz][style:knob]", 100, 20, 5000, 1); +att = hslider("attenuation [unit:dB][style:knob]", 0, -96, 10, 0.1); + +//----------------------------------- Process ------------------------------------- + +process = vgroup("low-freq shelving cut", lfcut(freq,att)); + diff --git a/dist/examples/filtering/lowShelf.dsp b/dist/examples/filtering/lowShelf.dsp new file mode 100644 index 00000000..3b4d0ec1 --- /dev/null +++ b/dist/examples/filtering/lowShelf.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "lowShelf"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = lowShelf(x,F,G,Q); + diff --git a/dist/examples/filtering/moogHalfLadder.dsp b/dist/examples/filtering/moogHalfLadder.dsp new file mode 100644 index 00000000..8e88c1d0 --- /dev/null +++ b/dist/examples/filtering/moogHalfLadder.dsp @@ -0,0 +1,12 @@ +declare name "moogHalfLadder"; +declare description "Demonstration of moogHalfLadder"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.7072,25,0.01); +normFreq = hslider("freq",0.1,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); +inputSignal = (no.noise *switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.moogHalfLadder(normFreq,Q) <:_,_; \ No newline at end of file diff --git a/dist/examples/filtering/moogLadder.dsp b/dist/examples/filtering/moogLadder.dsp new file mode 100644 index 00000000..4da02680 --- /dev/null +++ b/dist/examples/filtering/moogLadder.dsp @@ -0,0 +1,12 @@ +declare name "moogLadder"; +declare description "Demonstration of moogLadder"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.7072,25,0.01); +normFreq = hslider("freq",0.1,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); +inputSignal = (no.noise *switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.moogLadder(normFreq,Q) <:_,_; \ No newline at end of file diff --git a/dist/examples/filtering/moogVCF.dsp b/dist/examples/filtering/moogVCF.dsp new file mode 100644 index 00000000..45f256ec --- /dev/null +++ b/dist/examples/filtering/moogVCF.dsp @@ -0,0 +1,6 @@ +declare name "moogVCF"; +declare description "Exercise and compare three Moog VCF implementations"; + +import("stdfaust.lib"); + +process = dm.moog_vcf_demo; diff --git a/dist/examples/filtering/multibandFilter.dsp b/dist/examples/filtering/multibandFilter.dsp new file mode 100644 index 00000000..6afa6453 --- /dev/null +++ b/dist/examples/filtering/multibandFilter.dsp @@ -0,0 +1,14 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "multibandFilter"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//---------------------------Multi Band Filter----------------------------- +// +//------------------------------------------------------------------------- + +process = hgroup("Multi Band Filter", seq(i, 10, vgroup("peak %i", component("bandFilter.dsp").bandfilter(1000*(1+i))))); diff --git a/dist/examples/filtering/notch.dsp b/dist/examples/filtering/notch.dsp new file mode 100644 index 00000000..dcab9ecd --- /dev/null +++ b/dist/examples/filtering/notch.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "notch"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = notch(x,F,G,Q); + diff --git a/dist/examples/filtering/oberheim.dsp b/dist/examples/filtering/oberheim.dsp new file mode 100644 index 00000000..8e5d5964 --- /dev/null +++ b/dist/examples/filtering/oberheim.dsp @@ -0,0 +1,14 @@ +declare name "oberheimBSF"; +declare description "Demonstration of the Oberheim generic multi-outputs Filter"; +declare author "Eric Tarr, GRAME"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +// The BSF, BPF, HPF and LPF outputs are produced +process = inputSignal : ve.oberheim(normFreq,Q); diff --git a/dist/examples/filtering/oberheimBPF.dsp b/dist/examples/filtering/oberheimBPF.dsp new file mode 100644 index 00000000..c61e5cb0 --- /dev/null +++ b/dist/examples/filtering/oberheimBPF.dsp @@ -0,0 +1,13 @@ +declare name "oberheimBPF"; +declare description "Demonstration of the Oberheim Band-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.oberheimBPF(normFreq,Q) <:_,_; diff --git a/dist/examples/filtering/oberheimBSF.dsp b/dist/examples/filtering/oberheimBSF.dsp new file mode 100644 index 00000000..e048a03f --- /dev/null +++ b/dist/examples/filtering/oberheimBSF.dsp @@ -0,0 +1,13 @@ +declare name "oberheimBSF"; +declare description "Demonstration of the Oberheim Band-Stop Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.oberheimBSF(normFreq,Q) <:_,_; diff --git a/dist/examples/filtering/oberheimHPF.dsp b/dist/examples/filtering/oberheimHPF.dsp new file mode 100644 index 00000000..bfcc2feb --- /dev/null +++ b/dist/examples/filtering/oberheimHPF.dsp @@ -0,0 +1,13 @@ +declare name "oberheimHPF"; +declare description "Demonstration of the Oberheim High-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.oberheimHPF(normFreq,Q) <:_,_; diff --git a/dist/examples/filtering/oberheimLPF.dsp b/dist/examples/filtering/oberheimLPF.dsp new file mode 100644 index 00000000..a75d443f --- /dev/null +++ b/dist/examples/filtering/oberheimLPF.dsp @@ -0,0 +1,13 @@ +declare name "oberheimLPF"; +declare description "Demonstration of the Oberheim Low-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.oberheimLPF(normFreq,Q) <:_,_; diff --git a/dist/examples/filtering/parametricEqLab.dsp b/dist/examples/filtering/parametricEqLab.dsp new file mode 100644 index 00000000..39c1d781 --- /dev/null +++ b/dist/examples/filtering/parametricEqLab.dsp @@ -0,0 +1,12 @@ +declare name "parametricEqLab"; +declare description "Demonstrate the Parametric Equalizer sections on test signals with spectrum analysis display"; + +import("stdfaust.lib"); + +//process = ol.sawtooth_demo : fl.parametric_eq_demo : +// fl.mth_octave_spectral_level_demo(2) <: _,_; +process = + vgroup("[1]", dm.sawtooth_demo) : + vgroup("[2]", dm.parametric_eq_demo) : + vgroup("[3]", dm.mth_octave_spectral_level_demo(2)) + <: _,_; diff --git a/dist/examples/filtering/parametricEqualizer.dsp b/dist/examples/filtering/parametricEqualizer.dsp new file mode 100644 index 00000000..a9ceacd4 --- /dev/null +++ b/dist/examples/filtering/parametricEqualizer.dsp @@ -0,0 +1,6 @@ +declare name "parametricEqualizer"; +declare description "Exercise and compare Parametric Equalizer sections on test signals"; + +import("stdfaust.lib"); + +process = dm.parametric_eq_demo; diff --git a/dist/examples/filtering/peakNotch.dsp b/dist/examples/filtering/peakNotch.dsp new file mode 100644 index 00000000..67141013 --- /dev/null +++ b/dist/examples/filtering/peakNotch.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "peakNotch"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit: lin]", 1, 0, 8, 0.01); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = peakNotch(x,F,G,Q); + diff --git a/dist/examples/filtering/peakingEQ.dsp b/dist/examples/filtering/peakingEQ.dsp new file mode 100644 index 00000000..cf234cf6 --- /dev/null +++ b/dist/examples/filtering/peakingEQ.dsp @@ -0,0 +1,13 @@ +// WARNING: This a "legacy example based on a deprecated library". Check filters.lib +// for more accurate examples of filter functions + +declare name "peakingEQ"; + +import("maxmsp.lib"); + +G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1); +F = hslider("Freq", 1000, 100, 10000, 1); +Q = hslider("Q", 1, 0.01, 100, 0.01); + +process(x) = peakingEQ(x,F,G,Q); + diff --git a/dist/examples/filtering/sallenKey2ndOrder.dsp b/dist/examples/filtering/sallenKey2ndOrder.dsp new file mode 100644 index 00000000..cc227421 --- /dev/null +++ b/dist/examples/filtering/sallenKey2ndOrder.dsp @@ -0,0 +1,14 @@ +declare name "sallenKey2ndOrderBPF"; +declare description "Demonstration of the Sallen-Key Second Order generic multi-ourputs Filter"; +declare author "Eric Tarr, GRAME"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _ ; + +// The LPF and HPF outputs are produced +process = inputSignal : ve.sallenKey2ndOrder(normFreq,Q); diff --git a/dist/examples/filtering/sallenKey2ndOrderBPF.dsp b/dist/examples/filtering/sallenKey2ndOrderBPF.dsp new file mode 100644 index 00000000..21548577 --- /dev/null +++ b/dist/examples/filtering/sallenKey2ndOrderBPF.dsp @@ -0,0 +1,13 @@ +declare name "sallenKey2ndOrderBPF"; +declare description "Demonstration of the Sallen-Key Second Order Band-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.sallenKey2ndOrderBPF(normFreq,Q) <:_,_; diff --git a/dist/examples/filtering/sallenKey2ndOrderHPF.dsp b/dist/examples/filtering/sallenKey2ndOrderHPF.dsp new file mode 100644 index 00000000..882bb7eb --- /dev/null +++ b/dist/examples/filtering/sallenKey2ndOrderHPF.dsp @@ -0,0 +1,13 @@ +declare name "sallenKey2ndOrderHPF"; +declare description "Demonstration of the Sallen-Key Second Order Low-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.sallenKey2ndOrderHPF(normFreq,Q) <:_,_; diff --git a/dist/examples/filtering/sallenKey2ndOrderLPF.dsp b/dist/examples/filtering/sallenKey2ndOrderLPF.dsp new file mode 100644 index 00000000..3b29b0b9 --- /dev/null +++ b/dist/examples/filtering/sallenKey2ndOrderLPF.dsp @@ -0,0 +1,13 @@ +declare name "sallenKey2ndOrderLPF"; +declare description "Demonstration of the Sallen-Key Second Order Low-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +Q = hslider("Q",1,0.5,10,0.01); +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.sallenKey2ndOrderLPF(normFreq,Q) <:_,_; diff --git a/dist/examples/filtering/sallenKeyOnePole.dsp b/dist/examples/filtering/sallenKeyOnePole.dsp new file mode 100644 index 00000000..d64a3823 --- /dev/null +++ b/dist/examples/filtering/sallenKeyOnePole.dsp @@ -0,0 +1,13 @@ +declare name "sallenKeyOnePoleLPF"; +declare description "Demonstration of the Sallen-Key One Pole generic multi-ouputs Filter"; +declare author "Eric Tarr, GRAME"; + +import("stdfaust.lib"); + +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +// The LPF, BPF and HPF outputs are produced +process = inputSignal : ve.sallenKeyOnePole(normFreq); diff --git a/dist/examples/filtering/sallenKeyOnePoleHPF.dsp b/dist/examples/filtering/sallenKeyOnePoleHPF.dsp new file mode 100644 index 00000000..17197424 --- /dev/null +++ b/dist/examples/filtering/sallenKeyOnePoleHPF.dsp @@ -0,0 +1,12 @@ +declare name "sallenKeyOnePoleHPF"; +declare description "Demonstration of the Sallen-Key One Pole High-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.sallenKeyOnePoleHPF(normFreq) <:_,_; diff --git a/dist/examples/filtering/sallenKeyOnePoleLPF.dsp b/dist/examples/filtering/sallenKeyOnePoleLPF.dsp new file mode 100644 index 00000000..7704e819 --- /dev/null +++ b/dist/examples/filtering/sallenKeyOnePoleLPF.dsp @@ -0,0 +1,12 @@ +declare name "sallenKeyOnePoleLPF"; +declare description "Demonstration of the Sallen-Key One Pole Low-Pass Filter"; +declare author "Eric Tarr"; + +import("stdfaust.lib"); + +normFreq = hslider("freq",0.5,0,1,0.001):si.smoo; +switch = checkbox("Saw/Noise"); + +inputSignal = (no.noise*switch) , (os.sawtooth(100)*(1-switch)) :> _; + +process = inputSignal : ve.sallenKeyOnePoleLPF(normFreq) <:_,_; diff --git a/dist/examples/filtering/spectralTilt.dsp b/dist/examples/filtering/spectralTilt.dsp new file mode 100644 index 00000000..397c85ad --- /dev/null +++ b/dist/examples/filtering/spectralTilt.dsp @@ -0,0 +1,8 @@ +declare name "spectralTilt"; +declare description "Demonstrate the Spectral Tilt effect on test signals"; + +import("stdfaust.lib"); + +O = 2; // filter order + +process = dm.spectral_tilt_demo(2); diff --git a/dist/examples/filtering/vcfWahLab.dsp b/dist/examples/filtering/vcfWahLab.dsp new file mode 100644 index 00000000..247b898b --- /dev/null +++ b/dist/examples/filtering/vcfWahLab.dsp @@ -0,0 +1,15 @@ +import("stdfaust.lib"); +declare description "Demonstrate competing variable-lowpass-filter effects on test signals with spectrum analysis display"; + +declare name "vcfWahLab"; + +// process = ol.sawtooth_demo : +// el.crybaby_demo : el.moog_vcf_demo : el.wah4_demo : +// fl.spectral_level_demo <: _,_; +process = + vgroup("[1]", dm.sawtooth_demo) : + vgroup("[2]", dm.crybaby_demo) : + vgroup("[3]", dm.wah4_demo) : + vgroup("[4]", dm.moog_vcf_demo) : + vgroup("[5]", dm.spectral_level_demo) <: + _,_; diff --git a/dist/examples/filtering/vocoder.dsp b/dist/examples/filtering/vocoder.dsp new file mode 100644 index 00000000..3cc8ca4e --- /dev/null +++ b/dist/examples/filtering/vocoder.dsp @@ -0,0 +1,8 @@ +declare name "Vocoder"; +declare version "0.0"; +declare author "RM"; +declare description "Use example of the vocoder function where an impulse train is used as excitation."; + +import("stdfaust.lib"); + +process = dm.vocoder_demo; diff --git a/dist/examples/filtering/wahPedal.dsp b/dist/examples/filtering/wahPedal.dsp new file mode 100644 index 00000000..802fbe68 --- /dev/null +++ b/dist/examples/filtering/wahPedal.dsp @@ -0,0 +1,6 @@ +declare name "wahPedal"; +declare description "Demonstrate the Fourth-Order Wah pedal (similar to the Moog VCF)"; + +import("stdfaust.lib"); + +process = dm.wah4_demo; diff --git a/dist/examples/gameaudio/bubble.dsp b/dist/examples/gameaudio/bubble.dsp new file mode 100644 index 00000000..e487f7c7 --- /dev/null +++ b/dist/examples/gameaudio/bubble.dsp @@ -0,0 +1,42 @@ +declare name "bubble"; +declare description "Production of a water drop bubble sound."; +declare license "MIT"; +declare copyright "(c) 2017: Yann Orlarey, GRAME"; + +import("stdfaust.lib"); + +//---------------------------`bubble`-------------------------- +// bubble(f0, trig) : produces a water drop bubble sound +// +// #### Usage +// +// ``` +// bubble(f0, trig) : _ +// ``` +// +// Where: +// +// * ` f0 `: base frequency of bubble sound +// * `trig`: trigs the bubble sound on the rising front +// +// #### Example +// +// ``` +// button("drop") : bubble(600) : _ +// ``` +// +// #### Reference: +// +// +//------------------------------------------------------------ + +bubble(f0,trig) = os.osc(f) * (exp(-damp*time) : si.smooth(0.99)) + with { + damp = 0.043*f0 + 0.0014*f0^(3/2); + f = f0*(1+sigma*time); + sigma = eta * damp; + eta = 0.075; + time = 0 : (select2(trig>trig'):+(1)) ~ _ : ba.samp2sec; + }; + +process = button("drop") : bubble(hslider("v:bubble/freq", 600, 150, 2000, 1)) <: dm.freeverb_demo; diff --git a/dist/examples/gameaudio/door.dsp b/dist/examples/gameaudio/door.dsp new file mode 100644 index 00000000..b86d1e55 --- /dev/null +++ b/dist/examples/gameaudio/door.dsp @@ -0,0 +1,58 @@ +//----------------------------`door`-------------------------- +// door(force) : produces a creaking door sound, +// based on examples +// from the book "Designing Sound" +// by Andy Farnell +// +// #### Usage +// +// ``` +// door(force) : _ +// ``` +// +// Where: +// +// * `force`: a float value between 0 and 1 +// (0.3 to 0.93 for best results) +// +// #### Examples +// +// ``` +// door(hslider("force", 0, 0, 0.93, 0.001)) <: _, _; +// ``` +// +//------------------------------------------------------------ + +import("stdfaust.lib"); + +stickslip(force) = metro : timer : *(1000) : min(100) : /(100) : + sqrt <: (+(0.1) : sqrt), (vline) : (*) + with { + swap(a, b) = (b, a); + metro = force : ba.line(ba.sec2samp(0.1)) : (step1 ~ _); + step1(t, s) = s <: (>(0.3)), (swap(1) : (-) <: + ((*(60) : +(3)), (*(6) : *(no.noise : abs : ba.sAndH(t)))) : (+)) : _, (/(1000) : ba.sec2samp : ba.pulse) : (*); + timer(s) = 1 : ba.pulse_countup(((s : mem) == 0)) : /(ma.SR) : ba.sAndH(s); + vline(s) = s <: _, mem : (!=) : en.ar(0, s / 1000) <: (*); + }; + +wood1 = _ <: ((fs, qs, si.bus(6)) : ro.interleave(6, 3) : par(i, 6, flt)), *(0.2) :> _ + with { + fs = (62.5, 125, 250, 395, 560, 790); + qs = (1, 1, 2, 2, 3, 3); + flt(f, q) = fi.resonbp(f, q, 1); + }; + +wood2 = _ <: (ds, si.bus(8)) : ro.interleave(8, 2) : par(i, 8, res) :> fi.highpass(1, 125) + with { + res(b) = dfbe(b, 0.05); + ds = (4.52, 5.06, 6.27, 8, 5.48, 7.14, 10.12, 16); + dfbe(i, g) = ((+) : de.delay(ba.sec2samp(0.1), ba.sec2samp(i / 1000))) ~ (*(g)); + }; + +door(force) = stickslip(force) : wood1 : wood2 : *(0.2); + +process = door(force) <: (_, _) + with { + force = button("door") : ba.impulsify : en.ar(2, 1.5) : *(0.61) : +(0.28); + }; diff --git a/dist/examples/gameaudio/fire.dsp b/dist/examples/gameaudio/fire.dsp new file mode 100644 index 00000000..a4594423 --- /dev/null +++ b/dist/examples/gameaudio/fire.dsp @@ -0,0 +1,46 @@ +import("stdfaust.lib"); + +//----------------------------`fire`--------------------------- +// fire(is_wet) : produces burning fire sound +// +// #### Usage +// +// ``` +// fire(is_wet) : _ +// ``` +// +// Where: +// +// * `is_wet`: a binary flag/signal adding wet wood +// popping sound +// +// #### Example +// +// ``` +// checkbox("wet") : fire : _ +// ``` +// +//------------------------------------------------------------ + +sq(x) = x * x; +stretch(ms) = ba.countdown(ma.SR * ms / 1000): >(0); + +crackle(dens, rel) = ((no.noise : fi.lowpass(3, 10000)) * 0.77 * os.osc(50 / dens) * + en.arfe(0.001, release, 0, trigger: >(0) + : stretch(sus))) + : fi.highpass(3, 1000) + with { + trigger = no.sparse_noise(dens): abs; + sus = 2 + (trigger: ba.latch(trigger) * 8); + release = rel + (0.3 * (no.noise : abs : ba.latch(trigger))); + }; + +fire(is_wet) = (is_wet * wet) + (base <: (_, fi.lowpass(3, 1000), fi.highpass(3, 10000)) :> _) + with { + hiss = (no.noise : fi.lowpass(3, 500)) / 5; + hiss2 = 0.8 * (no.noise : fi.highpass(3, 3000) / 8) * sq(no.lfnoise(1000)); + wet = (3 * crackle(0.1, 0.05)) + (2 * crackle(0.2, 0.3)); + base = hiss + hiss2 + (0.2 * crackle(5, 0.1)); + }; + +process = checkbox("wet"): fire; diff --git a/dist/examples/gameaudio/insects.dsp b/dist/examples/gameaudio/insects.dsp new file mode 100644 index 00000000..d9c407f2 --- /dev/null +++ b/dist/examples/gameaudio/insects.dsp @@ -0,0 +1,148 @@ +import("stdfaust.lib"); + +//---------------------------`cricket`------------------------- +// cricket(f1, f2, trig) : produces a cricket chirp, +// the cricket sound based on examples +// from the book "Designing Sound" +// by Andy Farnell +// +// #### Usage +// +// ``` +// cricket(f1, f2, trig) : _ +// ``` +// +// Where: +// +// * ` f1 `: frequency of the first harmonic of the chirp +// * ` f2 `: frequency of the second harmonic of the chirp +// * `trig`: the trigger impulse +// +// #### Examples +// +// ``` +// ba.pulse(20000) : cricket(5134, 12342) : _ +// ``` +// or +// ``` +// button("chirp") : ba.impulsify : cricket(5134, 12342, trig1) : _ +// ``` +// +//------------------------------------------------------------ + +//--------------------------`critters`------------------------ +// critters(freqs) : produces background 'critters' sound, +// based on examples +// from the book "Designing Sound" +// by Andy Farnell +// +// #### Usage +// +// ``` +// critters(freqs) : _ +// ``` +// +// Where: +// +// * `freqs`: a list with 4 frequencies +// +// #### Examples +// +// ``` +// critters((2012, 4, 20, 2)) : _ +// ``` +// +//------------------------------------------------------------ + +//----------------------------`frog`-------------------------- +// frog(l, f, trig) : produces a frog croaking sound, +// based on examples +// from the book "Designing Sound" +// by Andy Farnell +// +// #### Usage +// +// ``` +// frog(l, f, trig) : _ +// ``` +// +// Where: +// +// * ` l `: length of the croak in [ms] +// * ` f `: the frequency of resonance (don't go below ~300Hz) +// * `trig`: the trigger impulse +// +// #### Examples +// +// ``` +// button("croak") : ba.impulsify : frog(250, 900) : _ +// ``` +// +//------------------------------------------------------------ + + +wrap(s) = s - int(s); +normsin(s) = sin(2 * ma.PI * s); +normcos(s) = cos(2 * ma.PI * s); +phasor(f) = os.phasor(1, f); +stretch(ms) = ba.countdown(ma.SR * ms / 1000) : >(0); +pulsetrain(ms, n, trig) = (trig: stretch(ms * n)) * ba.pulse(ma.SR * ms / 1000); + +cricket(f1, f2, trig) = s1 : *(44) <: ((aa.clip(0, 1.0): wrap), (aa.clip(1.0, 4.0) : wrap)) :> (+): + normsin : aa.clip(0.0, 1.0) : *(s2) : *(0.3): *(e) + with { + f = 0.8; + sig = phasor(f); + phase = sig : ba.sAndH(trig); + s1 = wrap(sig + (1 - phase)); + s2 = os.osc(f1) + os.osc(f2) : *(no.lfnoise(500)); + e = trig : stretch(1000 / f); + }; + +water = no.noise : abs : ba.sAndH(no.sparse_noise(250) : abs : >(0)) : + *(1200) : +(400) : os.osc : fi.resonhp(850, 15, 1) : *(0.008); + +hum = no.noise : fi.resonlp(800, 1, 0.08); + +critters(freqs) = freqs : prod(i, ba.count(freqs), phasor: normcos):> + fi.resonhp(20, 1, 1) : *(os.osc(0.01)): *(0.025); + +frog(l, f, trig) = out + with { + sq(x) = x * x; + src = en.asr(0.0, 1.0, l / 1000, trig); + ch1 = 1.0 / (src : max(0.5): *(-1.0): +(ch2): *(3): sq: *(2): -(1) : wrap *(122): sq: +(1)); + ch2 = src : min(0.5); + ch3 = (1 - src) <: ((max(0.9) : *(-1)), min(0.5)) :> *(3) <: ((*(40): +(f)), (*(90): +(2 * f)), (*(240): +(3 * f))); + out = ch3 : vcf(ch1, 5), vcf(ch1, 4), vcf(ch1, 3) : (*(0.45), _, *(0.45)) :> fi.resonhp(10, 1, 1): *(0.5); + vcf(s, res, f) = s : fi.resonbp(f, res, 1): fi.resonlp(1400, 1, 1); + }; + +process = insects, background : ro.interleave(2, 2) : par(i, 2, sum(j, 2, _)) + with { + N = ba.count(channels); + trig_data = ((0.1, 500, 5), (0.15, 300, 3), + (0.05, 250, 6), (0.0921, 320, 4), + (0.093, 250, 3), (0.09, 300, 2), (0.087, 150, 5)); + channels = (cricket(5134, 12342), + cricket(3134, 8342), + cricket(8134, 15342), + cricket(6134, 1842), + frog(250, 900), + frog(400, 600), + frog(200, 800)); + spat(rng1, rng2, trig) = sp.spat(2, r, d) + with { + r = rng1 : abs : ba.sAndH(trig); + d = rng2 : abs : ba.sAndH(trig); + }; + trig(f, ms, n) = no.sparse_noise(f) : abs : >(0) <: (_, pulsetrain(ms, n)); + trigsm = trig_data : par(i, N, trig): ro.interleave(2, N); + btrigs = trigsm : (si.bus(N), si.block(N)); + trigs = trigsm : (si.block(N), si.bus(N)); + spats = (no.multinoise(2 * N), btrigs, (trigs : channels)) : ro.interleave(N, 4): par(i, N, spat); + insects = spats : ro.interleave(2, N) : par(i, 2, sum(j, N, _)); + background = water + hum + + critters((2012, 4, 20, 2)) + + critters((2134, 4.279, 20.4, 15.5)) : *(0.4) <: (_, _); + }; diff --git a/dist/examples/gameaudio/rain.dsp b/dist/examples/gameaudio/rain.dsp new file mode 100644 index 00000000..09d12d0e --- /dev/null +++ b/dist/examples/gameaudio/rain.dsp @@ -0,0 +1,27 @@ +//----------------------`rain`-------------------------- +// A very simple rain simulator +// +// #### Usage +// +// ``` +// rain(d,l) : _,_ +// ``` +// +// Where: +// +// * `d`: is the density of the rain: between 0 and 1 +// * `l`: is the level (volume) of the rain: between 0 and 1 +// +//---------------------------------------------------------- + +import("stdfaust.lib"); + +rain(density,level) = no.multinoise(2) : par(i, 2, drop) : par(i, 2, *(level)) + with { + drop = _ <: @(1), (abs < density) : *; + }; + +process = rain( + hslider("v:rain/density", 300, 0, 1000, 1) / 1000, + hslider("v:rain/volume", 0.5, 0, 1, 0.01) + ); diff --git a/dist/examples/gameaudio/wind.dsp b/dist/examples/gameaudio/wind.dsp new file mode 100644 index 00000000..a7d3da2f --- /dev/null +++ b/dist/examples/gameaudio/wind.dsp @@ -0,0 +1,23 @@ +//----------------------`wind`-------------------------- +// A very simple wind simulator, based on a filtered white noise +// +// #### Usage +// +// ``` +// wind(f) : _ +// ``` +// +// Where: +// +// * `f`: is the force of the wind: between 0 and 1 +// +//---------------------------------------------------------- + +import("stdfaust.lib"); + +wind(force) = no.multinoise(2) : par(i, 2, ve.moog_vcf_2bn(force,freq)) : par(i, 2, *(force)) + with { + freq = (force*87)+1 : ba.pianokey2hz; + }; + +process = wind(hslider("v:wind/force",0.66,0,1,0.01) : si.smooth(0.997)); diff --git a/dist/examples/generator/filterOsc.dsp b/dist/examples/generator/filterOsc.dsp new file mode 100644 index 00000000..5169367f --- /dev/null +++ b/dist/examples/generator/filterOsc.dsp @@ -0,0 +1,8 @@ +declare name "filterOSC"; +declare version "0.0"; +declare author "JOS, revised by RM"; +declare description "Simple application demoing filter based oscillators."; + +import("stdfaust.lib"); + +process = dm.oscrs_demo; diff --git a/dist/examples/generator/noise.dsp b/dist/examples/generator/noise.dsp new file mode 100644 index 00000000..8544f4a6 --- /dev/null +++ b/dist/examples/generator/noise.dsp @@ -0,0 +1,52 @@ +// WARNING: This a "legacy example based on a deprecated library". Check noises.lib +// for more accurate examples of noise functions + +declare name "Noise"; +declare version "1.1"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2009"; + +//----------------------------------------------------------------- +// Noise generator and demo file for the Faust math documentation +//----------------------------------------------------------------- + + +\section{Presentation of the "noise.dsp" Faust program} +This program describes a white noise generator with an interactive volume, using a random function. + +\subsection{The random function} +The \texttt{random} function describes a generator of random numbers, which equation follows. You should notice hereby the use of an integer arithmetic on 32 bits, relying on integer wrapping for big numbers. +random + +\subsection{The noise function} +The white noise then corresponds to: +noise + + +random = +(12345)~*(1103515245); +noise = random/2147483647.0; + + +\subsection{Just add a user interface element to play volume!} +Endly, the sound level of this program is controlled by a user slider, which gives the following equation: +process + + + +\section{Block-diagram schema of process} +This process is illustrated on figure 1. +process + + +process = noise * vslider("Volume[style:knob][acc: 0 0 -10 0 10]", 0.5, 0, 1, 0.1); + + +\section{Notice of this documentation} +You might be careful of certain information and naming conventions used in this documentation: + + +\section{Listing of the input code} +The following listing shows the input Faust code, parsed to compile this mathematical documentation. ++ diff --git a/dist/examples/generator/noiseMetadata.dsp b/dist/examples/generator/noiseMetadata.dsp new file mode 100644 index 00000000..26ba20dd --- /dev/null +++ b/dist/examples/generator/noiseMetadata.dsp @@ -0,0 +1,74 @@ +// WARNING: This a "legacy example based on a deprecated library". Check noises.lib +// for more accurate examples of noise functions + + +\title{name} +\author{author} +\date{\today} +\maketitle + +\begin{tabular}{ll} + \hline + \textbf{name} & name \\ + \textbf{version} & version \\ + \textbf{author} & author \\ + \textbf{license} & license \\ + \textbf{copyright} & copyright \\ + \hline +\end{tabular} +\bigskip + +//----------------------------------------------------------------- +// Noise generator and demo file for the Faust math documentation +//----------------------------------------------------------------- + +declare name "noiseMetadata"; // avoid same name as in noise.dsp +declare version "1.1"; +declare author "Grame"; +declare author "Yghe"; +declare license "BSD"; +declare copyright "(c)GRAME 2009"; + + +\section{Presentation of the "noise.dsp" Faust program} +This program describes a white noise generator with an interactive volume, using a random function. + +\subsection{The random function} + + +random = +(12345)~*(1103515245); + + +The \texttt{random} function describes a generator of random numbers, which equation follows. You should notice hereby the use of an integer arithmetic on 32 bits, relying on integer wrapping for big numbers. +random + +\subsection{The noise function} + + +noise = random/2147483647.0; + + +The white noise then corresponds to: +noise + +\subsection{Just add a user interface element to play volume!} + + +process = noise * vslider("Volume[style:knob]", 0, 0, 1, 0.1); + + +Endly, the sound level of this program is controlled by a user slider, which gives the following equation: +process + +\section{Block-diagram schema of process} +This process is illustrated on figure 1. +process + +\section{Notice of this documentation} +You might be careful of certain information and naming conventions used in this documentation: + + +\section{Listing of the input code} +The following listing shows the input Faust code, parsed to compile this mathematical documentation. ++ diff --git a/dist/examples/generator/osc.dsp b/dist/examples/generator/osc.dsp new file mode 100644 index 00000000..e1860af4 --- /dev/null +++ b/dist/examples/generator/osc.dsp @@ -0,0 +1,17 @@ +declare name "osc"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2009"; + +//----------------------------------------------- +// Sinusoidal Oscillator +//----------------------------------------------- + +import("stdfaust.lib"); + +vol = hslider("volume [unit:dB]", 0, -96, 0, 0.1) : ba.db2linear : si.smoo; +freq = hslider("freq [unit:Hz]", 1000, 20, 24000, 1); + +process = vgroup("Oscillator", os.osc(freq) * vol); + diff --git a/dist/examples/generator/osci.dsp b/dist/examples/generator/osci.dsp new file mode 100644 index 00000000..87695300 --- /dev/null +++ b/dist/examples/generator/osci.dsp @@ -0,0 +1,17 @@ +declare name "osci"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2009"; + +//----------------------------------------------- +// Sinusoidal Oscillator +// (with linear interpolation) +//----------------------------------------------- + +import("stdfaust.lib"); + +vol = hslider("volume [unit:dB]", 0, -96, 0, 0.1) : ba.db2linear : si.smoo ; +freq = hslider("freq [unit:Hz]", 1000, 20, 24000, 1); + +process = vgroup("Oscillator", os.osci(freq) * vol); diff --git a/dist/examples/generator/sawtoothLab.dsp b/dist/examples/generator/sawtoothLab.dsp new file mode 100644 index 00000000..8cf5ca86 --- /dev/null +++ b/dist/examples/generator/sawtoothLab.dsp @@ -0,0 +1,8 @@ +declare name "sawtoothLab"; +declare version "0.0"; +declare author "JOS, revised by RM"; +declare description "An application demonstrating the different sawtooth oscillators of Faust."; + +import("stdfaust.lib"); + +process = dm.sawtooth_demo; diff --git a/dist/examples/generator/virtualAnalog.dsp b/dist/examples/generator/virtualAnalog.dsp new file mode 100644 index 00000000..b45eb3a0 --- /dev/null +++ b/dist/examples/generator/virtualAnalog.dsp @@ -0,0 +1,8 @@ +declare name "VirtualAnalog"; +declare version "0.0"; +declare author "JOS, revised by RM"; +declare description "Virtual analog oscillator demo application."; + +import("stdfaust.lib"); + +process = dm.virtual_analog_oscillator_demo; diff --git a/dist/examples/generator/virtualAnalogLab.dsp b/dist/examples/generator/virtualAnalogLab.dsp new file mode 100644 index 00000000..0fabf73b --- /dev/null +++ b/dist/examples/generator/virtualAnalogLab.dsp @@ -0,0 +1,10 @@ +declare name "virtualAnalogLab"; + +import("stdfaust.lib"); + +process = + vgroup("[1]", dm.virtual_analog_oscillator_demo) : + vgroup("[2]", dm.moog_vcf_demo) : + vgroup("[3]", dm.spectral_level_demo) + // See also: vgroup("[3]", dm.fft_spectral_level_demo(32)) + <: _,_; diff --git a/dist/examples/misc/UITester.dsp b/dist/examples/misc/UITester.dsp new file mode 100644 index 00000000..f86cdd15 --- /dev/null +++ b/dist/examples/misc/UITester.dsp @@ -0,0 +1,71 @@ +declare name "UITester"; +declare version "1.0"; +declare author "O. Guillerminet"; +declare license "BSD"; +declare copyright "(c) O. Guillerminet 2012"; + +vbox = vgroup("vbox", + checkbox("check1"), + checkbox("check2"), + nentry("knob0[style:knob]", 60, 0, 127, 0.1)); + +sliders = hgroup("sliders", + vslider("vslider1", 60, 0, 127, 0.1), + vslider("vslider2", 60, 0, 127, 0.1), + vslider("vslider3", 60, 0, 127, 0.1)); + +knobs = hgroup("knobs", + vslider("knob1[style:knob]", 60, 0, 127, 0.1), + vslider("knob2[style:knob]", 60, 0, 127, 0.1), + vslider("knob3[style:knob]", 60, 0, 127, 0.1)); + +smallhbox1 = hgroup("small box 1", + vslider("vslider5 [unit:Hz]", 60, 0, 127, 0.1), + vslider("vslider6 [unit:Hz]", 60, 0, 127, 0.1), + vslider("knob4[style:knob]", 60, 0, 127, 0.1), + nentry("num1 [unit:f]", 60, 0, 127, 0.1), + vbargraph("vbar1", 0, 127)); + +smallhbox2 = hgroup("small box 2", + vslider("vslider7 [unit:Hz]", 60, 0, 127, 0.1), + vslider("vslider8 [unit:Hz]", 60, 0, 127, 0.1), + vslider("knob5[style:knob]", 60, 0, 127, 0.1), + nentry("num2 [unit:f]", 60, 0, 127, 0.1), + vbargraph("vbar2", 0, 127)); + +smallhbox3 = hgroup("small box 3", + vslider("vslider9 [unit:Hz]", 60, 0, 127, 0.1), + vslider("vslider10 [unit:m]", 60, 0, 127, 0.1), + vslider("knob6[style:knob]", 60, 0, 127, 0.1), + nentry("num3 [unit:f]", 60, 0, 127, 0.1), + vbargraph("vbar3", 0, 127)); + +subhbox1 = hgroup("sub box 1", + smallhbox2, + smallhbox3); + +vmisc = vgroup("vmisc", + vslider("vslider4 [unit:Hz]", 60, 0, 127, 0.1), + button("button"), + hslider("hslider [unit:Hz]", 60, 0, 127, 0.1), + smallhbox1, + subhbox1, + hbargraph("hbar", 0, 127)); + +hmisc = hgroup("hmisc", + vslider("vslider4 [unit:f]", 60, 0, 127, 0.1), + button("button"), + hslider("hslider", 60, 0, 127, 0.1), + nentry("num [unit:f]", 60, 0, 127, 0.1), + vbargraph("vbar", 0, 127), + hbargraph("hbar", 0, 127)); + +//------------------------- Process -------------------------------- + +process = tgroup("grp 1", + vbox, + sliders, + knobs, + vmisc, + hmisc); + diff --git a/dist/examples/misc/autopan.dsp b/dist/examples/misc/autopan.dsp new file mode 100644 index 00000000..4c9e599c --- /dev/null +++ b/dist/examples/misc/autopan.dsp @@ -0,0 +1,59 @@ +//--------------------------autopan---------------------------- +// +// For a stereo input, adjust the left and right gains +// according to rate-synced sine oscillators. This example is +// reverse-engineered from Ableton Live's "Auto Pan" audio +// effect. We don't implement the "spin" feature in which +// the two LFOs could have different frequencies. +// We also don't use other LFOs such as triangle/square/noise. +// +// #### Usage +// +// ``` +// si.bus(2) : autopan(amount, rate, phase, shape) : si.bus(2) +// ``` +// +// Where: +// +// * `amount`: adjusts the amount of LFO modulation that is +// applied to incoming signals +// * `rate`: sets the frequency of the LFO in Hertz +// * `phase`: adjusts the amount of the offset between the +// waveforms for the left and right channel. At 180, +// the LFOs will be perfectly out of phase. For other +// values, you will hear more moments where the +// overall volume is reduced +// * `shape`: turning `shape` up pushes the waveforms to their +// upper and lower limits, "hardening" their shape +//------------------------------------------------------------ +import("stdfaust.lib"); + +autopan(amount, rate, phase, shape) = _*gainLeft, _*gainRight +with { + + // A saturator + // Assume `x` is a signal between -1 and 1. This function + // pushes the output towards -1 and 1. As the shape + // parameter goes from 0 to 1, an input sine will become + // closer to a square. If `shape` is zero, then the + // function doesn't change the input signal. + saturator(shape, x) = result + with { + // It's ok to replace tanh with another saturator + result = x, ma.tanh(x*10.) : it.interpolate_linear(shape); + }; + + phase2Gain(phase) = os.oscp(rate, phase) + : saturator(shape) // comment out this line to remove the saturator + : it.remap(-1., 1., 1.-amount, 1.); + + gainLeft = 0. : phase2Gain; + gainRight = phase : ma.deg2rad : phase2Gain; +}; + +amount = hslider("[0]Amount[style:knob]", 0., 0., 1., .001); +rate = hslider("[1]Rate[style:knob][unit:Hz][scale:log]", 1., .05, 90., .001); +phase = hslider("[2]Phase[style:knob][unit:°]", 180., 0., 360., 15) : si.smoo; +shape = hslider("[3]Shape[style:knob]", 0., 0., 1., 0.001) : si.smoo; + +process = hgroup("Auto Pan", autopan(amount, rate, phase, shape)); diff --git a/dist/examples/misc/capture.dsp b/dist/examples/misc/capture.dsp new file mode 100644 index 00000000..a6b507d8 --- /dev/null +++ b/dist/examples/misc/capture.dsp @@ -0,0 +1,25 @@ +declare name "capture"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------- +// Capture : record up to 8s of sound and +// playback the recorded sound in loop +//------------------------------------------------- + +import("stdfaust.lib"); + +B = button("Capture"); // Capture sound while pressed +I = int(B); // convert button signal from float to integer +R = (I-I') <= 0; // Reset capture when button is pressed +D = (+(I):*(R))~_; // Compute capture duration while button is pressed: 0..NNNN0..MMM + + +capture = *(B) : (+ : de.delay(8*65536, D-1)) ~ *(1.0-B); + +level = hslider("level (db)", 0, -96, 4, 0.1) : ba.db2linear : si.smoo; + +process = vgroup("Audio Capture", capture : *(level)); + diff --git a/dist/examples/misc/drumkit.dsp b/dist/examples/misc/drumkit.dsp new file mode 100644 index 00000000..a7ad24aa --- /dev/null +++ b/dist/examples/misc/drumkit.dsp @@ -0,0 +1,36 @@ + +//------------------------------------------------- +// A simple, fully generative +// drum machine +//------------------------------------------------- + +import("stdfaust.lib"); + +drumkit(gate, ks, ss, hs) = k_seq, s_seq, h_seq :> /(3) + with { + N = outputs(ks); + env = en.ar(0.001, 0.05); + kick(g) = g : env : *(os.osc(100)); + snare(g) = g : env : *(no.noise : fi.low_shelf(-60, 3000)); + hihat(g) = g : env : *(no.noise : fi.highpass(3, 10000)); + sequencer(t) = t : ba.selectn(N, gate : ba.pulse_countup_loop(N - 1, 1)) : *(gate : mem); + k_seq = sequencer(ks) : kick; + s_seq = sequencer(ss) : snare; + h_seq = sequencer(hs) : hihat; + }; + +drumkit_ui(n) = drumkit(attach(gate, nn), ks, ss, hs) + with { + gate = ba.pulse(ba.tempo(bpm)); + ks = par(i, n, checkbox("v:Drum kit/h:[0]kick/%2i")); + ss = par(i, n, checkbox("v:Drum kit/h:[1]snare/%2i")); + hs = par(i, n, checkbox("v:Drum kit/h:[2]hihat/%2i")); + bpm = hslider("v:Drum kit/[4]BPM", 350, 10, 800, 1); + mon = par(i, n, hbargraph("v:Drum kit/h:[3]seq/%2i[style:led]", 0, 1)); + nn = 1 : ba.selectoutn(n, gate : ba.pulse_countup_loop(n - 1, 1)) : mon :> _; + }; + +drumkit_ui_demo = drumkit_ui(15) <: (_, _); + +process = drumkit_ui_demo; + diff --git a/dist/examples/misc/guitarix.dsp b/dist/examples/misc/guitarix.dsp new file mode 100644 index 00000000..76bd22dc --- /dev/null +++ b/dist/examples/misc/guitarix.dsp @@ -0,0 +1,184 @@ +/* + * Copyright (C) 2009, 2010 Hermann Meyer, James Warden, Andreas Degert + * Copyright (C) 2011 Pete Shorthose + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * ---------------------------------------------------------------------------- + * Adapted version from guitarixlite (v.0.28) using foreign functions + * to this self-contained Faust version (v.0.29) + * Adapted by GRAME - 2014 + * ---------------------------------------------------------------------------- + */ + +declare name "guitarix"; +declare version "0.29"; +declare author "Guitarix project (http://guitarix.sourceforge.net/)"; +declare copyright "Guitarix project"; +declare license "LGPL"; + +ba = library("basics.lib"); +si = library("signals.lib"); + +import("tubes.lib"); +import("tonestacks.lib"); + +process = preamp; + +/**************************************************************** + ** Tube Preamp Emulation with + * tubescreamer - tube stage 1 - 2 - tonestack - cabinet + */ +preamp = hgroup("Guitarix", + hgroup("[0]TubeScreamer",ts9sim) : + hgroup("[1]preamp: 12AX7", stage1 : stage2): + hgroup("[2]tonestack: jcm2000", tstack) : + hgroup("[3]Cabinet", cab)) +with { + + stage1 = T1_12AX7 : *(preamp) : fi.lowpass(1,6531.0) : T2_12AX7 : *(preamp) + with { + preamp = vslider("[0] Pregain [style:knob]",-6,-20,20,0.1) : ba.db2linear : si.smoo; + }; + + stage2 = fi.lowpass(1,6531.0) : T3_12AX7 : *(gain) + with { + gain = vslider("[1] Gain [style:knob]",-6,-20.0,20.0,0.1) : ba.db2linear : si.smoo; + }; + + tstack = jcm2000(t, m, l) + with { + t = vslider("[2] Treble [style:knob]",0.5,0,1,0.01); + m = vslider("[3] Middle [style:knob]",0.5,0,1,0.01); + l = vslider("[4] Bass [style:knob]",0.5,0,1,0.01); + }; + + /* + // Dynamically choose between several 'tstack' + tstack = ba.selectmulti(ma.SR/100, (tjcm2000, tjtm45, tjcm800), + nentry("tstack [style:menu{'tjcm2000':0;'tjtm45':1;'tjcm800':2}]", 0, 0, 2, 1)) + with { + tjcm2000 = jcm2000(t, m, l); + tjtm45 = jtm45(t, m, l); + tjcm800 = jcm800(t, m, l); + t = vslider("[2] Treble [style:knob]",0.5,0,1,0.01); + m = vslider("[3] Middle [style:knob]",0.5,0,1,0.01); + l = vslider("[4] Bass [style:knob]",0.5,0,1,0.01); + }; + */ +}; + + +/**************************************************************************************** + * 1-dimensional function tables for nonlinear interpolation +****************************************************************************************/ +nonlininterpolation(table, low, high, step, size, x) = ts9(low, step, size, table, x),inverse(x) : ccopysign; + +//-- Interpolate value from table +ts9(low, step, size, table, x) = interpolation(table, getCoef(low, step, size, x), + nonlinindex(low, step, x) : boundIndex(size)); + +//-- Calculate non linear index +nonlinindex(low, step, x) = (abs(x)/(3.0 + abs(x)) - low) * step; + +//--Get interpolation factor +getCoef(low, step, size, x) = boundFactor(size, nonlinindex(low, step, x), nonlinindex(low, step, x) : boundIndex(size)); + +/********* Faust Version of ts9nonlin.cc, generated by tools/ts9sim.py ****************/ + +ts9comp = nonlininterpolation(ts9table, low, high, step, size) +with { + +// Characteristics of the wavetable +low = 0.0; +high = 0.970874; +step = 101.97; +size = 99; // (real size = 100, set the actual size at 100-1 for interpolation to work at the last point) + +ts9table = waveform{0.0,-0.0296990148227,-0.0599780676992,-0.0908231643281,-0.122163239629, + -0.15376009788,-0.184938007182,-0.214177260107,-0.239335434213,-0.259232575019, + -0.274433909887,-0.286183308354,-0.29553854444,-0.303222323477,-0.309706249977, + -0.315301338712,-0.320218440785,-0.324604982281,-0.328567120703,-0.332183356975, + -0.335513124719,-0.33860236542,-0.34148724693,-0.344196707008,-0.346754233717, + -0.34917913798,-0.351487480543,-0.35369275887,-0.355806424152,-0.357838275995, + -0.359796767655,-0.361689244919,-0.363522135105,-0.365301098113,-0.367031148289, + -0.368716753588,-0.370361916943,-0.371970243537,-0.373544996828,-0.375089145544, + -0.376605403346,-0.378096262548,-0.379564022938,-0.381010816596,-0.382438629377, + -0.383849319643,-0.385244634694,-0.386626225283,-0.387995658543,-0.389354429565, + -0.39070397188,-0.392045667012,-0.393380853288,-0.39471083403,-0.396036885269, + -0.397360263098,-0.398682210753,-0.400003965547,-0.401326765733,-0.402651857394, + -0.403980501471,-0.405313980999,-0.406653608692,-0.40800073496,-0.409356756504, + -0.410723125631,-0.412101360439,-0.413493056085,-0.414899897347,-0.416323672745, + -0.417766290556,-0.419229797097,-0.420716397759,-0.422228481377,-0.423768648654, + -0.425339745558,-0.426944902828,-0.428587583057,-0.430271637224,-0.432001373102, + -0.433781638746,-0.435617925286,-0.437516494692,-0.439484540257,-0.441530390423, + -0.443663770898,-0.445896146322,-0.448241172434,-0.450715304661,-0.453338632988, + -0.45613605235,-0.45913894467,-0.46238766699,-0.465935359011,-0.469854010456, + -0.474244617411,-0.479255257451,-0.48511588606,-0.492212726244,-0.501272723631 + }; +}; +/****************************************************************************************/ + +/**************************************************************************************** +* declare id "ts9sim"; +* declare name "Tube Screamer"; +* declare category "Distortion"; +* +** based on a circuit diagram of the Ibanez TS-9 and +** a mathematical analysis published by Tamás Kenéz +****************************************************************************************/ + +ts9sim = ts9nonlin : lowpassfilter : *(gain) +with { + + R1 = 4700; + R2 = 51000 + 500000 * vslider("drive[name:Drive][style:knob]", 0.5, 0, 1, 0.01); + C = 0.047 * 1e-6; + a1 = (R1 + R2) * C * 2 * ma.SR; + a2 = R1 * C * 2 * ma.SR; + B0 = (1 + a1) / (1 + a2); + B1 = (1 - a1) / (1 + a2); + A1 = (1 - a2) / (1 + a2); + X2 = fi.tf1(B0, B1, A1); + + ts9nonlin = _ <: _ ,(X2,_ : - : ts9comp) : - :> _; + + fc = vslider("tone[log][name:Tone][style:knob]", 400, 100, 1000, 1.03); + lowpassfilter = fi.lowpass(1,fc); + gain = vslider("level[name:Level][style:knob]", -16, -20, 4, 0.1) : ba.db2linear : si.smoo; +}; + +/**************************************************************************************** +* declare name "cabinet"; +* +** based on a circuit diagram of the Ibanez TS-9 and +** a mathematical analysis published by Tamás Kenéz +****************************************************************************************/ + +wetdry = vslider("[5] amount[style:knob]", 100, 0, 100, 1) : /(100); +dry = 1 - wetdry; + +cab = _<:(*(dry):_), (*(wetdry):fi.conv((0.000488281, -0.0020752, 0.000561523, -0.00231934, 0.000634766, -0.00247803, 0.000512695, -0.00247803, 0.000146484, -0.00219727, -0.000622559, -0.00145264, -0.00202637, + -2.44141e-05, -0.00438232, 0.00247803, -0.00822754, 0.00706787, -0.0159546, 0.0202148, -0.0471558, 0.0953003, -0.208582, 0.312427, 0.75, -0.26803, + 0.399963, 0.200696, -0.146655, -0.29303, -0.222168, -0.113098, 0.0267334, 0.0312134, 0.164685, 0.0443481, 0.186621, 0.0540039, 0.123303, + 0.0805054, 0.0739868, 0.0591797, 0.0661743, 0.0400391, 0.0429932, 0.0339844, 0.0320557, 0.02323, 0.0217285, 0.0182007, 0.0157227, 0.0130005, + 0.0103882, 0.00942383, 0.00718994, 0.0067749, 0.00458984, 0.00455322, 0.00272217, 0.00294189, 0.00140381, 0.00170898, 0.000402832, 0.000720215, -0.000354004, + -2.44141e-05, -0.000915527, -0.000610352, -0.00134277, -0.0010498, -0.00166016, -0.0013916, -0.0019043, -0.00166016, -0.0020874, -0.00187988, -0.00224609, -0.00203857, + -0.00235596, -0.00217285, -0.0024292, -0.0022583, -0.00247803, -0.00233154, -0.00252686, -0.00238037, -0.00256348, -0.0024292, 0.75, -0.00246582, -0.0026001, + -0.00247803, -0.0026001, -0.00249023, -0.0026001, -0.00250244, -0.0026001, -0.00251465, -0.0026001, -0.00251465, -0.0026001, -0.00251465, -0.0026001, -0.00252686, + -0.00258789, -0.00252686, -0.00258789, -0.00251465, -0.00257568, -0.00251465, -0.00256348, -0.00251465, -0.00256348, -0.00251465, -0.00256348, -0.00251465, -0.00256348, + -0.00251465, -0.00256348, -0.00251465, -0.00256348, -0.00252686, -0.00256348, -0.00252686, -0.00255127, -0.00252686, -0.00255127, -0.00252686, -0.00255127, -0.00252686, + -0.00255127, -0.00252686, -0.00256348 + ))):>_; diff --git a/dist/examples/misc/matrix.dsp b/dist/examples/misc/matrix.dsp new file mode 100644 index 00000000..8c9ff168 --- /dev/null +++ b/dist/examples/misc/matrix.dsp @@ -0,0 +1,17 @@ +declare name "matrix"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//----------------------------------------------- +// Audio Matrix : N inputs x M outputs +//----------------------------------------------- + +import("stdfaust.lib"); + +Fader(in) = ba.db2linear(vslider("Input %in", -10, -96, 4, 0.1)); +Mixer(N,out) = hgroup("Output %out", par(in, N, *(Fader(in)) ) :> _ ); +Matrix(N,M) = tgroup("Matrix %N x %M", par(in, N, _) <: par(out, M, Mixer(N, out))); + +process = Matrix(8, 8); diff --git a/dist/examples/misc/midiTester.dsp b/dist/examples/misc/midiTester.dsp new file mode 100644 index 00000000..f4eb1758 --- /dev/null +++ b/dist/examples/misc/midiTester.dsp @@ -0,0 +1,122 @@ +declare name "midiTester"; +declare version "1.0"; +declare author "Vincent Rateau, GRAME"; +declare license "GPL v3"; +declare reference "www.sonejo.net"; + +// FAUST MIDI TESTER + +process = _*0, (vgroup("FAUST MIDI TESTER", hgroup("[1]", controltester, controlchantester, noteontester, noteonchantester, noteofftester, noteoffchantester, keypresschantester, midiclocktester), hgroup("[2]", kattester, katchantester, pctester, pcchantester, chattester, chatchantester, pitchwheeltester, pitchwheelchantester) :> _)) : attach; + +/////////////////////////// + +//Ctrl tester (ctrl ): tester(midi in, midi out) +controltester = vgroup("CTRL IN/OUT", valuetest(50,51), booltest(100,101)) +with{ +valuetest(i,o) = hslider("Ctrl Value IN (Ctrl %i) [midi:ctrl %i]", 60, 0, 127, 1) : hbargraph("Ctrl Value OUT (Ctrl %o) [midi:ctrl %o]", 0, 127); +booltest(i,o) = checkbox("Ctrl Bool IN (Ctrl %i) [midi:ctrl %i]") : hbargraph("Ctrl Bool OUT (Ctrl %o) [midi:ctrl %o]", 0, 1); +}; + +//Ctrl Chan tester (ctrl chan): tester(midi in, midi out) +controlchantester = vgroup("CTRL CHAN IN/OUT", valuetest(50,2,74,3)) +with{ +valuetest(i,ic,o,oc) = hslider("Ctrl Value IN (Ctrl %i Channel %ic) [midi:ctrl %i %ic]", 60, 0, 127, 1) : hbargraph("Ctrl Value OUT (Ctrl %o) Channel OUT(Chan %oc) [midi:ctrl %o %oc]", 0, 127); +}; + +//Note tester (keyon) : tester(midi in, midi out) +noteontester = vgroup("NOTE ON IN/OUT", valuetest(50,51), booltest(100,101)) +with{ +valuetest(i,o) = hslider("NoteOn Value IN (Note %i) [midi:keyon %i]", 60, 0, 127, 1) : hbargraph("NoteOn Value OUT (Note %o) [midi:keyon %o]", 0, 127); +booltest(i,o) = checkbox("NoteOn Bool IN (Note %i) [midi:keyon %i]") : hbargraph("NoteOn Bool OUT (Note %o) [midi:keyon %o]", 0, 1); +}; + +//Note Chan tester (keyon) : tester(midi in, midi out) +noteonchantester = vgroup("NOTE ON CHAN IN/OUT", valuetest(50, 2, 51, 3), booltest(50, 2, 101, 3)) +with{ +valuetest(i, ic, o, oc) = hslider("NoteOn Value IN (Note %i Channel %ic) [midi:keyon %i %ic]", 60, 0, 127, 1) : hbargraph("NoteOn Value OUT (Note %o Chan %oc) [midi:keyon %o %oc]", 0, 127); +booltest(i, ic, o, oc) = checkbox("NoteOn Chan Bool IN (Note %i Channel %ic) [midi:keyon %i %ic]") : hbargraph("NoteOn Chan Bool OUT (Note %o Channel %oc) [midi:keyon %o %oc]", 0, 1); +}; + +//Note tester (keyoff) : tester(midi in, midi out) +noteofftester = vgroup("NOTE OFF IN/OUT", valuetest(50,51), booltest(100,101)) +with{ +valuetest(i,o) = hslider("NoteOff Value IN (Note %i) [midi:keyoff %i]", 60, 0, 127, 1) : hbargraph("NoteOff Value OUT (Note %o) [midi:keyoff %o]", 0, 127); +booltest(i,o) = checkbox("NoteOff Bool IN (Note %i) [midi:keyoff %i]") : hbargraph("NoteOff Bool OUT (Note %o) [midi:keyoff %o]", 0, 1); +}; + +//Note Chan tester (keyoff) : tester(midi in, midi out) +noteoffchantester = vgroup("NOTE OFF CHAN IN/OUT", valuetest(50, 2, 51, 3), booltest(50, 2, 101, 3)) +with{ +valuetest(i, ic, o, oc) = hslider("NoteOff Value IN (Note %i Channel %ic) [midi:keyoff %i %ic]", 60, 0, 127, 1) : hbargraph("NoteOff Value OUT (Note %o Channel %oc) [midi:keyoff %o %oc]", 0, 127); +booltest(i, ic, o, oc) = checkbox("NoteOff Bool IN (Note %i Channel %ic) [midi:keyoff %i %ic]") : hbargraph("NoteOff Bool OUT (Note %o Channel %oc) [midi:keyoff %o %oc]", 0, 1); +}; + +//KeyPress Chan tester (keypress) : tester(midi in, midi out) +keypresschantester = vgroup("KEY PRESS CHAN IN/OUT", valuetest(50, 2, 51, 3), booltest(50, 2, 101, 3)) +with{ +valuetest(i, ic, o, oc) = hslider("Pressure Value IN (Note %i Channel %ic) [midi:keypress %i %ic]", 60, 0, 127, 1) : hbargraph("Note Value OUT (Note %o Channel %oc) [midi:keypress %o %oc]", 0, 127); +booltest(i, ic, o, oc) = checkbox("Pressure Bool IN (Note %i Channel %ic) [midi:keypress %i %ic]") : hbargraph("Pressure Bool OUT (Note %o Channel %oc) [midi:keypress %o %oc]", 0, 1); +}; + +//Midisync tester +midiclocktester = vgroup("MIDI SYNC (IN)", clock, startstop) +with{ +clock = checkbox("MIDI clock signal [midi:clock]"); +startstop = checkbox("MIDI START/STOP [midi:start] [midi:stop]"); +}; + +//Key Aftertouch tester (keypress) : tester(midi in, midi out) +kattester = vgroup("KEY AFTERTOUCH (KAT) IN/OUT",valuetest(50,51), booltest(100,101)) +with{ +valuetest(i,o) = hslider("Note KAT Value IN (Note %i) [midi:keypress %i]", 60, 0, 127, 1) : hbargraph("Note KAT Value OUT (Note %o) [midi:keypress %o]", 0, 127); +booltest(i,o) = checkbox("Note KAT Bool IN (Note %i) [midi:keypress %i]") : hbargraph("Note KAT Bool OUT (Note %o) [midi:keypress %o]", 0, 1); +}; + +//Key Aftertouch tester (keypress) : tester(midi in, midi out) +katchantester = vgroup("KEY AFTERTOUCH CHAN (KAT) IN/OUT",valuetest(50,2,51,3), booltest(100,2,101,3)) +with{ +valuetest(i,ic,o,oc) = hslider("Note KAT Value IN (Note %i) (Chan %ic) [midi:keypress %i %ic]", 60, 0, 127, 1) : hbargraph("Note KAT Value OUT (Note %o) (Chan %oc) [midi:keypress %o %oc]", 0, 127); +booltest(i,ic,o,oc) = checkbox("Note KAT Bool IN (Note %i) (Chan %ic) [midi:keypress %i %ic]") : hbargraph("Note KAT Bool OUT (Note %o) (Chan %oc)[midi:keypress %o %oc]", 0, 1); +}; + +//ProgramChange tester (pgm) : tester(midi in, midi out) +pctester = vgroup("PROGRAM CHANGE (PC) IN/OUT",valuetest(1,2), booltest(1,2)) +with{ +valuetest(i,o) = hslider("ProgramChange Value IN (PC %i) [midi:pgm %i]", 60, 0, 127, 1) : hbargraph("ProgramChange Value OUT (PC %o) [midi:pgm %o]", 0, 127); +booltest(i,o) = checkbox("ProgramChange Bool IN (PC %i) [midi:pgm %i]") : hbargraph("ProgramChange Bool OUT (PC %o) [midi:pgm %o]", 0, 1); +}; + +//ProgramChange Chan tester (pgm) : tester(midi in, midi out) +pcchantester = vgroup("PROGRAM CHANGE CHAN (PC) IN/OUT",valuetest(1, 2, 2, 3), booltest(1, 2, 2, 3)) +with{ +valuetest(i,ic,o,oc) = hslider("ProgramChange Value IN (PC %i) (CHAN %ic) [midi:pgm %i %ic]", 60, 0, 127, 1) : hbargraph("ProgramChange Value OUT (PC %o) (CHAN %oc) [midi:pgm %o %oc]", 0, 127); +booltest(i,ic,o,oc) = checkbox("ProgramChange Bool IN (PC %i) (CHAN %ic) [midi:pgm %i %ic]") : hbargraph("ProgramChange Bool OUT (PC %o) (CHAN %oc) [midi:pgm %o %oc]", 0, 1); +}; + +//Channel Aftertourch tester (chanpress) : tester(midi in, midi out) +chattester = vgroup("CHANNEL AFTERTOUCH (CHAT) IN/OUT",valuetest(50,51), booltest(100,101)) +with{ +valuetest(i,o) = hslider("Note CHAT Value IN (Note %i) [midi:chanpress %i]", 60, 0, 127, 1) : hbargraph("Note CHAT Value OUT (Note %o) [midi:chanpress %o]", 0, 127); +booltest(i,o) = checkbox("Note CHAT Bool IN (Note %i) [midi:chanpress %i]") : hbargraph("Note CHAT Bool OUT (Note %o) [midi:chanpress %o]", 0, 1); +}; + +//Channel Aftertourch tester (chanpress) : tester(midi in, midi out) +chatchantester = vgroup("CHANNEL AFTERTOUCH CHAN (CHAT) IN/OUT",valuetest(50,2,51,3), booltest(100,2,101,3)) +with{ +valuetest(i,ic,o,oc) = hslider("Note CHAT Chan Value IN (Note %i) (Chan %ic) [midi:chanpress %i %ic]", 60, 0, 127, 1) : hbargraph("Note CHAT Value OUT (Note %o) (Chan %oc) [midi:chanpress %o %oc]", 0, 127); +booltest(i,ic,o,oc) = checkbox("Note CHAT Bool IN (Note %i) (Chan %ic) [midi:chanpress %i %ic]") : hbargraph("Note CHAT Bool OUT (Note %o) (Chan %oc) [midi:chanpress %o %oc]", 0, 1); +}; + +//Pitchwheel tester (pitchwheel) : tester(midi in, midi out) +pitchwheeltester = vgroup("PITCHWHEEL IN/OUT",valuetest, booltest) +with{ +valuetest = hslider("Pitchwheel Value IN [midi:pitchwheel]", 0, -8192, 8191, 1) : hbargraph("Pitchwheel Value OUT[midi:pitchwheel]", -8192, 8191); +booltest = checkbox("Pitchwheel Bool IN [midi:pitchwheel]") : hbargraph("Pitchwheel Bool OUT [midi:pitchwheel]", 0, 1); +}; + +//Pitchwheel Chan tester (pitchwheel) : tester(midi in, midi out) +pitchwheelchantester = vgroup("PITCHWHEEL CHAN IN/OUT",valuetest(2, 15), booltest(2, 15)) +with{ +valuetest(ic, oc) = hslider("Pitchwheel Value IN (Chan %ic) [midi:pitchwheel %ic]", 0, -8192, 8191, 1) : hbargraph("Pitchwheel Value OUT (Chan %oc)[midi:pitchwheel %oc]", -8192, 8191); +booltest(ic, oc) = checkbox("Pitchwheel Bool IN (Chan %ic) [midi:pitchwheel %ic]") : hbargraph("Pitchwheel Bool OUT (Chan %oc) [midi:pitchwheel %oc]", 0, 1); +}; diff --git a/dist/examples/misc/mixer.dsp b/dist/examples/misc/mixer.dsp new file mode 100644 index 00000000..93e2b93f --- /dev/null +++ b/dist/examples/misc/mixer.dsp @@ -0,0 +1,21 @@ +declare name "mixer"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------- +// Simple 8x2 mixer +//------------------------------------------------- + +vol = component("../dynamic/volume.dsp"); +pan = component("../spat/panpot.dsp"); +vumeter = component("../analysis/vumeter.dsp").vmeter; +mute = *(1 - checkbox("mute")); + +voice(v) = vgroup("Ch %v", mute : hgroup("[2]", vol : vumeter) : pan); +stereo = hgroup("stereo out", (vol, vol : vgroup("L", vumeter), vgroup("R", vumeter))); + +process = hgroup("mixer", par(i, 8, voice(i)) :> stereo ); + + diff --git a/dist/examples/misc/statespace.dsp b/dist/examples/misc/statespace.dsp new file mode 100644 index 00000000..34b191c7 --- /dev/null +++ b/dist/examples/misc/statespace.dsp @@ -0,0 +1,39 @@ +declare name "statespace"; +declare version "1.0"; +declare author "JOS"; +declare license "MIT"; +declare copyright "(c) Julius O. Smith III, 2020"; + +//----------------------------------------------- +// General Linear State-Space Model Example +//----------------------------------------------- + +import("stdfaust.lib"); + +p = 2; // number of inputs +q = 3; // number of outputs +N = 5; // number of states + +A = matrix(N,N); // state transition matrix +B = matrix(N,p); // input-to-states matrix +C = matrix(q,N); // states-to-output matrix +D = matrix(q,p); // direct-term matrix, bypassing state + +// ./matrix.dsp with M and N transposed to follow convention: +matrix(M,N) = tgroup("Matrix: %M x %N", par(in, N, _) + <: par(out, M, mixer(N, out))) with { + fader(in) = ba.db2linear(vslider("Input %in", -10, -96, 4, 0.1)); + mixer(N,out) = hgroup("Output %out", par(in, N, *(fader(in)) ) :> _ ); +}; + +Bd = par(i,p,mem) : B; // input delay needed for conventional definition +vsum(N) = si.bus(2*N) :> si.bus(N); // vector sum of two N-vectors + +// Illustrate nonzero initial state, following conventional definition: +impulse = 1-1'; // For zero initial state, set impulse = 0 or simplify code +x0 = par(i,N,i*impulse); // initial state = (0,1,2,3,...,N-1) + +system = si.bus(p) <: D, (Bd : vsum(N)~(A), x0 : vsum(N) : C) :> si.bus(q); + +process = system; + diff --git a/dist/examples/misc/switcher.dsp b/dist/examples/misc/switcher.dsp new file mode 100644 index 00000000..a174185e --- /dev/null +++ b/dist/examples/misc/switcher.dsp @@ -0,0 +1,22 @@ +declare name "switcher"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2007"; + +//----------------------------------------------- +// Switch between two stereo sources. +// Useful to compare these two sources +// The parameter c\in{0,1} indicates the +// channels to select +//----------------------------------------------- + +switch(c,x0,x1,y0,y1) = sel(c,x0,y0), sel(c,x1,y1) + with { + sel(c,x,y) = (1-c)*x + c*y; + }; + +process = switch(hslider("source 0 <-> source 1",0,0,1,1)); + + + diff --git a/dist/examples/misc/tester.dsp b/dist/examples/misc/tester.dsp new file mode 100644 index 00000000..39b8998a --- /dev/null +++ b/dist/examples/misc/tester.dsp @@ -0,0 +1,35 @@ +declare name "tester"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//----------------------------------------------- +// Tester : tests louspeakers +// Send a test signal( sine, noise, pink) to one +// of 8 loudspeakers +//----------------------------------------------- + +import("stdfaust.lib"); + +// TODO: this should be rewritten with the pink noise function of noises.lib +pink = f : (+ ~ g) with { + f(x) = 0.04957526213389*x - 0.06305581334498*x' + 0.01483220320740*x''; + g(x) = 1.80116083982126*x - 0.80257737639225*x'; +}; + +// User interface +//---------------- +vol = hslider("[2] volume [unit:dB]", -96, -96, 0, 1): ba.db2linear : si.smoo; +freq = hslider("[1] freq [unit:Hz]", 1000, 10, 20000, 1); +dest = hslider("[3] destination", 0, 0, 8, 1); + +testsignal = os.osci(freq)*checkbox("sine wave") + + no.noise * checkbox("white noise") + + pink(no.noise) * ba.db2linear(20) * checkbox("pink noise"); + +process = vgroup( "Audio Tester", + testsignal*vol + <: par(i, 8, *(dest==i)) + ); + diff --git a/dist/examples/misc/tester2.dsp b/dist/examples/misc/tester2.dsp new file mode 100644 index 00000000..f07893e4 --- /dev/null +++ b/dist/examples/misc/tester2.dsp @@ -0,0 +1,34 @@ +declare name "tester2"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2014"; + +//----------------------------------------------- +// Stereo Audio Tester : send a test signal (sine, +// noise, pink) on a stereo channel +//----------------------------------------------- + +import("stdfaust.lib"); + +pink = f : (+ ~ g) with { + f(x) = 0.04957526213389*x - 0.06305581334498*x' + 0.01483220320740*x''; + g(x) = 1.80116083982126*x - 0.80257737639225*x'; +}; + +// User interface +//---------------- +transition(n) = \(old,new).(ba.if(old fl.spectral_level_demo <: _,_; + +fx_stack = + vgroup("[1]", dm.sawtooth_demo) <: + vgroup("[2]", dm.flanger_demo) : + vgroup("[3]", dm.phaser2_demo); + +level_viewer(x,y) = attach(x, vgroup("[4]", dm.spectral_level_demo(x+y))),y; + +process = fx_stack : level_viewer; diff --git a/dist/examples/physicalModeling/brass.dsp b/dist/examples/physicalModeling/brass.dsp new file mode 100644 index 00000000..db73aa8d --- /dev/null +++ b/dist/examples/physicalModeling/brass.dsp @@ -0,0 +1,8 @@ +declare name "Brass"; +declare description "Simple brass instrument physical model with physical parameters."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.brass_ui <: _,_; diff --git a/dist/examples/physicalModeling/brassMIDI.dsp b/dist/examples/physicalModeling/brassMIDI.dsp new file mode 100644 index 00000000..b550b9ab --- /dev/null +++ b/dist/examples/physicalModeling/brassMIDI.dsp @@ -0,0 +1,8 @@ +declare name "BrassMIDI"; +declare description "Simple MIDI-controllable brass instrument physical model with physical parameters."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.brass_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/churchBell.dsp b/dist/examples/physicalModeling/churchBell.dsp new file mode 100644 index 00000000..6bdaece5 --- /dev/null +++ b/dist/examples/physicalModeling/churchBell.dsp @@ -0,0 +1,8 @@ +declare name "ChurchBell"; +declare description "Generic church bell physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.churchBell_ui <: _,_; diff --git a/dist/examples/physicalModeling/clarinet.dsp b/dist/examples/physicalModeling/clarinet.dsp new file mode 100644 index 00000000..dc4588fc --- /dev/null +++ b/dist/examples/physicalModeling/clarinet.dsp @@ -0,0 +1,8 @@ +declare name "Clarinet"; +declare description "Simple clarinet physical model with physical parameters."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.clarinet_ui <: _,_; diff --git a/dist/examples/physicalModeling/clarinetMIDI.dsp b/dist/examples/physicalModeling/clarinetMIDI.dsp new file mode 100644 index 00000000..a0905099 --- /dev/null +++ b/dist/examples/physicalModeling/clarinetMIDI.dsp @@ -0,0 +1,8 @@ +declare name "ClarinetMIDI"; +declare description "Simple MIDI-controllable clarinet physical model with physical parameters."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.clarinet_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/djembeMIDI.dsp b/dist/examples/physicalModeling/djembeMIDI.dsp new file mode 100644 index 00000000..2205c7fb --- /dev/null +++ b/dist/examples/physicalModeling/djembeMIDI.dsp @@ -0,0 +1,8 @@ +declare name "DjembeMIDI"; +declare description "Simple MIDI-controllable djembe physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.djembe_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/elecGuitarMIDI.dsp b/dist/examples/physicalModeling/elecGuitarMIDI.dsp new file mode 100644 index 00000000..7231a0c5 --- /dev/null +++ b/dist/examples/physicalModeling/elecGuitarMIDI.dsp @@ -0,0 +1,10 @@ +declare name "ElecGuitarMidi"; +declare description "Simple electric guitar model without effect chain."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +// TODO: We could potentially add an audio effect chain here + +process = pm.elecGuitar_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/englishBell.dsp b/dist/examples/physicalModeling/englishBell.dsp new file mode 100644 index 00000000..63b4eb64 --- /dev/null +++ b/dist/examples/physicalModeling/englishBell.dsp @@ -0,0 +1,8 @@ +declare name "EnglishChurchBell"; +declare description "English church bell physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.englishBell_ui <: _,_; diff --git a/dist/examples/physicalModeling/faust-stk/NLFeks.dsp b/dist/examples/physicalModeling/faust-stk/NLFeks.dsp new file mode 100644 index 00000000..be0dd05a --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/NLFeks.dsp @@ -0,0 +1,91 @@ +declare name "NLFeks"; +declare author "Julius Smith and Romain Michon"; +declare version "1.0"; +declare license "STK-4.3"; +declare copyright "Julius Smith"; +declare reference "http://ccrma.stanford.edu/~jos/pasp/vegf.html"; +// -> Virtual\_Electric\_Guitars\_Faust.html"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +// standard MIDI voice parameters: +// NOTE: The labels MUST be "freq", "gain", and "gate" for faust2pd +freq = nentry("freq", 440, 20, 7040, 1); // Hz +gain = nentry("gain", 1, 0, 10, 0.01); // 0 to 1 +gate = button("gate"); // 0 or 1 + +// Additional parameters (MIDI "controllers"): + +// Pick angle in [0,0.9]: +pickangle = 0.9 * hslider("pick_angle",0,0,0.9,0.1); + +// Normalized pick-position in [0,0.5]: +beta = hslider("pick_position [midi: ctrl 0x81]", 0.13, 0.02, 0.5, 0.01); + // MIDI Control 0x81 often "highpass filter frequency" + +// String decay time in seconds: +t60 = hslider("decaytime_T60", 4, 0, 10, 0.01); // -60db decay time (sec) + +// Normalized brightness in [0,1]: +B = hslider("brightness [midi:ctrl 0x74]", 0.5, 0, 1, 0.01);// 0-1 + // MIDI Controller 0x74 is often "brightness" + // (or VCF lowpass cutoff freq) + +// Dynamic level specified as dB level desired at Nyquist limit: +L = hslider("dynamic_level", -10, -60, 0, 1) : ba.db2linear; +// Note: A lively clavier is obtained by tying L to gain (MIDI velocity). + +//Nonlinear filter parameters +typeModulation = nentry("v:Nonlinear Filter/typeMod",0,0,4,1); +nonLinearity = hslider("Nonlinearity",0,0,1,0.01) : si.smoo; +frequencyMod = hslider("freqMod",220,20,1000,0.1) : si.smoo; + +//==================== SIGNAL PROCESSING ================ + +//----------------------- noiseburst ------------------------- +// White noise burst (adapted from Faust's karplus.dsp example) +// Requires music.lib (for noise) +noiseburst(gate,P) = no.noise : *(gate : trigger(P)) +with { + diffgtz(x) = (x-x') > 0; + decay(n,x) = x - (x>0)/n; + release(n) = + ~ decay(n); + trigger(n) = diffgtz : release(n) : > (0.0); +}; + +nlfOrder = 6; +P = ma.SR/freq ; // fundamental period in samples +Pmax = 4096; // maximum P (for delay-line allocation) + +ppdel = beta*P; // pick position delay +pickposfilter = fi.ffcombfilter(Pmax,ppdel,-1); + +excitation = noiseburst(gate,P) : *(gain); // defined in route.lib + +rho = pow(0.001,1.0/(freq*t60)); // multiplies loop-gain + +// Original EKS damping filter: +b1 = 0.5*B; b0 = 1.0-b1; // S and 1-S +dampingfilter1(x) = rho * ((b0 * x) + (b1 * x')); + +// Linear phase FIR3 damping filter: +h0 = (1.0 + B)/2; h1 = (1.0 - B)/4; +dampingfilter2(x) = rho * (h0 * x' + h1*(x+x'')); + +loopfilter = dampingfilter2; // or dampingfilter1 + +filtered_excitation = excitation : si.smooth(pickangle) + : pickposfilter;// : levelfilter(L,freq); + +//nonlinear allpass filter (nonLinearModulator is declared in instruments.lib) +NLFM = nonLinearModulator(nonLinearity,1,freq,typeModulation,frequencyMod,nlfOrder); + +//declared in instruments.lib +stereo = stereoizer(P); + +stringloop = (+ : de.fdelay4(Pmax, P-2)) ~ (loopfilter : NLFM); + +process = filtered_excitation : stringloop : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/NLFfm.dsp b/dist/examples/physicalModeling/faust-stk/NLFfm.dsp new file mode 100644 index 00000000..63d8447a --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/NLFfm.dsp @@ -0,0 +1,70 @@ +declare name "NLFfm"; +declare description "FM synthesizer implemented with a nonlinear passive allpass filter"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",0.8,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[2][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[2][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[2][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[2][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[3][unit:Hz]",5,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[3][tooltip:A value between 0 and 1]",0.1,0,1,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[3][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[3][unit:s][tooltip:Vibrato release duration]",0.01,0,2,0.01); + +envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack +[4][unit:s][tooltip:Envelope attack duration]",0.05,0,2,0.01); +envelopeDecay = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Decay +[4][unit:s][tooltip:Envelope decay duration]",0.05,0,2,0.01); +envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release +[4][unit:s][tooltip:Envelope release duration]",0.05,0,2,0.01); + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 3; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, + typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Algorithm implementation ---------------------------- + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//vibrato gain is controlled by envVibrato (declared in instruments.lib) +vibrato = os.osc(vibratoFreq)*vibratoGain*envVibrato(0.1*2*vibratoAttack,0.9*2*vibratoAttack,100,vibratoRelease,gate); + +//output gain is controlled by an adsr envelope +envelope = en.adsr(envelopeAttack,envelopeDecay,0.9,envelopeRelease,gate)*gain; +breath = envelope + envelope*vibrato; + +process = os.osc(freq)*breath : NLFM : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/blowBottle.dsp b/dist/examples/physicalModeling/faust-stk/blowBottle.dsp new file mode 100644 index 00000000..e4d9e867 --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/blowBottle.dsp @@ -0,0 +1,102 @@ +declare name "blowBottle"; +declare description "Blown Bottle Instrument"; +declare author "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare copyright "Romain Michon"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This object implements a helmholtz resonator (biquad filter) with a polynomial jet excitation (a la Cook)."; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +noiseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Noise_Gain +[2][tooltip:Breath noise gain (value between 0 and 1)]",0.5,0,1,0.01)*2; +pressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Pressure +[2][tooltip:Breath pressure (value bewteen 0 and 1)]",1,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[4][unit:Hz]",5,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[4][tooltip:A value between 0 and 1]",0.1,0,1,0.01); +vibratoBegin = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Begin +[4][unit:s][tooltip:Vibrato silence duration before attack]",0.05,0,2,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[4][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[4][unit:s][tooltip:Vibrato release duration]",0.01,0,2,0.01); + +envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack +[5][unit:s][tooltip:Envelope attack duration]",0.01,0,2,0.01); +envelopeDecay = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Decay +[5][unit:s][tooltip:Envelope decay duration]",0.01,0,2,0.01); +envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release +[5][unit:s][tooltip:Envelope release duration]",0.5,0,2,0.01); + + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, +typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//botlle radius +bottleRadius = 0.999; + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +bandPassFilter = bandPass(freq,bottleRadius); + +//----------------------- Algorithm implementation ---------------------------- + +//global envelope is of type attack - decay - sustain - release +envelopeG = gain*en.adsr(gain*envelopeAttack,envelopeDecay,1,envelopeRelease,gate); + +//pressure envelope is also ADSR +envelope = pressure*en.adsr(gain*0.02,0.01,1,gain*0.2,gate); + +//vibrato +vibrato = os.osc(vibratoFreq)*vibratoGain*envVibrato(vibratoBegin,vibratoAttack,100,vibratoRelease,gate)*os.osc(vibratoFreq); + +//breat pressure +breathPressure = envelope + vibrato; + +//breath noise +randPressure = noiseGain*no.noise*breathPressure ; + +process = + //differential pressure + (-(breathPressure) <: + ((+(1))*randPressure : +(breathPressure)) - *(jetTable),_ : bandPassFilter,_)~NLFM : !,_ : + //signal scaling + fi.dcblocker*envelopeG*0.5 : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/bowed.dsp b/dist/examples/physicalModeling/faust-stk/bowed.dsp new file mode 100644 index 00000000..ba46ce6e --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/bowed.dsp @@ -0,0 +1,114 @@ +declare name "bowed"; +declare description "Nonlinear WaveGuide Bowed Instrument"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "A bowed string model, a la Smith (1986), after McIntyre, Schumacher, Woodhouse (1983)."; +declare reference "https://ccrma.stanford.edu/~jos/pasp/Bowed_Strings.html"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +bowPosition = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Position +[2][tooltip:Bow position along the string (value between 0 and 1)]",0.7,0.01,1,0.01); +bowPressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Pressure +[2][tooltip:Bow pressure on the string (value between 0 and 1)]",0.75,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[4][unit:Hz]",6,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[4][tooltip:A value between 0 and 1]",0.01,0,1,0.01); +vibratoBegin = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Begin +[4][unit:s][tooltip:Vibrato silence duration before attack]",0.05,0,2,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[4][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[4][unit:s][tooltip:Vibrato release duration]",0.01,0,2,0.01); + +envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack +[5][unit:s][tooltip:Envelope attack duration]",0.01,0,2,0.01); +envelopeDecay = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Decay +[5][unit:s][tooltip:Envelope decay duration]",0.05,0,2,0.01); +envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release +[5][unit:s][tooltip:Envelope release duration]",0.1,0,2,0.01); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, + typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//Parameters for the bow table +tableOffset = 0; +tableSlope = 5 - (4*bowPressure); + +//the bow table is declared in instruments.lib +bowTable = bow(tableOffset,tableSlope); + +//a attack - decay - sustain - release envelope is used +envelope = en.adsr(gain*envelopeAttack,envelopeDecay,1, (1-gain)*envelopeRelease,gate); +maxVelocity = 0.03 + (0.2 * gain); + +//Delay lines declaration and vibrato, the length of the two delay lines are evolving propotionally +betaRatio = 0.027236 + (0.2*bowPosition); +fdelneck = (ma.SR/freq-4)*(1 - betaRatio); +vibratoEnvelope = envVibrato(vibratoBegin,vibratoAttack,100,vibratoRelease,gate); +vibrato = fdelneck + ((ma.SR/freq - 4)*vibratoGain*vibratoEnvelope*os.osc(vibratoFreq)); +neckDelay = de.fdelay(4096,vibrato); +fdelbridge = (ma.SR/freq - 4)*betaRatio; +bridgeDelay = de.delay(4096,fdelbridge); + +//Body Filter: a biquad filter with a normalized pick gain (declared in instruments.lib) +bodyFilter = bandPass(500,0.85); + +//String Filter: a lowpass filter (declared in instruments.lib) +stringFilter = *(0.95) : -onePole(b0,a1) + with{ + pole = 0.6 - (0.1*22050/ma.SR); + gain = 0.95; + b0 = 1-pole; + a1 = -pole; + }; + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//----------------------- Algorithm implementation ---------------------------- + +bowVelocity = envelope*maxVelocity; +instrumentBody(feedBckBridge) = (*(-1) <: +(feedBckBridge),_ : (bowVelocity-_ <: *(bowTable) <: _,_),_ : + _, + : +(feedBckBridge),_) ~ (neckDelay) : !,_; + +process = (stringFilter : instrumentBody) ~ (bridgeDelay : NLFM) : bodyFilter(*(0.2)) : + _*gain*8 : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/brass.dsp b/dist/examples/physicalModeling/faust-stk/brass.dsp new file mode 100644 index 00000000..357c0a1c --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/brass.dsp @@ -0,0 +1,103 @@ +declare name "brass"; +declare description "WaveGuide Brass instrument from STK"; +declare author "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare copyright "Romain Michon"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "A simple brass instrument waveguide model, a la Cook (TBone, HosePlayer)."; +declare reference "https://ccrma.stanford.edu/~jos/pasp/Brasses.html"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +pressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Pressure +[2][tooltip:A value between 0 and 1]",1,0.01,1,0.01); +lipTension = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Lip_Tension +[2][tooltip:A value between 0 and 1]",0.780,0.01,1,0.001); +slideLength = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Slide_Length +[2][tooltip:A value between 0 and 1]",0.041,0.01,1,0.001); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[4][unit:Hz]",6,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[4][tooltip:A value between 0 and 1]",0.05,0,1,0.01); +vibratoBegin = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Begin +[4][unit:s][tooltip:Vibrato silence duration before attack]",0.05,0,2,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[4][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[4][unit:s][tooltip:Vibrato release duration]",0.1,0,2,0.01); + +envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack +[5][unit:s][tooltip:Envelope attack duration]",0.005,0,2,0.01); +envelopeDecay = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Decay +[5][unit:s][tooltip:Envelope decay duration]",0.001,0,2,0.01); +envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release +[5][unit:s][tooltip:Envelope release duration]",0.07,0,2,0.01); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, + typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//lips are simulated by a biquad filter whose output is squared and hard-clipped, bandPassH and saturationPos are declared in instruments.lib +lipFilterFrequency = freq*pow(4,(2*lipTension)-1); +lipFilter = *(0.03) : bandPassH(lipFilterFrequency,0.997) <: * : saturationPos; + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//delay times in number of samples +slideTarget = ((ma.SR/freq)*2 + 3)*(0.5 + slideLength); +boreDelay = de.fdelay(4096,slideTarget); + +//----------------------- Algorithm implementation ---------------------------- + +//vibrato +vibrato = vibratoGain*os.osc(vibratoFreq)*envVibrato(vibratoBegin,vibratoAttack,100,vibratoRelease,gate); + +//envelope (Attack / Decay / Sustain / Release), breath pressure and vibrato +breathPressure = pressure*en.adsr(envelopeAttack,envelopeDecay,1,envelopeRelease,gate) + vibrato; +mouthPressure = 0.3*breathPressure; + +//scale the delay feedback +borePressure = *(0.85); + +//differencial presure +deltaPressure = mouthPressure - _; + +process = (borePressure <: deltaPressure,_ : + (lipFilter <: *(mouthPressure),(1-_)),_ : _, * :> + : + fi.dcblocker) ~ (boreDelay : NLFM) : + *(gain)*4 : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/clarinet.dsp b/dist/examples/physicalModeling/faust-stk/clarinet.dsp new file mode 100644 index 00000000..4adb679b --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/clarinet.dsp @@ -0,0 +1,110 @@ +declare name "clarinet"; +declare description "Nonlinear WaveGuide Clarinet"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "A simple clarinet physical model, as discussed by Smith (1986), McIntyre, Schumacher, Woodhouse (1983), and others."; +declare reference "https://ccrma.stanford.edu/~jos/pasp/Woodwinds.html"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +reedStiffness = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Reed_Stiffness +[2][tooltip:Reed stiffness (value between 0 and 1)]",0.5,0,1,0.01); +noiseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Noise_Gain +[2][tooltip:Breath noise gain (value between 0 and 1)]",0,0,1,0.01); +pressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Pressure +[2][tooltip:Breath pressure (value bewteen 0 and 1)]",1,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[4][unit:Hz]",5,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[4][tooltip:A value between 0 and 1]",0.1,0,1,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[4][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[4][unit:s][tooltip:Vibrato release duration]",0.01,0,2,0.01); + +envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack +[5][unit:s][tooltip:Envelope attack duration]",0.01,0,2,0.01); +envelopeDecay = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Decay +[5][unit:s][tooltip:Envelope decay duration]",0.05,0,2,0.01); +envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release +[5][unit:s][tooltip:Envelope release duration]",0.1,0,2,0.01); + +//==================== SIGNAL PROCESSING ====================== + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, + typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//reed table parameters +reedTableOffset = 0.7; +reedTableSlope = -0.44 + (0.26*reedStiffness); + +//the reed function is declared in instruments.lib +reedTable = reed(reedTableOffset,reedTableSlope); + +//delay line with a length adapted in function of the order of nonlinear filter +delayLength = ma.SR/freq*0.5 - 1.5 - (nlfOrder*nonLinearity)*(typeModulation < 2); +delayLine = de.fdelay(4096,delayLength); + +//one zero filter used as a allpass: pole is set to -1 +filter = oneZero0(0.5,0.5); + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//----------------------- Algorithm implementation ---------------------------- + +//Breath pressure + vibrato + breath noise + envelope (Attack / Decay / Sustain / Release) +envelope = en.adsr(envelopeAttack,envelopeDecay,1,envelopeRelease,gate)*pressure*0.9; + +vibrato = os.osc(vibratoFreq)*vibratoGain* + envVibrato(0.1*2*vibratoAttack,0.9*2*vibratoAttack,100,vibratoRelease,gate); +breath = envelope + envelope*no.noise*noiseGain; +breathPressure = breath + breath*vibrato; + +process = + //Commuted Loss Filtering + (_,(breathPressure <: _,_) : (filter*-0.95 - _ <: + + //Non-Linear Scattering + *(reedTable)) + _) ~ + + //Delay with Feedback + (delayLine : NLFM) : + + //scaling and stereo + *(gain)*1.5 : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/flute.dsp b/dist/examples/physicalModeling/faust-stk/flute.dsp new file mode 100644 index 00000000..e01a8623 --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/flute.dsp @@ -0,0 +1,116 @@ +declare name "flute"; +declare description "Nonlinear WaveGuide Flute"; +declare author "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare copyright "Romain Michon"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "A simple flute based on Smith algorithm: https://ccrma.stanford.edu/~jos/pasp/Flutes_Recorders_Pipe_Organs.html"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]") : int; + +pressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Pressure +[2][tooltip:Breath pressure (value bewteen 0 and 1)]",0.9,0,1.5,0.01) : si.smoo; +breathAmp = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Noise Gain +[2][tooltip:Breath noise gain (value between 0 and 1)]",0.1,0,1,0.01)/10; + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[4][unit:Hz]",5,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[4][tooltip:A value between 0 and 1]",0.1,0,1,0.01); +vibratoBegin = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Begin +[4][unit:s][tooltip:Vibrato silence duration before attack]",0.1,0,2,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[4][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[4][unit:s][tooltip:Vibrato release duration]",0.2,0,2,0.01); + +pressureEnvelope = checkbox("h:Envelopes_and_Vibrato/v:Pressure_Envelope_Parameters/Pressure_Env +[5][unit:s][tooltip:Activate Pressure envelope]") : int; +env1Attack = hslider("h:Envelopes_and_Vibrato/v:Pressure_Envelope_Parameters/Press_Env_Attack +[5][unit:s][tooltip:Pressure envelope attack duration]",0.05,0,2,0.01); +env1Decay = hslider("h:Envelopes_and_Vibrato/v:Pressure_Envelope_Parameters/Press_Env_Decay +[5][unit:s][tooltip:Pressure envelope decay duration]",0.2,0,2,0.01); +env1Release = hslider("h:Envelopes_and_Vibrato/v:Pressure_Envelope_Parameters/Press_Env_Release +[5][unit:s][tooltip:Pressure envelope release duration]",1,0,2,0.01); + +env2Attack = hslider("h:Envelopes_and_Vibrato/v:Global_Envelope_Parameters/Glob_Env_Attack +[6][unit:s][tooltip:Global envelope attack duration]",0.1,0,2,0.01); +env2Release = hslider("h:Envelopes_and_Vibrato/v:Global_Envelope_Parameters/Glob_Env_Release +[6][unit:s][tooltip:Global envelope release duration]",0.1,0,2,0.01); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,0.1,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, + typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//Loops feedbacks gains +feedBack1 = 0.4; +feedBack2 = 0.4; + +//Delay Lines +embouchureDelayLength = (ma.SR/freq)/2-2; +boreDelayLength = ma.SR/freq-2; +embouchureDelay = de.fdelay(4096,embouchureDelayLength); +boreDelay = de.fdelay(4096,boreDelayLength); + +//Polynomial +poly = _ <: _ - _*_*_; + +//jet filter is a lowpass filter (declared in miscfilter.lib) +reflexionFilter = fi.lowpass(1,2000); + +//stereoizer is declared in instruments.lib and implement a stereo spatialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//----------------------- Algorithm implementation ---------------------------- + +//Pressure envelope +env1 = en.adsr(env1Attack,env1Decay,0.9,env1Release,(gate | pressureEnvelope))*pressure*1.1; + +//Global envelope +env2 = en.asr(env2Attack,1,env2Release,gate)*0.5; + +//Vibrato Envelope +vibratoEnvelope = envVibrato(vibratoBegin,vibratoAttack,100,vibratoRelease,gate)*vibratoGain; + +vibrato = os.osc(vibratoFreq)*vibratoEnvelope; + +breath = no.noise*env1; + +flow = env1 + breath*breathAmp + vibrato; + +//instrReverb is declared in instruments.lib +process = (_ <: (flow + *(feedBack1) : embouchureDelay : poly) + *(feedBack2) : reflexionFilter)~(boreDelay : NLFM) : *(env2)*gain : +stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/fluteStk.dsp b/dist/examples/physicalModeling/faust-stk/fluteStk.dsp new file mode 100644 index 00000000..83f432dd --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/fluteStk.dsp @@ -0,0 +1,121 @@ +declare name "fluteStk"; +declare description "Nonlinear WaveGuide Flute from STK"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "A simple flute physical model, as discussed by Karjalainen, Smith, Waryznyk, etc. The jet model uses a polynomial, a la Cook."; +declare reference "https://ccrma.stanford.edu/~jos/pasp/Flutes_Recorders_Pipe_Organs.html"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +embouchureAjust = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Embouchure_Ajust +[2][tooltip:A value between 0 and 1]",0.5,0,1,0.01); +noiseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Noise_Gain +[2][tooltip:A value between 0 and 1]",0.03,0,1,0.01); +pressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Pressure +[2][tooltip:Breath pressure (value between 0 and 1)]",1,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[4][unit:Hz]",6,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[4][tooltip:A value between 0 and 1]",0.05,0,1,0.01); +vibratoBegin = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Begin +[4][unit:s][tooltip:Vibrato silence duration before attack]",0.05,0,2,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[4][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[4][unit:s][tooltip:Vibrato release duration]",0.1,0,2,0.01); + +envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack +[5][unit:s][tooltip:Envelope attack duration]",0.03,0,2,0.01); +envelopeDecay = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Decay +[5][unit:s][tooltip:Envelope decay duration]",0.01,0,2,0.01); +envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release +[5][unit:s][tooltip:Envelope release duration]",0.3,0,2,0.01); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, + typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +jetReflexion = 0.5; +//jetRatio = 0.08 + (0.48*embouchureAjust); //original stk function +jetRatio = 1+(0.5-embouchureAjust); //corrected function +endReflexion = 0.5; + +//Delay lines lengths in number of samples +//jetDelayLength = (SR/freq-2)*jetRatio; //original stk function for jet delay length +jetDelayLength = (ma.SR/(freq*2)-2)*jetRatio; //corrected function for jet delay length +boreDelayLength = ma.SR/(freq*2)-2; //original function for bore delay length +//boreDelayLength = SR/(freq)-2; //corrected function for bore delay length +filterPole = 0.7 - (0.1*22050/ma.SR); + +//One Pole Filter (declared in instruments.lib) +onePoleFilter = _*gain : onePole(b0,a1) + with{ + gain = -1; + pole = 0.7 - (0.1*22050/ma.SR); + b0 = 1 - pole; + a1 = -pole; + }; + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//----------------------- Algorithm implementation ---------------------------- + +//the vibrato amplitude is controlled by an envelope generator (declared in instruments.lib) +vibrato = vibratoGain*envVibrato(vibratoBegin,vibratoAttack,100,vibratoRelease,gate)*os.osc(vibratoFreq); + +//Breath pressure is controlled by an Attack / Decay / Sustain / Release envelope +envelopeBreath = pressure*en.adsr(pressure*envelopeAttack,envelopeDecay,0.8,envelopeRelease,gate); +breathPressure = envelopeBreath + envelopeBreath*(noiseGain*no.noise + vibrato) + 10.0^(-15.0); + +//delay lines +jetDelay = de.fdelay(4096,jetDelayLength); +boreDelay = de.fdelay(4096,boreDelayLength); + +//reflexion filter is a one pole and a dcblocker +reflexionFilters = onePoleFilter : fi.dcblocker; + +process = + (reflexionFilters <: + //Differential Pressure + ((breathPressure - _*jetReflexion) : + jetDelay : jetTable) + (_*endReflexion)) ~ (boreDelay : NLFM) : + //output scaling and stereo signal + *(0.3*gain) : stereo : instrReverb; + + diff --git a/dist/examples/physicalModeling/faust-stk/glassHarmonica.dsp b/dist/examples/physicalModeling/faust-stk/glassHarmonica.dsp new file mode 100644 index 00000000..f7e874d8 --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/glassHarmonica.dsp @@ -0,0 +1,131 @@ +declare name "glassHarmonica"; +declare description "Nonlinear Banded Waveguide Modeled Glass Harmonica"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This instrument uses banded waveguide. For more information, see Essl, G. and Cook, P. Banded Waveguides: Towards Physical Modelling of Bar Percussion Instruments, Proceedings of the 1999 International Computer Music Conference."; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",0.8,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +select = nentry("h:Physical_and_Nonlinearity/v:Physical_Parameters/Excitation_Selector +[2][tooltip:0=Bow; 1=Strike]",0,0,1,1); +integrationConstant = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Integration_Constant +[2][tooltip:A value between 0 and 1]",0,0,1,0.01); +baseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Base_Gain +[2][tooltip:A value between 0 and 1]",1,0,1,0.01); +bowPressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Pressure +[2][tooltip:Bow pressure on the instrument (Value between 0 and 1)]",0.2,0,1,0.01); +bowPosition = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Position +[2][tooltip:Bow position on the instrument (Value between 0 and 1)]",0,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +//==================== MODAL PARAMETERS ================ + +preset = 3; + +nMode(3) = 6; + +modes(3,0) = 1.0; +basegains(3,0) = pow(0.999,1); +excitation(3,0) = 1*gain*gate/(nMode(3) - 1); + +modes(3,1) = 2.32; +basegains(3,1) = pow(0.999,2); +excitation(3,1) = 1*gain*gate/(nMode(3) - 1); + +modes(3,2) = 4.25; +basegains(3,2) = pow(0.999,3); +excitation(3,2) = 1*gain*gate/(nMode(3) - 1); + +modes(3,3) = 6.63; +basegains(3,3) = pow(0.999,4); +excitation(3,3) = 1*gain*gate/(nMode(3) - 1); + +modes(3,4) = 9.38; +basegains(3,4) = pow(0.999,5); +excitation(3,4) = 1*gain*gate/(nMode(3) - 1); + +modes(3,5) = 9 : float; +basegains(3,5) = 0 : float; +excitation(3,5) = 0 : float; + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),1,freq, +typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//the number of modes depends on the preset being used +nModes = nMode(preset); + +//bow table parameters +tableOffset = 0; +tableSlope = 10 - (9*bowPressure); + +delayLengthBase = ma.SR/freq; + +//delay lengths in number of samples +delayLength(x) = delayLengthBase/modes(preset,x); + +//delay lines +delayLine(x) = de.delay(4096,delayLength(x)); + +//Filter bank: bandpass filters (declared in instruments.lib) +radius = 1 - ma.PI*32/ma.SR; +bandPassFilter(x) = bandPass(freq*modes(preset,x),radius); + +//Delay lines feedback for bow table lookup control +baseGainApp = 0.8999999999999999 + (0.1*baseGain); +velocityInputApp = integrationConstant; +velocityInput = velocityInputApp + _*baseGainApp,par(i,(nModes-1),(_*baseGainApp)) :> +; + +//Bow velocity is controlled by an ADSR envelope +maxVelocity = 0.03 + 0.1*gain; +bowVelocity = maxVelocity*en.adsr(0.02,0.005,1,0.01,gate); + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(delayLengthBase); + +//----------------------- Algorithm implementation ---------------------------- + +//Bow table lookup (bow is decalred in instruments.lib) +bowing = bowVelocity - velocityInput <: *(bow(tableOffset,tableSlope)) : /(nModes); + +//One resonance +resonance(x) = + : + (excitation(preset,x)*select) : delayLine(x) : *(basegains(preset,x)) : bandPassFilter(x); + +process = + //Bowed Excitation + (bowing*((select-1)*-1) <: + //nModes resonances with nModes feedbacks for bow table look-up + par(i,nModes,(resonance(i)~_)))~par(i,nModes,_) :> + : + //Signal Scaling and stereo + *(4) : NLFM : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/saxophony.dsp b/dist/examples/physicalModeling/faust-stk/saxophony.dsp new file mode 100644 index 00000000..b6bac050 --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/saxophony.dsp @@ -0,0 +1,114 @@ +declare name "saxophony"; +declare description "Nonlinear WaveGuide Saxophone"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This class implements a hybrid digital waveguide instrument that can generate a variety of wind-like sounds. It has also been referred to as the blowed string model. The waveguide section is essentially that of a string, with one rigid and one lossy termination. The non-linear function is a reed table. The string can be blown at any point between the terminations, though just as with strings, it is impossible to excite the system at either end. If the excitation is placed at the string mid-point, the sound is that of a clarinet. At points closer to the bridge, the sound is closer to that of a saxophone. See Scavone (2002) for more details."; +declare reference "https://ccrma.stanford.edu/~jos/pasp/Woodwinds.html"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +pressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Pressure +[2][tooltip:Breath pressure (a value between 0 and 1)]",1,0,1,0.01); +reedStiffness = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Reed_Stiffness +[2][tooltip:A value between 0 and 1]",0.3,0,1,0.01); +blowPosition = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Blow_Position +[2][tooltip:A value between 0 and 1]",0.5,0,1,0.01); +noiseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Noise_Gain",0.05,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[4][unit:Hz]",6,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[4][tooltip:A value between 0 and 1]",0.1,0,1,0.01); +vibratoBegin = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Begin +[4][unit:s][tooltip:Vibrato silence duration before attack]",0.05,0,2,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[4][unit:s][tooltip:Vibrato attack duration]",0.3,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[4][unit:s][tooltip:Vibrato release duration]",0.1,0,2,0.01); + +envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack +[5][unit:s][tooltip:Envelope attack duration]",0.05,0,2,0.01); +envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release +[5][unit:s][tooltip:Envelope release duration]",0.01,0,2,0.01); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//attack - sustain - release envelope for nonlinearity (declared in instruments.lib) +envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate); + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq, + typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//reed table parameters +reedTableOffset = 0.7; +reedTableSlope = 0.1 + (0.4*reedStiffness); + +//the reed function is declared in instruments.lib +reedTable = reed(reedTableOffset,reedTableSlope); + +//Delay lines length in number of samples +fdel1 = (1-blowPosition) * (ma.SR/freq - 3); +fdel2 = (ma.SR/freq - 3)*blowPosition +1 ; + +//Delay lines +delay1 = de.fdelay(4096,fdel1); +delay2 = de.fdelay(4096,fdel2); + +//Breath pressure is controlled by an attack / sustain / release envelope (asr is declared in instruments.lib) +envelope = (0.55+pressure*0.3)*en.asr(pressure*envelopeAttack,1,pressure*envelopeRelease,gate); +breath = envelope + envelope*noiseGain*no.noise; + +//envVibrato is decalred in instruments.lib +vibrato = vibratoGain*envVibrato(vibratoBegin,vibratoAttack,100,vibratoRelease,gate)*osc(vibratoFreq); +breathPressure = breath + breath*vibratoGain*os.osc(vibratoFreq); + +//Body filter is a one zero filter (declared in instruments.lib) +bodyFilter = *(gain) : oneZero1(b0,b1) + with{ + gain = -0.95; + b0 = 0.5; + b1 = 0.5; + }; + +instrumentBody(delay1FeedBack,breathP) = delay1FeedBack <: -(delay2) <: + ((breathP - _ <: breathP - _*reedTable) - delay1FeedBack),_; + +process = + (bodyFilter,breathPressure : instrumentBody) ~ + (delay1 : NLFM) : !, + //Scaling Output and stereo + *(gain) : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/sitar.dsp b/dist/examples/physicalModeling/faust-stk/sitar.dsp new file mode 100644 index 00000000..0b4b1af2 --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/sitar.dsp @@ -0,0 +1,48 @@ +declare name "Sitar"; +declare description "WaveGuide Sitar"; +declare author "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare copyright "Romain Michon"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This instrument implements a sitar plucked string physical model based on the Karplus-Strong algorithm using a randomly modulated delay line."; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +resonance = hslider("v:Physical_Parameters/Resonance +[2][tooltip:A value between 0 and 1]",0.7,0,1,0.01)*0.1; + +//==================== SIGNAL PROCESSING ================ + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//excitation envelope (adsr) +envelope = en.adsr(0.001,0.04,1,0.5,gate); + +//the delay length is randomly modulated +targetDelay = ma.SR/freq; +delayLength = targetDelay*((1+(0.5*no.noise)) : si.smooth(0.9992)); +delayLine = de.delay(4096,delayLength); + +//the loop gain control the resonance duration +loopGain = 0.895 + resonance + (freq*0.0000005); +amGain = 0.1*gain; + +//feedback filter is a one zero (declared in instruments.lib) +filter = oneZero1(b0,b1) + with{ + zero = 0.01; + b0 = 1/(1 + zero); + b1 = -zero*b0; + }; + +process = (*(loopGain) : filter + (envelope*no.noise*amGain))~delayLine : *(8) : +stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/tibetanBowl.dsp b/dist/examples/physicalModeling/faust-stk/tibetanBowl.dsp new file mode 100644 index 00000000..ce13307e --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/tibetanBowl.dsp @@ -0,0 +1,155 @@ +declare name "tibetanBowl"; +declare description "Banded Waveguide Modeld Tibetan Bowl"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This instrument uses banded waveguide. For more information, see Essl, G. and Cook, P. Banded Waveguides: Towards Physical Modelling of Bar Percussion Instruments, Proceedings of the 1999 International Computer Music Conference."; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",0.8,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +select = nentry("h:Physical_and_Nonlinearity/v:Physical_Parameters/Excitation_Selector +[2][tooltip:0=Bow; 1=Strike]",0,0,1,1); +integrationConstant = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Integration_Constant +[2][tooltip:A value between 0 and 1]",0,0,1,0.01); +baseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Base_Gain +[2][tooltip:A value between 0 and 1]",1,0,1,0.01); +bowPressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Pressure +[2][tooltip:Bow pressure on the instrument (Value between 0 and 1)]",0.2,0,1,0.01); +bowPosition = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Position +[2][tooltip:Bow position on the instrument (Value between 0 and 1)]",0,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +//==================== MODAL PARAMETERS ================ + +preset = 0; + +nMode(0) = 12; + +modes(0,0) = 0.996108344; +basegains(0,0) = 0.999925960128219; +excitation(0,0) = 11.900357 / 10; + +modes(0,1) = 1.0038916562; +basegains(0,1) = 0.999925960128219; +excitation(0,1) = 11.900357 / 10; + +modes(0,2) = 2.979178; +basegains(0,2) = 0.999982774366897; +excitation(0,2) = 10.914886 / 10; + +modes(0,3) = 2.99329767; +basegains(0,3) = 0.999982774366897; +excitation(0,3) = 10.914886 / 10; + +modes(0,4) = 5.704452; +basegains(0,4) = 1.0; +excitation(0,4) = 42.995041 / 10; + +modes(0,5) = 5.704452; +basegains(0,5) = 1.0; +excitation(0,5) = 42.995041 / 10; + +modes(0,6) = 8.9982; +basegains(0,6) = 1.0; +excitation(0,6) = 40.063034 / 10; + +modes(0,7) = 9.01549726; +basegains(0,7) = 1.0; +excitation(0,7) = 40.063034 / 10; + +modes(0,8) = 12.83303; +basegains(0,8) = 0.999965497558225; +excitation(0,8) = 7.063034 / 10; + +modes(0,9) = 12.807382; +basegains(0,9) = 0.999965497558225; +excitation(0,9) = 7.063034 / 10; + +modes(0,10) = 17.2808219; +basegains(0,10) = 0.9999999999999999999965497558225; +excitation(0,10) = 57.063034 / 10; + +modes(0,11) = 21.97602739726; +basegains(0,11) = 0.999999999999999965497558225; +excitation(0,11) = 57.063034 / 10; + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),1,freq, +typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//the number of modes depends on the preset being used +nModes = nMode(preset); + +//bow table parameters +tableOffset = 0; +tableSlope = 10 - (9*bowPressure); + +delayLengthBase = ma.SR/freq; + +//delay lengths in number of samples +delayLength(x) = delayLengthBase/modes(preset,x); + +//delay lines +delayLine(x) = de.delay(4096,delayLength(x)); + +//Filter bank: bandpass filters (declared in instruments.lib) +radius = 1 - ma.PI*32/ma.SR; +bandPassFilter(x) = bandPass(freq*modes(preset,x),radius); + +//Delay lines feedback for bow table lookup control +baseGainApp = 0.8999999999999999 + (0.1*baseGain); +velocityInputApp = integrationConstant; +velocityInput = velocityInputApp + _*baseGainApp,par(i,(nModes-1),(_*baseGainApp)) :> +; + +//Bow velocity is controlled by an ADSR envelope +maxVelocity = 0.03 + 0.1*gain; +bowVelocity = maxVelocity*en.adsr(0.02,0.005,1,0.01,gate); + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(delayLengthBase); + +//----------------------- Algorithm implementation ---------------------------- + +//Bow table lookup (bow is decalred in instruments.lib) +bowing = bowVelocity - velocityInput <: *(bow(tableOffset,tableSlope)) : /(nModes); + +//One resonance +resonance(x) = + : + (excitation(preset,x)*select) : delayLine(x) : *(basegains(preset,x)) : bandPassFilter(x); + +process = + //Bowed Excitation + (bowing*((select-1)*-1) <: + //nModes resonances with nModes feedbacks for bow table look-up + par(i,nModes,(resonance(i)~_)))~par(i,nModes,_) :> + : + //Signal Scaling and stereo + NLFM : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/tunedBar.dsp b/dist/examples/physicalModeling/faust-stk/tunedBar.dsp new file mode 100644 index 00000000..1dd6b15b --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/tunedBar.dsp @@ -0,0 +1,123 @@ +declare name "tunedBar"; +declare description "Nonlinear Banded Waveguide Models"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This instrument uses banded waveguide. For more information, see Essl, G. and Cook, P. Banded Waveguides: Towards Physical Modelling of Bar Percussion Instruments, Proceedings of the 1999 International Computer Music Conference."; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",0.8,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +select = nentry("h:Physical_and_Nonlinearity/v:Physical_Parameters/Excitation_Selector +[2][tooltip:0=Bow; 1=Strike]",0,0,1,1); +integrationConstant = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Integration_Constant +[2][tooltip:A value between 0 and 1]",0,0,1,0.01); +baseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Base_Gain +[2][tooltip:A value between 0 and 1]",1,0,1,0.01); +bowPressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Pressure +[2][tooltip:Bow pressure on the instrument (Value between 0 and 1)]",0.2,0,1,0.01); +bowPosition = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Position +[2][tooltip:Bow position on the instrument (Value between 0 and 1)]",0,0,1,0.01); + +typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type +[3][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal; +2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod; +4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1); +nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity +[3][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01); +frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency +[3][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1); +nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack +[3][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01); + +//==================== MODAL PARAMETERS ================ + +preset = 2; + +nMode(2) = 4; + +modes(2,0) = 1; +basegains(2,0) = pow(0.999,1); +excitation(2,0) = 1*gain*gate/nMode(2); + +modes(2,1) = 4.0198391420; +basegains(2,1) = pow(0.999,2); +excitation(2,1) = 1*gain*gate/nMode(2); + +modes(2,2) = 10.7184986595; +basegains(2,2) = pow(0.999,3); +excitation(2,2) = 1*gain*gate/nMode(2); + +modes(2,3) = 18.0697050938; +basegains(2,3) = pow(0.999,4); +excitation(2,3) = 1*gain*gate/nMode(2); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Nonlinear filter ---------------------------- +//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib + +//nonlinear filter order +nlfOrder = 6; + +//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib +//for using it with waveguide instruments +NLFM = nonLinearModulator((nonLinearity : si.smoo),1,freq, +typeModulation,(frequencyMod : si.smoo),nlfOrder); + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//the number of modes depends on the preset being used +nModes = nMode(preset); + +//bow table parameters +tableOffset = 0; +tableSlope = 10 - (9*bowPressure); + +delayLengthBase = ma.SR/freq; + +//delay lengths in number of samples +delayLength(x) = delayLengthBase/modes(preset,x); + +//delay lines +delayLine(x) = de.delay(4096,delayLength(x)); + +//Filter bank: bandpass filters (declared in instruments.lib) +radius = 1 - ma.PI*32/ma.SR; +bandPassFilter(x) = bandPass(freq*modes(preset,x),radius); + +//Delay lines feedback for bow table lookup control +baseGainApp = 0.8999999999999999 + (0.1*baseGain); +velocityInputApp = integrationConstant; +velocityInput = velocityInputApp + _*baseGainApp,par(i,(nModes-1),(_*baseGainApp)) :> +; + +//Bow velocity is controlled by an ADSR envelope +maxVelocity = 0.03 + 0.1*gain; +bowVelocity = maxVelocity*en.adsr(0.02,0.005,0.9,0.01,gate); + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(delayLengthBase); + +//----------------------- Algorithm implementation ---------------------------- + +//Bow table lookup (bow is decalred in instruments.lib) +bowing = bowVelocity - velocityInput <: *(bow(tableOffset,tableSlope)) : /(nModes); + +//One resonance +resonance(x) = + : + (excitation(preset,x)*select) : delayLine(x) : *(basegains(preset,x)) : bandPassFilter(x); + +process = + //Bowed Excitation + (bowing*((select-1)*-1) <: + //nModes resonances with nModes feedbacks for bow table look-up + par(i,nModes,(resonance(i)~_)))~par(i,nModes,_) :> + : + //Signal Scaling and stereo + *(4) : NLFM : stereo : instrReverb; + diff --git a/dist/examples/physicalModeling/faust-stk/uniBar.dsp b/dist/examples/physicalModeling/faust-stk/uniBar.dsp new file mode 100644 index 00000000..c485f93d --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/uniBar.dsp @@ -0,0 +1,100 @@ +declare name "UniBar"; +declare description "Nonlinear Banded Waveguide Models"; +declare author "Romain Michon"; +declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This instrument uses banded waveguide. For more information, see Essl, G. and Cook, P. Banded Waveguides: Towards Physical Modelling of Bar Percussion Instruments, Proceedings of the 1999 International Computer Music Conference."; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",0.8,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +select = nentry("h:Physical_and_Nonlinearity/v:Physical_Parameters/Excitation_Selector +[2][tooltip:0=Bow; 1=Strike]",0,0,1,1); +integrationConstant = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Integration_Constant +[2][tooltip:A value between 0 and 1]",0,0,1,0.01); +baseGain = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Base_Gain +[2][tooltip:A value between 0 and 1]",1,0,1,0.01); +bowPressure = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Pressure +[2][tooltip:Bow pressure on the instrument (Value between 0 and 1)]",0.2,0,1,0.01); +bowPosition = hslider("h:Physical_and_Nonlinearity/v:Physical_Parameters/Bow_Position +[2][tooltip:Bow position on the instrument (Value between 0 and 1)]",0,0,1,0.01); + +//==================== MODAL PARAMETERS ================ + +preset = 1; + +nMode(1) = 4; + +modes(1,0) = 1; +basegains(1,0) = pow(0.9,1); +excitation(1,0) = 1*gain/nMode(1); + +modes(1,1) = 2.756; +basegains(1,1) = pow(0.9,2); +excitation(1,1) = 1*gain/nMode(1); + +modes(1,2) = 5.404; +basegains(1,2) = pow(0.9,3); +excitation(1,2) = 1*gain/nMode(1); + +modes(1,3) = 8.933; +basegains(1,3) = pow(0.9,4); +excitation(1,3) = 1*gain/nMode(1); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//the number of modes depends on the preset being used +nModes = nMode(preset); + +//bow table parameters +tableOffset = 0; +tableSlope = 10 - (9*bowPressure); + +delayLengthBase = ma.SR/freq; + +//delay lengths in number of samples +delayLength(x) = delayLengthBase/modes(preset,x); + +//delay lines +delayLine(x) = de.delay(4096,delayLength(x)); + +//Filter bank: bandpass filters (declared in instruments.lib) +radius = 1 - ma.PI*32/ma.SR; +bandPassFilter(x) = bandPass(freq*modes(preset,x),radius); + +//Delay lines feedback for bow table lookup control +baseGainApp = 0.8999999999999999 + (0.1*baseGain); +velocityInputApp = integrationConstant; +velocityInput = velocityInputApp + _*baseGainApp,par(i,(nModes-1),(_*baseGainApp)) :> +; + +//Bow velocity is controlled by an ADSR envelope +maxVelocity = 0.03 + 0.1*gain; +bowVelocity = maxVelocity*en.adsr(0.02,0.005,0.9,0.01,gate); + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(delayLengthBase); + +//----------------------- Algorithm implementation ---------------------------- + +//Bow table lookup (bow is decalred in instruments.lib) +bowing = bowVelocity - velocityInput <: *(bow(tableOffset,tableSlope)) : /(nModes); + +//One resonance +resonance(x) = + : + (excitation(preset,x)*select) : delayLine(x) : *(basegains(preset,x)) : bandPassFilter(x); + +process = + //Bowed Excitation + (bowing*((select-1)*-1) <: + //nModes resonances with nModes feedbacks for bow table look-up + par(i,nModes,(resonance(i)~_)))~par(i,nModes,_) :> + : + //Signal Scaling and stereo + *(14) : stereo : instrReverb; diff --git a/dist/examples/physicalModeling/faust-stk/voiceForm.dsp b/dist/examples/physicalModeling/faust-stk/voiceForm.dsp new file mode 100644 index 00000000..7e297df6 --- /dev/null +++ b/dist/examples/physicalModeling/faust-stk/voiceForm.dsp @@ -0,0 +1,125 @@ +declare name "voiceForm"; +declare description "Voice Formant Instrument"; +declare author "Romain Michon (rmichon@ccrma.stanford.edu)"; +declare copyright "Romain Michon"; +declare version "1.0"; +declare licence "STK-4.3"; // Synthesis Tool Kit 4.3 (MIT style license); +declare description "This instrument contains an excitation singing wavetable (looping wave with random and periodic vibrato, smoothing on frequency, etc.), excitation noise, and four sweepable complex resonances. Phoneme preset numbers: 0->eee (beet), 1->ihh (bit), 2->ehh (bet), 3->aaa (bat), 4->ahh (father), 5->aww (bought), 6->ohh (bone), 7->uhh (but), 8->uuu (foot), 9->ooo (boot), 10->rrr (bird), 11->lll (lull), 12->mmm (mom), 13->nnn (nun), 14->nng (sang), 15->ngg (bong), 16->fff, 17->sss, 18->thh, 19->shh, 20->xxx, 21->hee (beet), 22->hoo (boot), 23->hah (father), 24->bbb, 25->ddd, 26->jjj, 27->ggg, 28->vvv, 29->zzz, 30->thz, 31->zhh"; + +import("instruments.lib"); + +//==================== GUI SPECIFICATION ================ + +freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1); +gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",1,0,1,0.01); +gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]"); + +phoneme = hslider("v:Physical_Parameters/Phoneme +[2][tooltip:0->eee, 1->ihh, 2->ehh, 3->aaa, 4->ahh, 5->aww, 6->ohh, 7->uhh, 8->uuu, 9->ooo, 10->rrr, 11->lll, 12->mmm, 13->nnn, 14->nng, 15->ngg, 16->fff, 17->sss, 18->thh, 19->shh, 20->xxx, 21->hee, 22->hoo, 23->hah, 24->bbb, 25->ddd, 26->jjj, 27->ggg, 28->vvv, 29->zzz, 30->thz, 31->zhh]",4,0,31,1); + +vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq +[3][unit:Hz]",6,1,15,0.1); +vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain +[3][tooltip:A value between 0 and 1]",0.05,0,1,0.01); +vibratoBegin = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Begin +[3][unit:s][tooltip:Vibrato silence duration before attack]",0.05,0,2,0.01); +vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack +[3][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01); +vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release +[3][unit:s][tooltip:Vibrato release duration]",0.1,0,2,0.01); + +voicedEnvelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Voiced_Attack +[4][unit:s][tooltip:Voiced sounds attack duration]",0.01,0,2,0.01); +voicedEnvelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Voiced_Release +[4][unit:s][tooltip:Voiced sounds release duration]",0.01,0,2,0.01); + +noiseEnvelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Noised_Attack +[4][unit:s][tooltip:Noised sounds attack duration]",0.001,0,2,0.001); +noiseEnvelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Noised_Release +[4][unit:s][tooltip:Noised sounds release duration]",0.001,0,2,0.001); + +//==================== SIGNAL PROCESSING ================ + +//----------------------- Synthesis parameters computing and functions declaration ---------------------------- + +//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of +//the frequency period in number of samples +stereo = stereoizer(ma.SR/freq); + +//exitation filters (declared in instruments.lib) +onePoleFilter = onePole(b0,a1) + with{ + pole = 0.97 - (gain*0.2); + b0 = 1 - pole; + a1 = -pole; + }; +oneZeroFilter = oneZero1(b0,b1) + with{ + zero = -0.9; + b0 = 1/(1 - zero); + b1 = -zero*b0; + }; + +//implements a formant (resonance) which can be "swept" over time from one frequency setting to another +formSwep(frequency,radius,filterGain) = *(gain_) : bandPass(frequency_,radius) + with{ + //filter's radius, gain and frequency are interpolated + radius_ = radius : si.smoo; + frequency_ = frequency : si.smoo; + gain_ = filterGain : si.smoo; + }; + +//formants parameters are countained in a C++ file +phonemeGains = ffunction(float loadPhonemeGains(int,int), ,""); +phonemeParameters = ffunction(float loadPhonemeParameters(int,int,int), ,""); + +//formants frequencies +ffreq0 = phonemeParameters(phoneme,0,0); +ffreq1 = phonemeParameters(phoneme,1,0); +ffreq2 = phonemeParameters(phoneme,2,0); +ffreq3 = phonemeParameters(phoneme,3,0); + +//formants radius +frad0 = phonemeParameters(phoneme,0,1); +frad1 = phonemeParameters(phoneme,1,1); +frad2 = phonemeParameters(phoneme,2,1); +frad3 = phonemeParameters(phoneme,3,1); + +//formants gains +fgain0 = phonemeParameters(phoneme,0,2) : pow(10,(_/20)); +fgain1 = phonemeParameters(phoneme,1,2) : pow(10,(_/20)); +fgain2 = phonemeParameters(phoneme,2,2) : pow(10,(_/20)); +fgain3 = phonemeParameters(phoneme,3,2) : pow(10,(_/20)); + +//gain of the voiced part od the sound +voiceGain = phonemeGains(phoneme,0) : si.smoo; + +//gain of the fricative part of the sound +noiseGain = phonemeGains(phoneme,1) : si.smoo; + +//formants filters +filter0 = formSwep(ffreq0,frad0,fgain0); +filter1 = formSwep(ffreq1,frad1,fgain1); +filter2 = formSwep(ffreq2,frad2,fgain2); +filter3 = formSwep(ffreq3,frad3,fgain3); + +//----------------------- Algorithm implementation ---------------------------- + +//envelopes (declared in instruments.lib) and vibrato +vibratoEnvelope = envVibrato(vibratoBegin,vibratoAttack,100,vibratoRelease,gate); +voicedEnvelope = en.asr(voicedEnvelopeAttack,1,voicedEnvelopeRelease,gate); +noiseEnvelope = en.asr(noiseEnvelopeAttack,1,noiseEnvelopeRelease,gate); +vibrato = os.osc(vibratoFreq)*vibratoGain*100*vibratoEnvelope; + +//the voice source is generated by an impulse train +//(imptrain defined in oscillator.lib) that is lowpass filtered +voiced = os.imptrain(freq+vibrato) : fi.lowpass3e(3300) : *(voiceGain*voicedEnvelope); + +//ficative sounds are produced by a noise generator +frica = no.noise*noiseEnvelope*noiseGain; + +process = voiced : oneZeroFilter : onePoleFilter : + +(frica) <: filter0,filter1,filter2,filter3 :> + : stereo : + instrReverb; + + diff --git a/dist/examples/physicalModeling/flute.dsp b/dist/examples/physicalModeling/flute.dsp new file mode 100644 index 00000000..9fa8bcd4 --- /dev/null +++ b/dist/examples/physicalModeling/flute.dsp @@ -0,0 +1,8 @@ +declare name "Flute"; +declare description "Simple flute physical model with physical parameters."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.flute_ui <: _,_; diff --git a/dist/examples/physicalModeling/fluteMIDI.dsp b/dist/examples/physicalModeling/fluteMIDI.dsp new file mode 100644 index 00000000..18fa0669 --- /dev/null +++ b/dist/examples/physicalModeling/fluteMIDI.dsp @@ -0,0 +1,8 @@ +declare name "FluteMIDI"; +declare description "Simple MIDI-controllable flute physical model with physical parameters."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.flute_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/frenchBell.dsp b/dist/examples/physicalModeling/frenchBell.dsp new file mode 100644 index 00000000..52bb8df2 --- /dev/null +++ b/dist/examples/physicalModeling/frenchBell.dsp @@ -0,0 +1,8 @@ +declare name "FrenchChurchBell"; +declare description "French church bell physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.frenchBell_ui <: _,_; diff --git a/dist/examples/physicalModeling/germanBell.dsp b/dist/examples/physicalModeling/germanBell.dsp new file mode 100644 index 00000000..b6376532 --- /dev/null +++ b/dist/examples/physicalModeling/germanBell.dsp @@ -0,0 +1,8 @@ +declare name "GermanChurchBell"; +declare description "German church bell physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.germanBell_ui <: _,_; diff --git a/dist/examples/physicalModeling/guitarMIDI.dsp b/dist/examples/physicalModeling/guitarMIDI.dsp new file mode 100644 index 00000000..d374d6b9 --- /dev/null +++ b/dist/examples/physicalModeling/guitarMIDI.dsp @@ -0,0 +1,8 @@ +declare name "GuitarMidi"; +declare description "Simple acoustic guitar model with steel strings."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.guitar_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/karplus.dsp b/dist/examples/physicalModeling/karplus.dsp new file mode 100644 index 00000000..2c5421c8 --- /dev/null +++ b/dist/examples/physicalModeling/karplus.dsp @@ -0,0 +1,8 @@ +declare name "KarplusStrong"; +declare description "Simple call of the Karplus-Strong model for the Faust physical modeling library"; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.ks_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/marimbaMIDI.dsp b/dist/examples/physicalModeling/marimbaMIDI.dsp new file mode 100644 index 00000000..1ebabd07 --- /dev/null +++ b/dist/examples/physicalModeling/marimbaMIDI.dsp @@ -0,0 +1,10 @@ +// WARNING: this model is incomplete and is only here for testing purposes + +declare name "MarimbaMIDI"; +declare description "Simple MIDI-controllable marimba physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.marimba_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/modularInterpInstrMIDI.dsp b/dist/examples/physicalModeling/modularInterpInstrMIDI.dsp new file mode 100644 index 00000000..ecc3f38a --- /dev/null +++ b/dist/examples/physicalModeling/modularInterpInstrMIDI.dsp @@ -0,0 +1,8 @@ +declare name "ModularInterpInstrMidi"; +declare description "String instrument with a modular body"; +declare license "MIT"; +declare copyright "(c)Romain Michon & John Granzow, CCRMA (Stanford University), GRAME, University of Michigan"; + +import("stdfaust.lib"); + +process = pm.modularInterpInstr_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/nylonGuitarMIDI.dsp b/dist/examples/physicalModeling/nylonGuitarMIDI.dsp new file mode 100644 index 00000000..d1e43173 --- /dev/null +++ b/dist/examples/physicalModeling/nylonGuitarMIDI.dsp @@ -0,0 +1,8 @@ +declare name "NylonGuitarMidi"; +declare description "Simple acoustic guitar model with nylon strings."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.nylonGuitar_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/russianBell.dsp b/dist/examples/physicalModeling/russianBell.dsp new file mode 100644 index 00000000..db3e3a91 --- /dev/null +++ b/dist/examples/physicalModeling/russianBell.dsp @@ -0,0 +1,8 @@ +declare name "RussianChurchBell"; +declare description "Russian church bell physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.russianBell_ui <: _,_; diff --git a/dist/examples/physicalModeling/standardBell.dsp b/dist/examples/physicalModeling/standardBell.dsp new file mode 100644 index 00000000..f8adaf77 --- /dev/null +++ b/dist/examples/physicalModeling/standardBell.dsp @@ -0,0 +1,8 @@ +declare name "StandardChurchBell"; +declare description "Standard church bell physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.standardBell_ui <: _,_; diff --git a/dist/examples/physicalModeling/violin.dsp b/dist/examples/physicalModeling/violin.dsp new file mode 100644 index 00000000..2a62fcb1 --- /dev/null +++ b/dist/examples/physicalModeling/violin.dsp @@ -0,0 +1,8 @@ +declare name "Violin"; +declare description "Simple violin physical model controlled with continuous parameters."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.violin_ui <: _,_; diff --git a/dist/examples/physicalModeling/violinMIDI.dsp b/dist/examples/physicalModeling/violinMIDI.dsp new file mode 100644 index 00000000..f432ab86 --- /dev/null +++ b/dist/examples/physicalModeling/violinMIDI.dsp @@ -0,0 +1,8 @@ +declare name "ViolinMidi"; +declare description "Simple MIDI-controllable violin physical model."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.violin_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/vocalBP.dsp b/dist/examples/physicalModeling/vocalBP.dsp new file mode 100644 index 00000000..d2db5f28 --- /dev/null +++ b/dist/examples/physicalModeling/vocalBP.dsp @@ -0,0 +1,8 @@ +declare name "Vocal BandPass"; +declare description "Simple source-filter vocal synthesizer."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.SFFormantModelBP_ui <: _,_; diff --git a/dist/examples/physicalModeling/vocalBPMIDI.dsp b/dist/examples/physicalModeling/vocalBPMIDI.dsp new file mode 100644 index 00000000..11eb0a83 --- /dev/null +++ b/dist/examples/physicalModeling/vocalBPMIDI.dsp @@ -0,0 +1,8 @@ +declare name "Vocal BandPass MIDI"; +declare description "Simple MIDI-controllable source-filter vocal synthesizer."; +declare license "MIT"; +declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME"; + +import("stdfaust.lib"); + +process = pm.SFFormantModelBP_ui_MIDI <: _,_; diff --git a/dist/examples/physicalModeling/vocalFOF.dsp b/dist/examples/physicalModeling/vocalFOF.dsp new file mode 100644 index 00000000..c832a0c9 --- /dev/null +++ b/dist/examples/physicalModeling/vocalFOF.dsp @@ -0,0 +1,8 @@ +declare name "Vocal FOF"; +declare description "FOF vocal synthesizer."; +declare license "MIT"; +declare copyright "(c)Mike Olsen, CCRMA (Stanford University)"; + +import("stdfaust.lib"); + +process = pm.SFFormantModelFofSmooth_ui <: _,_; diff --git a/dist/examples/physicalModeling/vocalFOFMIDI.dsp b/dist/examples/physicalModeling/vocalFOFMIDI.dsp new file mode 100644 index 00000000..799f80b5 --- /dev/null +++ b/dist/examples/physicalModeling/vocalFOFMIDI.dsp @@ -0,0 +1,8 @@ +declare name "Vocal FOF MIDI"; +declare description "MIDI-controllable FOF vocal synthesizer."; +declare license "MIT"; +declare copyright "(c)Mike Olsen, CCRMA (Stanford University)"; + +import("stdfaust.lib"); + +process = pm.SFFormantModelFofSmooth_ui_MIDI <: _,_; diff --git a/dist/examples/pitchShifting/pitchShifter.dsp b/dist/examples/pitchShifting/pitchShifter.dsp new file mode 100644 index 00000000..c84a3e22 --- /dev/null +++ b/dist/examples/pitchShifting/pitchShifter.dsp @@ -0,0 +1,20 @@ +declare name "pitchShifter"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + + //-------------------------------------- + // very simple real time pitch shifter + //-------------------------------------- + +import("stdfaust.lib"); + +pitchshifter = vgroup("Pitch Shifter", ef.transpose( + hslider("window (samples)", 1000, 50, 10000, 1), + hslider("xfade (samples)", 10, 1, 10000, 1), + hslider("shift (semitones) ", 0, -12, +12, 0.1) + ) + ); + +process = pitchshifter; diff --git a/dist/examples/psychoacoustic/harmonicExciter.dsp b/dist/examples/psychoacoustic/harmonicExciter.dsp new file mode 100644 index 00000000..54303ee9 --- /dev/null +++ b/dist/examples/psychoacoustic/harmonicExciter.dsp @@ -0,0 +1,10 @@ +declare exciter_name "harmonicExciter"; +declare exciter_author "Priyanka Shekar (pshekar@ccrma.stanford.edu), revised by RM"; +declare exciter_copyright "Copyright (c) 2013 Priyanka Shekar"; +declare exciter_version "1.0"; +declare exciter_license "MIT License (MIT)"; +declare description "Psychoacoustic harmonic exciter, with GUI"; + +import("stdfaust.lib"); + +process = dm.exciter; diff --git a/dist/examples/reverb/dattorro.dsp b/dist/examples/reverb/dattorro.dsp new file mode 100644 index 00000000..cddabe86 --- /dev/null +++ b/dist/examples/reverb/dattorro.dsp @@ -0,0 +1,8 @@ +declare name "dattorro"; +declare version "0.1"; +declare author "Jakob Zerbian"; +declare description "Dattorro demo application."; + +import("stdfaust.lib"); + +process = dm.dattorro_rev_demo; diff --git a/dist/examples/reverb/fdnRev.dsp b/dist/examples/reverb/fdnRev.dsp new file mode 100644 index 00000000..13d9a268 --- /dev/null +++ b/dist/examples/reverb/fdnRev.dsp @@ -0,0 +1,8 @@ +declare name "fdnRev"; +declare version "0.0"; +declare author "JOS, Revised by RM"; +declare description "A feedback delay network reverb."; + +import("stdfaust.lib"); + +process = dm.fdnrev0_demo(16,5,3); diff --git a/dist/examples/reverb/freeverb.dsp b/dist/examples/reverb/freeverb.dsp new file mode 100644 index 00000000..61494404 --- /dev/null +++ b/dist/examples/reverb/freeverb.dsp @@ -0,0 +1,8 @@ +declare name "freeverb"; +declare version "0.0"; +declare author "RM"; +declare description "Freeverb demo application."; + +import("stdfaust.lib"); + +process = dm.freeverb_demo; diff --git a/dist/examples/reverb/greyhole.dsp b/dist/examples/reverb/greyhole.dsp new file mode 100644 index 00000000..d6e943a1 --- /dev/null +++ b/dist/examples/reverb/greyhole.dsp @@ -0,0 +1,8 @@ +declare name "greyhole"; +declare version "0.1"; +declare author "GRAME"; +declare description "Greyhole demo application."; + +import("stdfaust.lib"); + +process = dm.greyhole_demo; diff --git a/dist/examples/reverb/jprev.dsp b/dist/examples/reverb/jprev.dsp new file mode 100644 index 00000000..33425412 --- /dev/null +++ b/dist/examples/reverb/jprev.dsp @@ -0,0 +1,8 @@ +declare name "jprev"; +declare version "0.1"; +declare author "GRAME"; +declare description "Jprev demo application."; + +import("stdfaust.lib"); + +process = dm.jprev_demo; diff --git a/dist/examples/reverb/reverbDesigner.dsp b/dist/examples/reverb/reverbDesigner.dsp new file mode 100644 index 00000000..32369921 --- /dev/null +++ b/dist/examples/reverb/reverbDesigner.dsp @@ -0,0 +1,9 @@ +declare name "reverbDesigner"; + +import("stdfaust.lib"); + +N = 16; // Feedback Delay Network (FDN) order (power of 2, 2 to 16) +NB = 5; // Number of T60-controlled frequency-bands (3 or more) +BSO = 3; // Order of each lowpass/highpass bandsplit (odd positive integer) + +process = dm.fdnrev0_demo(N,NB,BSO); diff --git a/dist/examples/reverb/reverbTester.dsp b/dist/examples/reverb/reverbTester.dsp new file mode 100644 index 00000000..70a1adf0 --- /dev/null +++ b/dist/examples/reverb/reverbTester.dsp @@ -0,0 +1,8 @@ +declare name "reverbTester"; +declare version "0.0"; +declare author "RM"; +declare description "Handy test inputs for reverberator demos below."; + +import("stdfaust.lib"); + +process = dm.stereo_reverb_tester; diff --git a/dist/examples/reverb/zitaRev.dsp b/dist/examples/reverb/zitaRev.dsp new file mode 100644 index 00000000..c9fb3b5f --- /dev/null +++ b/dist/examples/reverb/zitaRev.dsp @@ -0,0 +1,8 @@ +declare name "zitaRev"; +declare version "0.0"; +declare author "JOS, Revised by RM"; +declare description "Example GUI for `zita_rev1_stereo` (mostly following the Linux `zita-rev1` GUI)."; + +import("stdfaust.lib"); + +process = dm.zita_rev1; diff --git a/dist/examples/reverb/zitaRevFDN.dsp b/dist/examples/reverb/zitaRevFDN.dsp new file mode 100644 index 00000000..c51ddc9f --- /dev/null +++ b/dist/examples/reverb/zitaRevFDN.dsp @@ -0,0 +1,8 @@ +declare name "zitaRevFDN"; +declare version "0.0"; +declare author "JOS, Revised by RM"; +declare description "Reverb demo application based on `zita_rev_fdn`."; + +import("stdfaust.lib"); + +process = dm.zita_rev_fdn_demo; diff --git a/dist/examples/smartKeyboard/acGuitar.dsp b/dist/examples/smartKeyboard/acGuitar.dsp new file mode 100644 index 00000000..81c84dab --- /dev/null +++ b/dist/examples/smartKeyboard/acGuitar.dsp @@ -0,0 +1,100 @@ +//############################### acGuitar.dsp ################################# +// Faust instrument specifically designed for `faust2smartkeyb` where 6 virtual +// nylon strings can be strummed and plucked using a dedicated keyboard. The +// extra "strumming keyboard" could be easily replaced by an external strumming +// interface while the touch screen could keep being used to change the pitch +// of the strings. +// +// ## `SmartKeyboard` Use Strategy +// +// The first 6 keyboards implement each individual string of the instrument. A +// seventh keybaord is used a strumming/plucking interface. As mentionned +// previously, it could be easily replaced by an external interface. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. +// However it was specifically designed to be used with `faust2smartkeyb`. For +// best results, we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp acGuitar.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Aug. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//############################################################################## + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'7', + 'Max Keyboard Polyphony':'0', + 'Rounding Mode':'2', + 'Keyboard 0 - Number of Keys':'14', + 'Keyboard 1 - Number of Keys':'14', + 'Keyboard 2 - Number of Keys':'14', + 'Keyboard 3 - Number of Keys':'14', + 'Keyboard 4 - Number of Keys':'14', + 'Keyboard 5 - Number of Keys':'14', + 'Keyboard 6 - Number of Keys':'6', + 'Keyboard 0 - Lowest Key':'52', + 'Keyboard 1 - Lowest Key':'57', + 'Keyboard 2 - Lowest Key':'62', + 'Keyboard 3 - Lowest Key':'67', + 'Keyboard 4 - Lowest Key':'71', + 'Keyboard 5 - Lowest Key':'76', + 'Keyboard 0 - Send Keyboard Freq':'1', + 'Keyboard 1 - Send Keyboard Freq':'1', + 'Keyboard 2 - Send Keyboard Freq':'1', + 'Keyboard 3 - Send Keyboard Freq':'1', + 'Keyboard 4 - Send Keyboard Freq':'1', + 'Keyboard 5 - Send Keyboard Freq':'1', + 'Keyboard 6 - Piano Keyboard':'0', + 'Keyboard 6 - Send Key Status':'1', + 'Keyboard 6 - Key 0 - Label':'S0', + 'Keyboard 6 - Key 1 - Label':'S1', + 'Keyboard 6 - Key 2 - Label':'S2', + 'Keyboard 6 - Key 3 - Label':'S3', + 'Keyboard 6 - Key 4 - Label':'S4', + 'Keyboard 6 - Key 5 - Label':'S5' +}"; + +import("stdfaust.lib"); + +// SMARTKEYBOARD PARAMS +kbfreq(0) = hslider("kb0freq",164.8,20,10000,0.01); +kbbend(0) = hslider("kb0bend",1,0,10,0.01); +kbfreq(1) = hslider("kb1freq",220,20,10000,0.01); +kbbend(1) = hslider("kb1bend",1,0,10,0.01); +kbfreq(2) = hslider("kb2freq",293.7,20,10000,0.01); +kbbend(2) = hslider("kb2bend",1,0,10,0.01); +kbfreq(3) = hslider("kb3freq",392,20,10000,0.01); +kbbend(3) = hslider("kb3bend",1,0,10,0.01); +kbfreq(4) = hslider("kb4freq",493.9,20,10000,0.01); +kbbend(4) = hslider("kb4bend",1,0,10,0.01); +kbfreq(5) = hslider("kb5freq",659.2,20,10000,0.01); +kbbend(5) = hslider("kb5bend",1,0,10,0.01); +kb6kstatus(0) = hslider("kb6k0status",0,0,1,1) <: ==(1) | ==(4) : int; +kb6kstatus(1) = hslider("kb6k1status",0,0,1,1) <: ==(1) | ==(4) : int; +kb6kstatus(2) = hslider("kb6k2status",0,0,1,1) <: ==(1) | ==(4) : int; +kb6kstatus(3) = hslider("kb6k3status",0,0,1,1) <: ==(1) | ==(4) : int; +kb6kstatus(4) = hslider("kb6k4status",0,0,1,1) <: ==(1) | ==(4) : int; +kb6kstatus(5) = hslider("kb6k5status",0,0,1,1) <: ==(1) | ==(4) : int; + +// MODEL PARAMETERS +// strings length +sl(i) = kbfreq(i)*kbbend(i) : pm.f2l : si.smoo; +// pluck position is controlled by the x axis of the accel +pluckPosition = + hslider("pluckPosition[acc: 1 0 -10 0 10]",0.5,0,1,0.01) : si.smoo; + +// ASSEMBLING MODELS +// number of strings +nStrings = 6; +guitar = par(i,nStrings, + kb6kstatus(i) : ba.impulsify : // using "raw" impulses to drive the models + pm.nylonGuitarModel(sl(i),pluckPosition)) :> _; + +process = guitar <: _,_; diff --git a/dist/examples/smartKeyboard/associatedEffects/elecGuitarEffect.dsp b/dist/examples/smartKeyboard/associatedEffects/elecGuitarEffect.dsp new file mode 100644 index 00000000..e73f299f --- /dev/null +++ b/dist/examples/smartKeyboard/associatedEffects/elecGuitarEffect.dsp @@ -0,0 +1,8 @@ +// a stereo distortion effect connected to a stereo reverb + +import("stdfaust.lib"); + +distDrive = 0.8; +distOffset = 0; + +process = par(i,2,ef.cubicnl(distDrive,distOffset)) : dm.zita_rev1; \ No newline at end of file diff --git a/dist/examples/smartKeyboard/associatedEffects/myEffect.dsp b/dist/examples/smartKeyboard/associatedEffects/myEffect.dsp new file mode 100644 index 00000000..1755f4b6 --- /dev/null +++ b/dist/examples/smartKeyboard/associatedEffects/myEffect.dsp @@ -0,0 +1,5 @@ +// Just calling zita_rev1 from demo.lib + +import("stdfaust.lib"); + +process = dm.zita_rev1; \ No newline at end of file diff --git a/dist/examples/smartKeyboard/associatedEffects/reverb.dsp b/dist/examples/smartKeyboard/associatedEffects/reverb.dsp new file mode 100644 index 00000000..1755f4b6 --- /dev/null +++ b/dist/examples/smartKeyboard/associatedEffects/reverb.dsp @@ -0,0 +1,5 @@ +// Just calling zita_rev1 from demo.lib + +import("stdfaust.lib"); + +process = dm.zita_rev1; \ No newline at end of file diff --git a/dist/examples/smartKeyboard/bells.dsp b/dist/examples/smartKeyboard/bells.dsp new file mode 100644 index 00000000..c3cc877b --- /dev/null +++ b/dist/examples/smartKeyboard/bells.dsp @@ -0,0 +1,80 @@ +//################################ bells.dsp ################################### +// Faust instrument specifically designed for `faust2smartkeyb` where the +// physical models of 4 different bells can be played using screen pads. The +// models are taken from `physmodels.lib`. +// +// ## `SmartKeyboard` Use Strategy +// +// The `SmartKeyboard` interface is used to implement percussion pads where +// the X/Y position of fingers is retrieved to control the strike position on +// the bells. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. +// However it was specifically designed to be used with `faust2smartkeyb`. For +// best results, we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp bells.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Aug. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//############################################################################## + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'2', + 'Max Keyboard Polyphony':'0', + 'Keyboard 0 - Number of Keys':'2', + 'Keyboard 1 - Number of Keys':'2', + 'Keyboard 0 - Send Freq':'0', + 'Keyboard 1 - Send Freq':'0', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 1 - Piano Keyboard':'0', + 'Keyboard 0 - Send Key Status':'1', + 'Keyboard 1 - Send Key Status':'1', + 'Keyboard 0 - Send X':'1', + 'Keyboard 0 - Send Y':'1', + 'Keyboard 1 - Send X':'1', + 'Keyboard 1 - Send Y':'1', + 'Keyboard 0 - Key 0 - Label':'English Bell', + 'Keyboard 0 - Key 1 - Label':'French Bell', + 'Keyboard 1 - Key 0 - Label':'German Bell', + 'Keyboard 1 - Key 1 - Label':'Russian Bell' +}"; + +import("stdfaust.lib"); + +// SMARTKEYBOARD PARAMS +kb0k0status = hslider("kb0k0status",0,0,1,1) : min(1) : int; +kb0k1status = hslider("kb0k1status",0,0,1,1) : min(1) : int; +kb1k0status = hslider("kb1k0status",0,0,1,1) : min(1) : int; +kb1k1status = hslider("kb1k1status",0,0,1,1) : min(1) : int; +x = hslider("x",1,0,1,0.001); +y = hslider("y",1,0,1,0.001); + +// MODEL PARAMETERS +strikeCutoff = 6500; +strikeSharpness = 0.5; +strikeGain = 1; +// synthesize 10 modes out of 50 +nModes = 10; +// resonance duration is 30s +t60 = 30; +// number of excitation pos (retrieved from model) +nExPos = 7; +// computing excitation position from X and Y +exPos = min((x*2-1 : abs),(y*2-1 : abs))*(nExPos-1) : int; + +// ASSEMBLING MODELS +bells = + (kb0k0status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.englishBellModel(nModes,exPos,t60,1,3)) + + (kb0k1status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.frenchBellModel(nModes,exPos,t60,1,3)) + + (kb1k0status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.germanBellModel(nModes,exPos,t60,1,2.5)) + + (kb1k1status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.russianBellModel(nModes,exPos,t60,1,3)) :> *(0.2); + +process = bells <: _,_; diff --git a/dist/examples/smartKeyboard/bowed.dsp b/dist/examples/smartKeyboard/bowed.dsp new file mode 100644 index 00000000..b567f41b --- /dev/null +++ b/dist/examples/smartKeyboard/bowed.dsp @@ -0,0 +1,87 @@ +//##################################### bowed.dsp ######################################## +// Faust instrument specifically designed for `faust2smartkeyb` implementing a +// non-polyphonic synthesizer (e.g., physical model; etc.) using a combination of +// different types of UI elements. +// +// ## `SmartKeyboard` Use Strategy +// +// 5 keyboards are declared (4 actual keyboards and 1 control surface). We want to +// disable the voice allocation system and we want to activate a voice on start-up +// so that all strings are constantly running so we set `Max Keyboard Polyphony` to +// 0. Since we don't want the first 4 keyboards to send the X and Y position of +// fingers on the screen, we set `Send X` and `Send Y` to 0 for all these keyboards. +// Similarly, we don't want the fifth keyboard to send pitch information to the synth +// so we set `Send Freq` to 0 for that keyboard. Finally, we deactivate piano keyboard +// mode for the fifth keyboard to make sure that color doesn't change when the key is +// touch and that note names are not displayed. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp midiOnly.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'5', + 'Max Keyboard Polyphony':'0', + 'Rounding Mode':'1', + 'Keyboard 0 - Number of Keys':'19', + 'Keyboard 1 - Number of Keys':'19', + 'Keyboard 2 - Number of Keys':'19', + 'Keyboard 3 - Number of Keys':'19', + 'Keyboard 4 - Number of Keys':'1', + 'Keyboard 4 - Send Freq':'0', + 'Keyboard 0 - Send X':'0', + 'Keyboard 1 - Send X':'0', + 'Keyboard 2 - Send X':'0', + 'Keyboard 3 - Send X':'0', + 'Keyboard 0 - Send Y':'0', + 'Keyboard 1 - Send Y':'0', + 'Keyboard 2 - Send Y':'0', + 'Keyboard 3 - Send Y':'0', + 'Keyboard 0 - Lowest Key':'55', + 'Keyboard 1 - Lowest Key':'62', + 'Keyboard 2 - Lowest Key':'69', + 'Keyboard 3 - Lowest Key':'76', + 'Keyboard 4 - Piano Keyboard':'0', + 'Keyboard 4 - Key 0 - Label':'Bow' +}"; + +import("stdfaust.lib"); + +// parameters +f = hslider("freq",400,50,2000,0.01); +bend = hslider("bend",1,0,10,0.01); +keyboard = hslider("keyboard",0,0,5,1) : int; +key = hslider("key",0,0,18,1) : int; +x = hslider("x",0.5,0,1,0.01) : si.smoo; +y = hslider("y",0,0,1,0.01) : si.smoo; + +// mapping +freq = f*bend; +// dirty motion tracker +velocity = x-x' : abs : an.amp_follower_ar(0.1,1) : *(8000) : min(1); + +// 4 "strings" +synthSet = par(i,4,synth(localFreq(i),velocity)) :> _ +with{ + localFreq(i) = freq : ba.sAndH(keyboard == i) : si.smoo; + synth(freq,velocity) = sy.fm((freq,freq + freq*modFreqRatio),index*velocity)*velocity + with{ + index = 1000; + modFreqRatio = y*0.3; + }; +}; + +process = synthSet <: _,_; \ No newline at end of file diff --git a/dist/examples/smartKeyboard/brass.dsp b/dist/examples/smartKeyboard/brass.dsp new file mode 100644 index 00000000..d4ed673c --- /dev/null +++ b/dist/examples/smartKeyboard/brass.dsp @@ -0,0 +1,82 @@ +//############################### brass.dsp ################################### +// Faust instrument specifically designed for `faust2smartkeyb` where a +// trumpet physical model is controlled using some of the built-in sensors of +// the device and the touchscreen. Some of these elements could be replaced by +// external controllers (e.g., breath/mouth piece controller). +// +// ## `SmartKeyboard` Use Strategy +// +// 1 keyboard is used to implement the pistons of the trumpet (3 keys) and the +// other allows to control the lips tension. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. +// However it was specifically designed to be used with `faust2smartkeyb`. For +// best results, we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp brass.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Aug. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//############################################################################## + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'2', + 'Max Keyboard Polyphony':'0', + 'Keyboard 0 - Number of Keys':'1', + 'Keyboard 1 - Number of Keys':'3', + 'Keyboard 0 - Send Freq':'0', + 'Keyboard 1 - Send Freq':'0', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 1 - Piano Keyboard':'0', + 'Keyboard 0 - Send Key X':'1', + 'Keyboard 1 - Send Key Status':'1', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 0 - Key 0 - Label':'Lips Tension', + 'Keyboard 1 - Key 0 - Label':'P1', + 'Keyboard 1 - Key 1 - Label':'P2', + 'Keyboard 1 - Key 2 - Label':'P3' +}"; + +import("stdfaust.lib"); + +// SMARTKEYBOARD PARAMS +kb0k0x = hslider("kb0k0x",0,0,1,1); +kb1k0status = hslider("kb1k0status",0,0,1,1) : min(1) : int; +kb1k1status = hslider("kb1k1status",0,0,1,1) : min(1) : int; +kb1k2status = hslider("kb1k2status",0,0,1,1) : min(1) : int; + +// MODEL PARAMETERS +// pressure is controlled by accelerometer +pressure = hslider("pressure[acc: 1 1 -10 0 10]",0,0,1,0.01) : si.smoo; +breathGain = 0.005; breathCutoff = 2000; +vibratoFreq = 5; vibratoGain = 0; +//pitch when no pistons are pushed +basePitch = 48; // C4 +// calculate pitch shift in function of piston combination +pitchShift = + ((kb1k0status == 0) & (kb1k1status == 1) & (kb1k2status == 0))*(1) + + ((kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 0))*(2) + + ((kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 0))*(3) + + ((kb1k0status == 0) & (kb1k1status == 1) & (kb1k2status == 1))*(4) + + ((kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 1))*(5) + + ((kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 1))*(6); +// tube length is calculated based on piston combination +tubeLength = basePitch-pitchShift : ba.midikey2hz : pm.f2l : si.smoo; +// lips tension is controlled using pad on screen +lipsTension = kb0k0x : si.smoo; +// default mute value +mute = 0.5; + +// ASSEMBLING MODEL +model = + pm.blower(pressure,breathGain,breathCutoff,vibratoFreq,vibratoGain) : + pm.brassModel(tubeLength,lipsTension,mute); + +process = model <: _,_; diff --git a/dist/examples/smartKeyboard/clarinet.dsp b/dist/examples/smartKeyboard/clarinet.dsp new file mode 100644 index 00000000..84122f5c --- /dev/null +++ b/dist/examples/smartKeyboard/clarinet.dsp @@ -0,0 +1,113 @@ +//############################### clarinet.dsp ################################# +// Faust instrument specifically designed for `faust2smartkeyb` where a +// clarinet physical model is controlled by an interface implementing +// fingerings similar to that of a the real instrument. The pressure of the +// breath in the mouthpiece of the clarinet is controlled by blowing on the +// built-in microphone of the device. +// +// ## `SmartKeyboard` Use Strategy +// +// The device is meant to be held with 2 hands vertically in order to put all +// fingers on the screen at the same time. Key combinations determine the +// pitch of the instrument. A single voice is constantly ran. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. +// However it was specifically designed to be used with `faust2smartkeyb`. For +// best results, we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] clarinet.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Aug. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//############################################################################## + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'2', + 'Max Keyboard Polyphony':'0', + 'Keyboard 0 - Number of Keys':'4', + 'Keyboard 1 - Number of Keys':'5', + 'Keyboard 0 - Send Freq':'0', + 'Keyboard 1 - Send Freq':'0', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 1 - Piano Keyboard':'0', + 'Keyboard 0 - Send Key Status':'1', + 'Keyboard 1 - Send Key Status':'1', + 'Keyboard 0 - Key 3 - Label':'O+', + 'Keyboard 1 - Key 4 - Label':'O-' +}"; + +import("stdfaust.lib"); + +// SMARTKEYBOARD PARAMS +kb0k0status = hslider("kb0k0status",0,0,1,1) : min(1) : int; +kb0k1status = hslider("kb0k1status",0,0,1,1) : min(1) : int; +kb0k2status = hslider("kb0k2status",0,0,1,1) : min(1) : int; +kb0k3status = hslider("kb0k3status",0,0,1,1) : min(1) : int; +kb1k0status = hslider("kb1k0status",0,0,1,1) : min(1) : int; +kb1k1status = hslider("kb1k1status",0,0,1,1) : min(1) : int; +kb1k2status = hslider("kb1k2status",0,0,1,1) : min(1) : int; +kb1k3status = hslider("kb1k3status",0,0,1,1) : min(1) : int; +kb1k4status = hslider("kb1k4status",0,0,1,1) : min(1) : int; + +// MODEL PARAMETERS +reedStiffness = hslider("reedStiffness[acc: 1 1 -10 0 10]",0,0,1,0.01) : si.smoo; +basePitch = 73; // C#4 +pitchShift = // calculate pitch shfit in function of "keys" combination + ((kb0k0status == 0) & (kb0k1status == 1) & (kb0k2status == 0) & + (kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 0))*(-1) + // C + ((kb0k0status == 1) & (kb0k1status == 0) & (kb0k2status == 0) & + (kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 0))*(-2) + // B + ((kb0k0status == 1) & (kb0k1status == 0) & (kb0k2status == 1) & + (kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 0))*(-3) + // Bb + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 0) & + (kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 0))*(-4) + // A + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 0) & + (kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 0))*(-5) + // G# + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) & + (kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 0))*(-6) + // G + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) & + (kb1k0status == 0) & (kb1k1status == 1) & (kb1k2status == 0) & + (kb1k3status == 0))*(-7) + // F# + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) & + (kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 0))*(-8) + // F + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) & + (kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 0) & + (kb1k3status == 0))*(-9) + // E + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) & + (kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 0) & + (kb1k3status == 1))*(-10) + // Eb + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) & + (kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 1) & + (kb1k3status == 0))*(-11) + // D + ((kb0k0status == 0) & (kb0k1status == 0) & (kb0k2status == 0) & + (kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) & + (kb1k3status == 1))*(-12) + // C# + ((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) & + (kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 1) & + (kb1k3status == 1))*(-13); // C +octaveShiftUp = +(kb0k3status : ba.impulsify)~_; // counting up +octaveShiftDown = +(kb1k4status : ba.impulsify)~_; // counting down +octaveShift = (octaveShiftUp-octaveShiftDown)*(12); +// tube length is just smoothed: could be improved +tubeLength = basePitch+pitchShift+octaveShift : ba.midikey2hz : pm.f2l : si.smoo; +bellOpening = 0.5; + +// ASSEMBLING MODEL +model(pressure) = pm.clarinetModel(tubeLength,pressure,reedStiffness,bellOpening); + +// pressure is estimated from mic signal +process = an.amp_follower_ud(0.02,0.02)*0.7 : model <: _,_; diff --git a/dist/examples/smartKeyboard/crazyGuiro.dsp b/dist/examples/smartKeyboard/crazyGuiro.dsp new file mode 100644 index 00000000..33492dc6 --- /dev/null +++ b/dist/examples/smartKeyboard/crazyGuiro.dsp @@ -0,0 +1,96 @@ +//################################### crazyGuiro.dsp ##################################### +// A simple smart phone "Guiro" where the touch screen is used to drive the instrument and +// select its pitch and where the x and y axis of the accelerometer control the +// resonance properties of the instrument. +// +// ## `SmartKeyboard` Use Strategy +// +// Since the sounds generated by this synth are very short, the strategy here is to take +// advantage of the polyphony capabilities of the iOSKeyboard architecture by creating +// a new voice every time a new key is pressed. Since the `SmartKeyboard` interface has a +// large number of keys here (128), lots of sounds are generated when sliding a +// finger across the keyboard. Also, it's interesting to notice that the `freq` parameter +// is not used here. Instead `keyboard` and `key` are used which allows us to easily +// make custom mappings. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] crazyGuiro.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +import("stdfaust.lib"); + + +//========================= Smart Keyboard Configuration ================================= +// 8 keyboards, each has 16 keys, none of them display key names. +//======================================================================================== + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'8', + 'Keyboard 0 - Number of Keys':'16', + 'Keyboard 1 - Number of Keys':'16', + 'Keyboard 2 - Number of Keys':'16', + 'Keyboard 3 - Number of Keys':'16', + 'Keyboard 4 - Number of Keys':'16', + 'Keyboard 5 - Number of Keys':'16', + 'Keyboard 6 - Number of Keys':'16', + 'Keyboard 7 - Number of Keys':'16', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 1 - Piano Keyboard':'0', + 'Keyboard 2 - Piano Keyboard':'0', + 'Keyboard 3 - Piano Keyboard':'0', + 'Keyboard 4 - Piano Keyboard':'0', + 'Keyboard 5 - Piano Keyboard':'0', + 'Keyboard 6 - Piano Keyboard':'0', + 'Keyboard 7 - Piano Keyboard':'0' +}"; + + +//================================ Instrument Parameters ================================= +// Creates the connection between the synth and the mobile device +//======================================================================================== + +// the current keyboard +keyboard = hslider("keyboard",0,0,2,1); +// the current key of the current keyboard +key = hslider("key",0,0,2,1); +// the wet factor of the reverb +wet = hslider("wet[acc: 0 0 -10 0 10]",0,0,1,0.01); +// the resonance factor of the reverb +res = hslider("res[acc: 1 0 -10 0 10]",0.5,0,1,0.01); +// smart keyboard gate parameter +gate = button("gate"); + + +//=================================== Parameters Mapping ================================= +//======================================================================================== + +// the resonance frequency of each click of the Guiro changes in function of +// the selected keyboard and key on it +minKey = 50; // min key of lowest keyboard +keySkipKeyboard = 8; // key skip per keyboard +drumResFreq = (key+minKey)+(keyboard*keySkipKeyboard) : ba.midikey2hz; +reverbWet = wet : si.smoo; +reverbRes = wet : si.smoo; + +// filter q +q = 8; + +//============================================ DSP ======================================= +//======================================================================================== + +reverb(wet,res) = _ <: *(1-wet),(*(wet) : re.mono_freeverb(res, 0.5, 0.5, 0)) :> _; + +process = sy.popFilterDrum(drumResFreq,q,gate) : reverb(wet,res) <: _,_; diff --git a/dist/examples/smartKeyboard/drums.dsp b/dist/examples/smartKeyboard/drums.dsp new file mode 100644 index 00000000..441c9571 --- /dev/null +++ b/dist/examples/smartKeyboard/drums.dsp @@ -0,0 +1,74 @@ +//##################################### drums.dsp ######################################## +// Faust instrument specifically designed for `faust2smartkeyb` where 3 drums can +// be controlled using pads. The X/Y postion of fingers is detected on each key +// and use to control the strike postion on the virtual membrane. +// +// ## `SmartKeyboard` Use Strategy +// +// The drum physical model used here is implemented to be generic so that its +// fundamental frequency can be changed for each voice. `SmartKeyboard` is used +// in polyphonic mode so each new strike on the interface corresponds to a new +// new voice. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp drums.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +// Interface with 2 keyboards of 2 and 1 keys (3 pads) +// Static mode is used so that keys don't change color when touched +// Note labels are hidden +// Piano Keyboard mode is deactivated so all the keys look the same +declare interface "SmartKeyboard{ + 'Number of Keyboards':'2', + 'Keyboard 0 - Number of Keys':'2', + 'Keyboard 1 - Number of Keys':'1', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 1 - Static Mode':'1', + 'Keyboard 0 - Send X':'1', + 'Keyboard 0 - Send Y':'1', + 'Keyboard 1 - Send X':'1', + 'Keyboard 1 - Send Y':'1', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 1 - Piano Keyboard':'0', + 'Keyboard 0 - Key 0 - Label':'High', + 'Keyboard 0 - Key 1 - Label':'Mid', + 'Keyboard 1 - Key 0 - Label':'Low' +}"; + +import("stdfaust.lib"); + +// standard parameters +gate = button("gate"); +x = hslider("x",1,0,1,0.001); +y = hslider("y",1,0,1,0.001); +keyboard = hslider("keyboard",0,0,1,1) : int; +key = hslider("key",0,0,1,1) : int; + +drumModel = pm.djembe(rootFreq,exPos,strikeSharpness,gain,gate) +with{ + // frequency of the lowest drum + bFreq = 60; + // retrieving pad ID (0-2) + padID = 2-(keyboard*2+key); + // drum root freq is computed in function of pad number + rootFreq = bFreq*(padID+1); + // excitation position + exPos = min((x*2-1 : abs),(y*2-1 : abs)); + strikeSharpness = 0.5; + gain = 2; +}; + +process = drumModel <: _,_; diff --git a/dist/examples/smartKeyboard/dubDub.dsp b/dist/examples/smartKeyboard/dubDub.dsp new file mode 100644 index 00000000..5744a907 --- /dev/null +++ b/dist/examples/smartKeyboard/dubDub.dsp @@ -0,0 +1,87 @@ +//################################### dubDub.dsp ##################################### +// A simple smartphone abstract instrument than can be controlled using the touch +// screen and the accelerometers of the device. +// +// ## `SmartKeyboard` Use Strategy +// +// The idea here is to use the `SmartKeyboard` interface as an X/Y control pad by just +// creating one keyboard with on key and by retrieving the X and Y position on that single +// key using the `x` and `y` standard parameters. Keyboard mode is deactivated so that +// the color of the pad doesn't change when it is pressed. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] dubDub.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +declare name "dubDub"; + +import("stdfaust.lib"); + +//========================= Smart Keyboard Configuration ================================= +// (1 keyboards with 1 key configured as a pad. +//======================================================================================== + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'1', + 'Keyboard 0 - Number of Keys':'1', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 0 - Send X':'1', + 'Keyboard 0 - Send Y':'1' +}"; + + +//================================ Instrument Parameters ================================= +// Creates the connection between the synth and the mobile device +//======================================================================================== + +// SmartKeyboard X parameter +x = hslider("x",0,0,1,0.01); +// SmartKeyboard Y parameter +y = hslider("y",0,0,1,0.01); +// SmartKeyboard gate parameter +gate = button("gate"); +// modulation frequency is controlled with the x axis of the accelerometer +modFreq = hslider("modFeq[acc: 0 0 -10 0 10]",9,0.5,18,0.01); +// general gain is controlled with the y axis of the accelerometer +gain = hslider("gain[acc: 1 0 -10 0 10]",0.5,0,1,0.01); + + +//=================================== Parameters Mapping ================================= +//======================================================================================== + +// sawtooth frequency +minFreq = 80; +maxFreq = 500; +freq = x*(maxFreq-minFreq) + minFreq : si.polySmooth(gate,0.999,1); + +// filter q +q = 8; + +// filter cutoff frequency is modulate with a triangle wave +minFilterCutoff = 50; +maxFilterCutoff = 5000; +filterModFreq = modFreq : si.smoo; +filterCutoff = (1-os.lf_trianglepos(modFreq)*(1-y))*(maxFilterCutoff-minFilterCutoff)+minFilterCutoff; + +// general gain of the synth +generalGain = gain : ba.lin2LogGain : si.smoo; + + +//============================================ DSP ======================================= +//======================================================================================== + +process = sy.dubDub(freq,filterCutoff,q,gate)*generalGain <: _,_; diff --git a/dist/examples/smartKeyboard/elecGuitar.dsp b/dist/examples/smartKeyboard/elecGuitar.dsp new file mode 100644 index 00000000..52f3562d --- /dev/null +++ b/dist/examples/smartKeyboard/elecGuitar.dsp @@ -0,0 +1,67 @@ +//################################### elecGuitar.dsp ##################################### +// Faust instruments specifically designed for `faust2smartkeyb` where an electric +// guitar physical model is controlled using an isomorphic keyboard. Rock on! +// +// ## `SmartKeyboard` Use Strategy +// +// we want to create an isomorphic keyboard where each keyboard is monophonic and +// implements a "string". Keyboards should be one fourth apart from each other +// (more or less like on a guitar). We want to be able to slide between keyboards +// (strum) to trigger a new note (voice) and we want new fingers on a keyboard to +// "steal" the pitch from the previous finger (sort of hammer on). +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect elecGuitarEffecr.dsp elecGuitar.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017: +// https://ccrma.stanford.edu/~rmichon +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +// Interface with 6 monophonic keyboards one fourth apart from each other +declare interface "SmartKeyboard{ + 'Number of Keyboards':'6', + 'Max Keyboard Polyphony':'1', + 'Keyboard 0 - Number of Keys':'13', + 'Keyboard 1 - Number of Keys':'13', + 'Keyboard 2 - Number of Keys':'13', + 'Keyboard 3 - Number of Keys':'13', + 'Keyboard 4 - Number of Keys':'13', + 'Keyboard 5 - Number of Keys':'13', + 'Keyboard 0 - Lowest Key':'72', + 'Keyboard 1 - Lowest Key':'67', + 'Keyboard 2 - Lowest Key':'62', + 'Keyboard 3 - Lowest Key':'57', + 'Keyboard 4 - Lowest Key':'52', + 'Keyboard 5 - Lowest Key':'47', + 'Rounding Mode':'2' +}"; + +import("stdfaust.lib"); + +// standard parameters +f = hslider("freq",300,50,2000,0.01); +bend = hslider("bend[midi:pitchwheel]",1,0,10,0.01) : si.polySmooth(gate,0.999,1); +gain = hslider("gain",1,0,1,0.01); +s = hslider("sustain[midi:ctrl 64]",0,0,1,1); // for sustain pedal +t = button("gate"); + +// mapping params +gate = t+s : min(1); +freq = f*bend : max(60); // min freq is 60 Hz + +stringLength = freq : pm.f2l; +pluckPosition = 0.8; +mute = gate : si.polySmooth(gate,0.999,1); + +process = pm.elecGuitar(stringLength,pluckPosition,mute,gain,gate) <: _,_; diff --git a/dist/examples/smartKeyboard/fm.dsp b/dist/examples/smartKeyboard/fm.dsp new file mode 100644 index 00000000..a5629b55 --- /dev/null +++ b/dist/examples/smartKeyboard/fm.dsp @@ -0,0 +1,78 @@ +//###################################### fm.dsp ########################################## +// A simple smart phone percussion abstract sound toy based on an FM synth. +// +// ## `SmartKeyboard` Use Strategy +// +// The idea here is to use the `SmartKeyboard` interface as an X/Y control pad by just +// creating one keyboard with on key and by retrieving the X and Y position on that single +// key using the `x` and `y` standard parameters. Keyboard mode is deactivated so that +// the color of the pad doesn't change when it is pressed. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] crazyGuiro.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +declare name "fm"; + +import("stdfaust.lib"); + +//========================= Smart Keyboard Configuration ================================= +// (1 keyboards with 1 key configured as a pad. +//======================================================================================== + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'1', + 'Keyboard 0 - Number of Keys':'1', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 0 - Send X':'1', + 'Keyboard 0 - Send Y':'1' +}"; + +//================================ Instrument Parameters ================================= +// Creates the connection between the synth and the mobile device +//======================================================================================== + +// SmartKeyboard X parameter +x = hslider("x",0,0,1,0.01); +// SmartKeyboard Y parameter +y = hslider("y",0,0,1,0.01); +// SmartKeyboard gate parameter +gate = button("gate") ; +// mode resonance duration is controlled with the x axis of the accelerometer +modFreqRatio = hslider("res[acc: 0 0 -10 0 10]",1,0,2,0.01) : si.smoo; + +//=================================== Parameters Mapping ================================= +//======================================================================================== + +// carrier frequency +minFreq = 80; +maxFreq = 500; +cFreq = x*(maxFreq-minFreq) + minFreq : si.polySmooth(gate,0.999,1); + +// modulator frequency +modFreq = cFreq*modFreqRatio; + +// modulation index +modIndex = y*1000 : si.smoo; + +//============================================ DSP ======================================= +//======================================================================================== + +// since the generated sound is pretty chaotic, there is no need for an envelope generator +fmSynth = sy.fm((cFreq,modFreq),(modIndex))*(gate : si.smoo)*0.5; + +process = fmSynth; diff --git a/dist/examples/smartKeyboard/frog.dsp b/dist/examples/smartKeyboard/frog.dsp new file mode 100644 index 00000000..cf3c7077 --- /dev/null +++ b/dist/examples/smartKeyboard/frog.dsp @@ -0,0 +1,74 @@ +//################################### frog.dsp ##################################### +// A simple smart phone abstract instrument than can be controlled using the touch +// screen and the accelerometers of the device. +// +// ## `SmartKeyboard` Use Strategy +// +// The idea here is to use the `SmartKeyboard` interface as an X/Y control pad by just +// creating one keyboard with on key and by retrieving the X and Y position on that single +// key using the `x` and `y` standard parameters. Keyboard mode is deactivated so that +// the color of the pad doesn't change when it is pressed. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] frog.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +declare name "frog"; + +import("stdfaust.lib"); + +//========================= Smart Keyboard Configuration ================================= +// (1 keyboards with 1 key configured as a pad. +//======================================================================================== + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'1', + 'Keyboard 0 - Number of Keys':'1', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 0 - Send X':'1', + 'Keyboard 0 - Send Y':'1' +}"; + +//================================ Instrument Parameters ================================= +// Creates the connection between the synth and the mobile device +//======================================================================================== + +// SmartKeyboard X parameter +x = hslider("x",0,0,1,0.01); +// SmartKeyboard Y parameter +y = hslider("y",0,0,1,0.01); +// SmartKeyboard gate parameter +gate = button("gate"); +// the cutoff frequency of the filter is controlled with the x axis of the accelerometer +cutoff = hslider("cutoff[acc: 0 0 -10 0 10]",2500,50,5000,0.01); + +//=================================== Parameters Mapping ================================= +//======================================================================================== + +maxFreq = 100; +minFreq = 1; +freq = x*(maxFreq-minFreq) + minFreq : si.polySmooth(gate,0.999,1); + +maxQ = 40; +minQ = 1; +q = (1-y)*(maxQ-minQ) + minQ : si.smoo; +filterCutoff = cutoff : si.smoo; + +//============================================ DSP ======================================= +//======================================================================================== + +process = sy.dubDub(freq,filterCutoff,q,gate) <: _,_; diff --git a/dist/examples/smartKeyboard/harp.dsp b/dist/examples/smartKeyboard/harp.dsp new file mode 100644 index 00000000..bd4bd251 --- /dev/null +++ b/dist/examples/smartKeyboard/harp.dsp @@ -0,0 +1,84 @@ +//######################################## harp.dsp ###################################### +// A simple smart phone based harp (if we dare to call it like that). +// +// ## `SmartKeyboard` Use Strategy +// +// Since the sounds generated by this synth are very short, the strategy here is to take +// advantage of the polyphony capabilities of the iOSKeyboard architecture by creating +// a new voice every time a new key is pressed. Since the `SmartKeyboard` interface has a +// large number of keys here (128), lots of sounds are generated when sliding a +// finger across the keyboard. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] harp.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +declare name "harp"; + +import("stdfaust.lib"); + +//========================= Smart Keyboard Configuration ================================= +// (8 keyboards with 16 keys configured as a pitch matrix. +//======================================================================================== + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'8', + 'Keyboard 0 - Number of Keys':'16', + 'Keyboard 1 - Number of Keys':'16', + 'Keyboard 2 - Number of Keys':'16', + 'Keyboard 3 - Number of Keys':'16', + 'Keyboard 4 - Number of Keys':'16', + 'Keyboard 5 - Number of Keys':'16', + 'Keyboard 6 - Number of Keys':'16', + 'Keyboard 7 - Number of Keys':'16', + 'Keyboard 0 - Lowest Key':'40', + 'Keyboard 1 - Lowest Key':'45', + 'Keyboard 2 - Lowest Key':'50', + 'Keyboard 3 - Lowest Key':'55', + 'Keyboard 4 - Lowest Key':'60', + 'Keyboard 5 - Lowest Key':'65', + 'Keyboard 6 - Lowest Key':'70', + 'Keyboard 7 - Lowest Key':'75', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 1 - Piano Keyboard':'0', + 'Keyboard 2 - Piano Keyboard':'0', + 'Keyboard 3 - Piano Keyboard':'0', + 'Keyboard 4 - Piano Keyboard':'0', + 'Keyboard 5 - Piano Keyboard':'0', + 'Keyboard 6 - Piano Keyboard':'0', + 'Keyboard 7 - Piano Keyboard':'0' +}"; + +//================================ Instrument Parameters ================================= +// Creates the connection between the synth and the mobile device +//======================================================================================== + +// the string resonance in second is controlled by the x axis of the accelerometer +res = hslider("res[acc: 0 0 -10 0 10]",2,0.1,4,0.01); +// Smart Keyboard frequency parameter +freq = hslider("freq",400,50,2000,0.01); +// Smart Keyboard gate parameter +gate = button("gate"); + +//=================================== Parameters Mapping ================================= +//======================================================================================== + +stringFreq = freq; + +//============================================ DSP ======================================= +//======================================================================================== + +process = sy.combString(freq,res,gate); diff --git a/dist/examples/smartKeyboard/midiOnly.dsp b/dist/examples/smartKeyboard/midiOnly.dsp new file mode 100644 index 00000000..53f478fc --- /dev/null +++ b/dist/examples/smartKeyboard/midiOnly.dsp @@ -0,0 +1,62 @@ +//################################### midiOnly.dsp ###################################### +// Faust instrument specifically designed for `faust2smartkeyb` implementing a MIDI +// controllable app where the mobile device's touch screen is used to control +// specific parameters of the synth continuously using two separate X/Y control surfaces. +// +// ## `SmartKeyboard` Use Strategy +// +// The `SmartKeyboard` configuration for this instrument consists in a single keyboard +// with two keys. Each key implements a control surface. `Piano Keyboard` mode is +// disabled so that key names are not displayed and that keys don't change color when +// touched. Finally, `Send Freq` is set to 0 so that new voices are not allocated by +// the touch screen and that the `freq` and `bend` parameters are not computed. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp midiOnly.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +// Interface with 4 polyphnic keyboards of 13 keys with the same config +declare interface "SmartKeyboard{ + 'Number of Keyboards':'1', + 'Keyboard 0 - Number of Keys':'2', + 'Keyboard 0 - Send Freq':'0', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 0 - Send Key X':'1', + 'Keyboard 0 - Key 0 - Label':'Mod Index', + 'Keyboard 0 - Key 1 - Label':'Mod Freq' +}"; + +import("stdfaust.lib"); + +f = hslider("freq",300,50,2000,0.01); +bend = ba.semi2ratio(hslider("bend[midi:pitchwheel]",0,-2,2,0.001)) : si.polySmooth(gate,0.999,1); +gain = hslider("gain",1,0,1,0.01); +key = hslider("key",0,0,1,1) : int; +kb0k0x = hslider("kb0k0x[midi:ctrl 1]",0.5,0,1,0.01) : si.smoo; +kb0k1x = hslider("kb0k1x[midi:ctrl 1]",0.5,0,1,0.01) : si.smoo; +s = hslider("sustain[midi:ctrl 64]",0,0,1,1); +t = button("gate"); + +// fomating parameters +gate = t+s : min(1); +freq = f*bend; +index = kb0k0x*1000; +modFreqRatio = kb0k1x; + +envelope = gain*gate : si.smoo; + +process = sy.fm((freq,freq + freq*modFreqRatio),index*envelope)*envelope <: _,_; diff --git a/dist/examples/smartKeyboard/multiSynth.dsp b/dist/examples/smartKeyboard/multiSynth.dsp new file mode 100644 index 00000000..36a65254 --- /dev/null +++ b/dist/examples/smartKeyboard/multiSynth.dsp @@ -0,0 +1,75 @@ +//################################### multiSynth.dsp ###################################### +// Faust instrument specifically designed for `faust2smartkeyb` where 4 keyboards +// are used to control 4 independent synths. +// +// ## `SmartKeyboard` Use Strategy +// +// The `SmartKeyboard` configuration is relatively simple for this example and +// only consists in four polyphonic keyboards in parallel. The `keyboard` standard +// parameter is used to activate specific elements of the synthesizer. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp multiSynth.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +// Interface with 4 polyphnic keyboards of 13 keys with the same config +declare interface "SmartKeyboard{ + 'Number of Keyboards':'4', + 'Rounding Mode':'2', + 'Inter-Keyboard Slide':'0', + 'Keyboard 0 - Number of Keys':'13', + 'Keyboard 1 - Number of Keys':'13', + 'Keyboard 2 - Number of Keys':'13', + 'Keyboard 3 - Number of Keys':'13', + 'Keyboard 0 - Lowest Key':'60', + 'Keyboard 1 - Lowest Key':'60', + 'Keyboard 2 - Lowest Key':'60', + 'Keyboard 3 - Lowest Key':'60', + 'Keyboard 0 - Send Y':'1', + 'Keyboard 1 - Send Y':'1', + 'Keyboard 2 - Send Y':'1', + 'Keyboard 3 - Send Y':'1' +}"; + +import("stdfaust.lib"); + +// standard parameters +f = hslider("freq",300,50,2000,0.01); +bend = ba.semi2ratio(hslider("bend[midi:pitchwheel]",0,-2,2,0.001)) : si.polySmooth(gate,0.999,1); +gain = hslider("gain",1,0,1,0.01); +s = hslider("sustain[midi:ctrl 64]",0,0,1,1); // for sustain pedal +t = button("gate"); +y = hslider("y[midi:ctrl 1]",1,0,1,0.001) : si.smoo; +keyboard = hslider("keyboard",0,0,3,1) : int; + +// fomating parameters +gate = t+s : min(1); +freq = f*bend; +cutoff = y*4000+50; + +// oscillators +oscilators(0) = os.sawtooth(freq); +oscilators(1) = os.triangle(freq); +oscilators(2) = os.square(freq); +oscilators(3) = os.osc(freq); + +// oscs are selected in function of the current keyboard +synths = par(i,4,select2(keyboard == i,0,oscilators(i))) :> fi.lowpass(3,cutoff) : *(envelope) +with{ + envelope = gate*gain : si.smoo; +}; + +process = synths <: _,_; diff --git a/dist/examples/smartKeyboard/toy.dsp b/dist/examples/smartKeyboard/toy.dsp new file mode 100644 index 00000000..16838ba3 --- /dev/null +++ b/dist/examples/smartKeyboard/toy.dsp @@ -0,0 +1,71 @@ +//##################################### toy.dsp ####################################### +// Faust sound toy specifically designed for `faust2smartkeyb` where a funny +// synth can be controlled using several fingers on the screen and the built-in +// accelerometer. +// +// ## `SmartKeyboard` Use Strategy +// +// We just want a blank screen where the position of the different fingers on +// the screen can be tracked and retrieved in the Faust object. For that, we +// create one keyboard with one key, that should fill the screen. We ask the +// interface to not compute the `freq` and `bend` parameters to save +// computation by setting `'Keyboard 0 - Send Freq':'0'`. We don't want the +// color of the key to change when it is touched so we deactivate the +// `Piano Keyboard` mode. Fingers should be numbered to be able to use the +// numbered `x` and `y` parameters (`x0`, `y0`, `x1`, etc.), so `Count Fingers` +// is enabled. Finally, by setting `Max Keyboard Polyphony` to 0, we deactivate +// the voice allocation system and we automatically start a voice when the app +// is launched. This means that fingers are no longer associated to specific voices. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] toy.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017: +// https://ccrma.stanford.edu/~rmichon +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +// X/Y interface: one keyboard with one key +// freq and bend are not computed +// fingers are counted +// voice is launched on startup +declare interface "SmartKeyboard{ + 'Number of Keyboards':'1', + 'Max Keyboard Polyphony':'0', + 'Keyboard 0 - Number of Keys':'1', + 'Keyboard 0 - Send Freq':'0', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 0 - Send Numbered X':'1', + 'Keyboard 0 - Send Numbered Y':'1' +}"; + +import("stdfaust.lib"); + +// parameters +x0 = hslider("x0",0.5,0,1,0.01) : si.smoo; +y0 = hslider("y0",0.5,0,1,0.01) : si.smoo; +y1 = hslider("y1",0,0,1,0.01) : si.smoo; +q = hslider("q[acc: 0 0 -10 0 10]",30,10,50,0.01) : si.smoo; +del = hslider("del[acc: 0 0 -10 0 10]",0.5,0.01,1,0.01) : si.smoo; +fb = hslider("fb[acc: 1 0 -10 0 10]",0.5,0,1,0.01) : si.smoo; + +// mapping +impFreq = 2 + x0*20; +resFreq = y0*3000+300; + +// simple echo effect +echo = +~(de.delay(65536,del*ma.SR)*fb); + +// putting it together +process = os.lf_imptrain(impFreq) : fi.resonlp(resFreq,q,1) : echo : ef.cubicnl(y1,0)*0.95 <: _,_; diff --git a/dist/examples/smartKeyboard/trumpet.dsp b/dist/examples/smartKeyboard/trumpet.dsp new file mode 100644 index 00000000..2662d0ad --- /dev/null +++ b/dist/examples/smartKeyboard/trumpet.dsp @@ -0,0 +1,59 @@ +//################################### trumpet.dsp ##################################### +// A simple trumpet app... (for large screens). +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp trumpet.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +import("stdfaust.lib"); + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'5', + 'Max Keyboard Polyphony':'1', + 'Mono Mode':'1', + 'Keyboard 0 - Number of Keys':'13', + 'Keyboard 1 - Number of Keys':'13', + 'Keyboard 2 - Number of Keys':'13', + 'Keyboard 3 - Number of Keys':'13', + 'Keyboard 4 - Number of Keys':'13', + 'Keyboard 0 - Lowest Key':'77', + 'Keyboard 1 - Lowest Key':'72', + 'Keyboard 2 - Lowest Key':'67', + 'Keyboard 3 - Lowest Key':'62', + 'Keyboard 4 - Lowest Key':'57', + 'Rounding Mode':'2', + 'Keyboard 0 - Send Y':'1', + 'Keyboard 1 - Send Y':'1', + 'Keyboard 2 - Send Y':'1', + 'Keyboard 3 - Send Y':'1', + 'Keyboard 4 - Send Y':'1', +}"; + +// standard parameters +f = hslider("freq",300,50,2000,0.01); +bend = ba.semi2ratio(hslider("bend[midi:pitchwheel]",0,-2,2,0.001)) : si.polySmooth(gate,0.999,1); +gain = hslider("gain",1,0,1,0.01); +s = hslider("sustain[midi:ctrl 64]",0,0,1,1); // for sustain pedal +t = button("gate"); +y = hslider("y[midi:ctrl 1]",1,0,1,0.001) : si.smoo; + +// fomating parameters +gate = t+s : min(1); +freq = f*bend; +cutoff = y*4000+50; +envelope = gate*gain : si.smoo; + +process = os.sawtooth(freq)*envelope : fi.lowpass(3,cutoff) <: _,_; diff --git a/dist/examples/smartKeyboard/turenas.dsp b/dist/examples/smartKeyboard/turenas.dsp new file mode 100644 index 00000000..864795ee --- /dev/null +++ b/dist/examples/smartKeyboard/turenas.dsp @@ -0,0 +1,114 @@ +//################################### turenas.dsp ######################################## +// A simple smart phone percussion based on an additive synthesizer. +// +// ## `SmartKeyboard` Use Strategy +// +// Since the sounds generated by this synth are very short, the strategy here is to take +// advantage of the polyphony capabilities of the iOSKeyboard architecture by creating +// a new voice every time a new key is pressed. Since the `SmartKeyboard` interface has a +// large number of keys here (180), lots of sounds are generated when sliding a +// finger across the keyboard. +// +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] turenas.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +declare name "turenas"; + +import("stdfaust.lib"); + +//========================= Smart Keyboard Configuration ================================= +// (10 keyboards with 18 keys each configured as a pitch matrix. +//======================================================================================== + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'10', + 'Keyboard 0 - Number of Keys':'18', + 'Keyboard 1 - Number of Keys':'18', + 'Keyboard 2 - Number of Keys':'18', + 'Keyboard 3 - Number of Keys':'18', + 'Keyboard 4 - Number of Keys':'18', + 'Keyboard 5 - Number of Keys':'18', + 'Keyboard 6 - Number of Keys':'18', + 'Keyboard 7 - Number of Keys':'18', + 'Keyboard 8 - Number of Keys':'18', + 'Keyboard 9 - Number of Keys':'18', + 'Keyboard 0 - Lowest Key':'50', + 'Keyboard 1 - Lowest Key':'55', + 'Keyboard 2 - Lowest Key':'60', + 'Keyboard 3 - Lowest Key':'65', + 'Keyboard 4 - Lowest Key':'70', + 'Keyboard 5 - Lowest Key':'75', + 'Keyboard 6 - Lowest Key':'80', + 'Keyboard 7 - Lowest Key':'85', + 'Keyboard 8 - Lowest Key':'90', + 'Keyboard 9 - Lowest Key':'95', + 'Keyboard 0 - Piano Keyboard':'0', + 'Keyboard 1 - Piano Keyboard':'0', + 'Keyboard 2 - Piano Keyboard':'0', + 'Keyboard 3 - Piano Keyboard':'0', + 'Keyboard 4 - Piano Keyboard':'0', + 'Keyboard 5 - Piano Keyboard':'0', + 'Keyboard 6 - Piano Keyboard':'0', + 'Keyboard 7 - Piano Keyboard':'0', + 'Keyboard 8 - Piano Keyboard':'0', + 'Keyboard 9 - Piano Keyboard':'0', + 'Keyboard 0 - Send X':'0', + 'Keyboard 1 - Send X':'0', + 'Keyboard 2 - Send X':'0', + 'Keyboard 3 - Send X':'0', + 'Keyboard 4 - Send X':'0', + 'Keyboard 5 - Send X':'0', + 'Keyboard 6 - Send X':'0', + 'Keyboard 7 - Send X':'0', + 'Keyboard 8 - Send X':'0', + 'Keyboard 9 - Send X':'0' +}"; + +//================================ Instrument Parameters ================================= +// Creates the connection between the synth and the mobile device +//======================================================================================== + +// SmartKeyboard Y parameter +y = hslider("y",0,0,1,0.01); +// Smart Keyboard frequency parameter +freq = hslider("freq",400,50,2000,0.01); +// SmartKeyboard gate parameter +gate = button("gate"); +// mode resonance duration is controlled with the x axis of the accelerometer +res = hslider("res[acc: 0 0 -10 0 10]",2.5,0.01,5,0.01); + +//=================================== Parameters Mapping ================================= +//======================================================================================== + +// number of modes +nModes = 6; +// distance between each mode +maxModeSpread = 5; +modeSpread = y*maxModeSpread; +// computing modes frequency ratio +modeFreqRatios = par(i,nModes,1+(i+1)/nModes*modeSpread); +// computing modes gain +minModeGain = 0.3; +modeGains = par(i,nModes,1-(i+1)/(nModes*minModeGain)); +// smoothed mode resonance +modeRes = res : si.smoo; + +//============================================ DSP ======================================= +//======================================================================================== + +process = sy.additiveDrum(freq,modeFreqRatios,modeGains,0.8,0.001,modeRes,gate)*0.05; diff --git a/dist/examples/smartKeyboard/violin.dsp b/dist/examples/smartKeyboard/violin.dsp new file mode 100644 index 00000000..16ba739e --- /dev/null +++ b/dist/examples/smartKeyboard/violin.dsp @@ -0,0 +1,91 @@ +//############################### violin.dsp ################################### +// Faust instrument specifically designed for `faust2smartkeyb` where a +// complete violin physical model can be played using the touch sceen +// interface. While the 4 virtual strings can be bowed using a control +// surface on the screen, it could be easily substituted with an external +// interface. +// +// ## `SmartKeyboard` Use Strategy +// +// 4 keyboards are used to control the pitch of the 4 bowed strings. Strings +// are connected to the virtual bow when they are touched. A pad created from +// a keybaord with a single key can be used to control the bow velocity and +// pressure on the selected strings. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. +// However it was specifically designed to be used with `faust2smartkeyb`. For +// best results, we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp violin.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Aug. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//############################################################################## + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'5', + 'Max Keyboard Polyphony':'0', + 'Rounding Mode':'2', + 'Send Fingers Count':'1', + 'Keyboard 0 - Number of Keys':'19', + 'Keyboard 1 - Number of Keys':'19', + 'Keyboard 2 - Number of Keys':'19', + 'Keyboard 3 - Number of Keys':'19', + 'Keyboard 4 - Number of Keys':'1', + 'Keyboard 0 - Lowest Key':'55', + 'Keyboard 1 - Lowest Key':'62', + 'Keyboard 2 - Lowest Key':'69', + 'Keyboard 3 - Lowest Key':'76', + 'Keyboard 0 - Send Keyboard Freq':'1', + 'Keyboard 1 - Send Keyboard Freq':'1', + 'Keyboard 2 - Send Keyboard Freq':'1', + 'Keyboard 3 - Send Keyboard Freq':'1', + 'Keyboard 4 - Send Freq':'0', + 'Keyboard 4 - Send Key X':'1', + 'Keyboard 4 - Send Key Y':'1', + 'Keyboard 4 - Key 0 - Label':'Bow', + 'Keyboard 4 - Static Mode':'1' +}"; + +import("stdfaust.lib"); + +// SMARTKEYBOARD PARAMS +kbfreq(0) = hslider("kb0freq",220,20,10000,0.01); +kbbend(0) = hslider("kb0bend",1,0,10,0.01); +kbfreq(1) = hslider("kb1freq",330,20,10000,0.01); +kbbend(1) = hslider("kb1bend",1,0,10,0.01); +kbfreq(2) = hslider("kb2freq",440,20,10000,0.01); +kbbend(2) = hslider("kb2bend",1,0,10,0.01); +kbfreq(3) = hslider("kb3freq",550,20,10000,0.01); +kbbend(3) = hslider("kb3bend",1,0,10,0.01); +kb4k0x = hslider("kb4k0x",0,0,1,1) : si.smoo; +kb4k0y = hslider("kb4k0y",0,0,1,1) : si.smoo; +kbfingers(0) = hslider("kb0fingers",0,0,10,1) : int; +kbfingers(1) = hslider("kb1fingers",0,0,10,1) : int; +kbfingers(2) = hslider("kb2fingers",0,0,10,1) : int; +kbfingers(3) = hslider("kb3fingers",0,0,10,1) : int; + +// MODEL PARAMETERS +// strings lengths +sl(i) = kbfreq(i)*kbbend(i) : pm.f2l : si.smoo; +// string active only if fingers are touching the keyboard +as(i) = kbfingers(i)>0; +// bow pressure could also be controlled by an external parameter +bowPress = kb4k0y; +// retrieving finger displacement on screen (dirt simple) +bowVel = kb4k0x-kb4k0x' : abs : *(8000) : min(1) : si.smoo; +// bow position is constant but could be ontrolled by an external interface +bowPos = 0.7; + +// ASSEMBLING MODELS +// essentially 4 parallel violin strings +model = par(i,4,pm.violinModel(sl(i),bowPress,bowVel*as(i),bowPos)) :> _; + +process = model <: _,_; diff --git a/dist/examples/smartKeyboard/violin2.dsp b/dist/examples/smartKeyboard/violin2.dsp new file mode 100644 index 00000000..e8f80c1a --- /dev/null +++ b/dist/examples/smartKeyboard/violin2.dsp @@ -0,0 +1,84 @@ +//############################### violin2.dsp ################################## +// Faust instrument specifically designed for `faust2smartkeyb` where a +// complete violin physical model can be played using the touch sceen +// interface. Bowing is carried out by constantly moving a finger on the +// y axis of a key. +// +// ## `SmartKeyboard` Use Strategy +// +// 4 keyboards are used to control the pitch of the 4 bowed strings. Strings +// are connected to the virtual bow when they are touched. +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. +// However it was specifically designed to be used with `faust2smartkeyb`. For +// best results, we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] -effect reverb.dsp violin.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Aug. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//############################################################################## + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'4', + 'Max Keyboard Polyphony':'0', + 'Rounding Mode':'2', + 'Send Fingers Count':'1', + 'Keyboard 0 - Number of Keys':'12', + 'Keyboard 1 - Number of Keys':'12', + 'Keyboard 2 - Number of Keys':'12', + 'Keyboard 3 - Number of Keys':'12', + 'Keyboard 0 - Lowest Key':'55', + 'Keyboard 1 - Lowest Key':'62', + 'Keyboard 2 - Lowest Key':'69', + 'Keyboard 3 - Lowest Key':'76', + 'Keyboard 0 - Send Keyboard Freq':'1', + 'Keyboard 1 - Send Keyboard Freq':'1', + 'Keyboard 2 - Send Keyboard Freq':'1', + 'Keyboard 3 - Send Keyboard Freq':'1', + 'Keyboard 0 - Send Y':'1', + 'Keyboard 1 - Send Y':'1', + 'Keyboard 2 - Send Y':'1', + 'Keyboard 3 - Send Y':'1' +}"; + +import("stdfaust.lib"); + +// SMARTKEYBOARD PARAMS +kbfreq(0) = hslider("kb0freq",220,20,10000,0.01); +kbbend(0) = hslider("kb0bend",1,0,10,0.01); +kbfreq(1) = hslider("kb1freq",330,20,10000,0.01); +kbbend(1) = hslider("kb1bend",1,0,10,0.01); +kbfreq(2) = hslider("kb2freq",440,20,10000,0.01); +kbbend(2) = hslider("kb2bend",1,0,10,0.01); +kbfreq(3) = hslider("kb3freq",550,20,10000,0.01); +kbbend(3) = hslider("kb3bend",1,0,10,0.01); +kbfingers(0) = hslider("kb0fingers",0,0,10,1) : int; +kbfingers(1) = hslider("kb1fingers",0,0,10,1) : int; +kbfingers(2) = hslider("kb2fingers",0,0,10,1) : int; +kbfingers(3) = hslider("kb3fingers",0,0,10,1) : int; +y = hslider("y",0,0,1,1) : si.smoo; + +// MODEL PARAMETERS +// strings lengths +sl(i) = kbfreq(i)*kbbend(i) : pm.f2l : si.smoo; +// string active only if fingers are touching the keyboard +as(i) = kbfingers(i)>0; +// retrieving finger displacement on screen (dirt simple) +bowVel = y-y' : abs : *(3000) : min(1) : si.smoo; +// bow position is constant but could be ontrolled by an external interface +bowPos = 0.7; +bowPress = 0.5; + +// ASSEMBLING MODELS +// essentially 4 parallel violin strings +model = par(i,4,pm.violinModel(sl(i),bowPress,bowVel*as(i),bowPos)) :> _; + +process = model <: _,_; diff --git a/dist/examples/smartKeyboard/vocal.dsp b/dist/examples/smartKeyboard/vocal.dsp new file mode 100644 index 00000000..fc350164 --- /dev/null +++ b/dist/examples/smartKeyboard/vocal.dsp @@ -0,0 +1,43 @@ +//######################################## vocal.dsp ##################################### +// A funny vocal synth app... +// +// ## Compilation Instructions +// +// This Faust code will compile fine with any of the standard Faust targets. However +// it was specifically designed to be used with `faust2smartkeyb`. For best results, +// we recommend to use the following parameters to compile it: +// +// ``` +// faust2smartkeyb [-ios/-android] vocal.dsp +// ``` +// +// ## Version/Licence +// +// Version 0.0, Feb. 2017 +// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017 +// MIT Licence: https://opensource.org/licenses/MIT +//######################################################################################## + +import("stdfaust.lib"); + +declare interface "SmartKeyboard{ + 'Number of Keyboards':'1', + 'Max Keyboard Polyphony':'0', + 'Keyboard 0 - Number of Keys':'1', + 'Keyboard 0 - Send Freq':'0', + 'Keyboard 0 - Static Mode':'1', + 'Keyboard 0 - Send X':'1', + 'Keyboard 0 - Piano Keyboard':'0' +}"; + +// standard parameters +vowel = hslider("vowel[acc: 0 0 -10 0 10]",2,0,4,0.01) : si.smoo; +x = hslider("x",0.5,0,1,0.01) : si.smoo; +vibrato = hslider("vibrato[acc: 1 0 -10 0 10]",0.05,0,0.1,0.01); +gain = hslider("gain",0.25,0,1,0.01); + +// fomating parameters +freq = x*200 + 50; +voiceFreq = freq*(os.osc(6)*vibrato+1); + +process = pm.SFFormantModelBP(1,vowel,0,voiceFreq,gain) <: _,_; diff --git a/dist/examples/spat/panpot.dsp b/dist/examples/spat/panpot.dsp new file mode 100644 index 00000000..56fcce6c --- /dev/null +++ b/dist/examples/spat/panpot.dsp @@ -0,0 +1,17 @@ +declare name "panpot"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//------------------------------------------------- +// Stereo panpot +//------------------------------------------------- + +panpot(x) = sqrt(c)*x, sqrt(1-c)*x + with { + c=(nentry("[1]pan[style:knob]",0,-90,90,1)-90.0)/-180.0; + }; + +process = panpot; + diff --git a/dist/examples/spat/spat.dsp b/dist/examples/spat/spat.dsp new file mode 100644 index 00000000..012085ec --- /dev/null +++ b/dist/examples/spat/spat.dsp @@ -0,0 +1,25 @@ +declare name "spat"; +declare version "1.0"; +declare author "Grame"; +declare license "BSD"; +declare copyright "(c)GRAME 2006"; + +//========================================================== +// +// GMEM SPAT +// implementation of L. Pottier Spatializer +// +//========================================================== + +import("stdfaust.lib"); + +//------------------------------------------------------ +// EXEMPLE : une entree mono spatialisee sur 8 sorties +//------------------------------------------------------ + +angle = hslider("angle", 0.0, 0, 1, 0.01); +distance = hslider("distance", 0.5, 0, 1, 0.01); + +process = vgroup("Spatializer 1x8", sp.spat(8, angle, distance)); + + diff --git a/dist/faust-ui/index.d.ts b/dist/faust-ui/index.d.ts new file mode 100644 index 00000000..dfa85b01 --- /dev/null +++ b/dist/faust-ui/index.d.ts @@ -0,0 +1,631 @@ +// Generated by dts-bundle-generator v9.3.1 + +import { FaustUIDescriptor, FaustUIGroupType, FaustUIInputItem, FaustUIInputType, FaustUIItem, FaustUIMeta, FaustUIOutputType, FaustUIType } from '@grame/faustwasm'; + +declare const $AnyEventType: unique symbol; +export interface IEmitOptions { + excludeAny?: boolean; + exclude?: ((...args: any[]) => any)[]; +} +declare class TypedEventEmitter { + private _listeners; + get listeners(): { + [eventName: string]: ((e?: any, emitter?: any) => any)[]; + [$AnyEventType]: ((eventName: string, eventData?: any, emitter?: any) => any)[]; + }; + private getListeners; + on(eventName: K, listener: (e: M[K], emitter?: this) => any): void; + once(eventName: K, listener: (e: M[K], emitter?: this) => any): void; + onAny(listener: (eventName: KK, eventData?: M[KK], emitter?: this) => any): void; + off(eventName: K, listener: (e: M[K], emitter?: this) => any): void; + offAny(listener: (eventName: KK, eventData?: M[KK], emitter?: this) => any): void; + emit(eventName: K, eventData?: M[K], options?: IEmitOptions): Promise; + emitSerial(eventName: K, eventData?: M[K], options?: IEmitOptions): Promise; + emitSync(eventName: K, eventData?: M[K], options?: IEmitOptions): any[]; + offAll(eventName?: keyof M & string): void; + listenerCount(eventName: keyof M & string): number; +} +declare abstract class AbstractComponent extends TypedEventEmitter { + /** + * The default state of the component. + */ + static defaultProps: Record; + get defaultProps(): T; + /** + * Here stores corrent state of component + * change the state with `setState` method to fire state events + * then UI parts will get notified and rerender + */ + state: T; + /** + * Frame count in order to reduce frame rate + */ + private $frame; + /** + * Frame reducing factor, 1 = render at every browser rendering tick, 2 will skip one every two ticks. + */ + frameReduce: number; + /** + * Here stores current `requestAnimationFrame` reference + * if we have a new state to render, we cancel the old one + */ + private $raf; + /** + * `requestAnimationFrame` callback + */ + private raf; + /** + * tasks to execute in next redering tick + */ + private tasks; + /** + * Initiate default state with incoming state. + */ + constructor(props?: T); + /** + * set internal state and fire events for UI parts subscribed + */ + setState(newState: Partial): void; + /** + * Use this method to request a new rendering + * schedule what you need to do in next render tick in `raf` callback + */ + schedule(func: () => any): void; +} +export interface FaustUIItemProps { + value?: number; + active?: boolean; + focus?: boolean; + label?: string; + address: string; + min?: number; + max?: number; + step?: number; + tooltip?: string; + enums?: { + [key: string]: number; + }; + type?: "enum" | "int" | "float"; + unit?: string; + scale?: "linear" | "exp" | "log"; + style?: T; + emitter?: FaustUI; +} +export interface FaustUIGroupProps { + label?: string; + type?: "tgroup" | "vgroup" | "hgroup"; + style?: FaustUIItemStyle; + items?: FaustUIItem[]; + isRoot?: boolean; + emitter?: FaustUI; +} +export interface FaustUIItemStyle { + width?: number; + height?: number; + left?: number; + top?: number; + grid?: number; + labelcolor?: string; +} +export interface PointerDownEvent { + x: number; + y: number; + originalEvent: MouseEvent | TouchEvent; +} +export interface PointerDragEvent { + prevValue: number; + x: number; + y: number; + fromX: number; + fromY: number; + movementX: number; + movementY: number; + originalEvent: MouseEvent | TouchEvent; +} +export interface PointerUpEvent { + x: number; + y: number; + originalEvent: MouseEvent | TouchEvent; +} +declare abstract class AbstractItem extends AbstractComponent> { + /** + * The default state of the component. + */ + static defaultProps: FaustUIItemProps; + /** + * DOM Div container of the component + */ + container: HTMLDivElement; + /** + * DOM Div container of label canvas + */ + label: HTMLDivElement; + /** + * Use canvas as label to fit full text in. + */ + labelCanvas: HTMLCanvasElement; + labelCtx: CanvasRenderingContext2D; + /** + * Override this to get css work + */ + className: string; + frameReduce: number; + /** + * Default DOM event listeners, unify mousedown and touchstart events + * For mouse or touch events, please use `handlePointerDown` `handlePointerUp` `handlePointerDrag` callbacks + */ + handleKeyDown: (e: KeyboardEvent) => void; + handleKeyUp: (e: KeyboardEvent) => void; + handleTouchStart: (e: TouchEvent) => void; + handleWheel: (e: WheelEvent) => void; + handleClick: (e: MouseEvent) => void; + handleMouseDown: (e: MouseEvent) => void; + handleMouseOver: (e: MouseEvent) => void; + handleMouseOut: (e: MouseEvent) => void; + handleContextMenu: (e: MouseEvent) => void; + handlePointerDown: (e: PointerDownEvent) => void; + handlePointerDrag: (e: PointerDragEvent) => void; + handlePointerUp: (e: PointerUpEvent) => void; + handleFocusIn: (e: FocusEvent) => boolean; + handleFocusOut: (e: FocusEvent) => boolean; + /** + * Initiate default state with incoming state. + */ + constructor(props?: FaustUIItemProps); + /** + * Get a nearest valid number + */ + toValidNumber(value: number): number; + /** + * Use this method if you want the emitter to send value to DSP + */ + setValue(valueIn: number): boolean; + /** + * Send value to DSP + */ + change(valueIn?: number): void; + /** + * set internal state and fire events for UI parts subscribed + * This will not send anything to DSP + * @returns is state updated + */ + setState(newState: { + [key in keyof FaustUIItemProps]?: FaustUIItemProps[key]; + }): boolean; + /** + * Create container with class name + * override it with `super.componentWillMount();` + */ + componentWillMount(): this; + /** + * Here append all child DOM to container + */ + mount(): this; + paintLabel(align?: CanvasTextAlign): this; + /** + * will call this method when mounted + */ + componentDidMount(): this; + /** + * Count steps in range min-max with step + */ + get stepsCount(): number; + /** + * Normalized value between 0 - 1. + */ + get distance(): number; + static getDistance(state: { + value: number; + min: number; + max: number; + enums?: { + [key: string]: number; + }; + type: "enum" | "int" | "float"; + scale: "linear" | "exp" | "log"; + }): number; + /** + * Mousemove pixels for each step + */ + get stepRange(): number; +} +export interface FaustUINentryStyle extends FaustUIItemStyle { + fontname?: string; + fontsize?: number; + fontface?: "regular" | "bold" | "italic" | "bold italic"; + bgcolor?: string; + bordercolor?: string; + labelcolor?: string; + textcolor?: string; +} +declare class Nentry extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + input: HTMLInputElement; + componentWillMount(): this; + handleChange: (e: Event) => void; + setStyle: () => void; + componentDidMount(): this; + mount(): this; +} +export interface FaustUISliderStyle extends FaustUINentryStyle { + sliderwidth?: number; + sliderbgcolor?: string; + sliderbgoncolor?: string; + slidercolor?: string; +} +declare class VSlider extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + canvas: HTMLCanvasElement; + inputNumber: HTMLInputElement; + input: HTMLInputElement; + flexDiv: HTMLDivElement; + canvasDiv: HTMLDivElement; + ctx: CanvasRenderingContext2D; + interactionRect: number[]; + componentWillMount(): this; + handleChange: (e: Event) => void; + setStyle: () => void; + componentDidMount(): this; + mount(): this; + paint: () => void; + get stepsCount(): number; + get stepRange(): number; + getValueFromPos(e: { + x: number; + y: number; + }): number; + handlePointerDown: (e: PointerDownEvent) => void; + handlePointerDrag: (e: PointerDragEvent) => void; +} +export interface FaustUISoundfileStyle extends FaustUIItemStyle { + fontname?: string; + fontsize?: number; + fontface?: "normal" | "bold" | "italic" | "bold italic"; + bgcolor?: string; + bgoncolor?: string; + bordercolor?: string; + borderoncolor?: string; + textcolor?: string; + textoncolor?: string; +} +declare class Soundfile extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + btn: HTMLDivElement; + span: HTMLSpanElement; + componentWillMount(): this; + setStyle: () => void; + mount(): this; + componentDidMount(): this; + handlePointerDown: () => void; + handlePointerUp: () => void; +} +export interface FaustUIButtonStyle extends FaustUIItemStyle { + fontname?: string; + fontsize?: number; + fontface?: "normal" | "bold" | "italic" | "bold italic"; + bgcolor?: string; + bgoncolor?: string; + bordercolor?: string; + borderoncolor?: string; + textcolor?: string; + textoncolor?: string; +} +declare class Button extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + btn: HTMLDivElement; + span: HTMLSpanElement; + componentWillMount(): this; + setStyle: () => void; + mount(): this; + componentDidMount(): this; + handlePointerDown: () => void; + handlePointerUp: () => void; +} +export interface FaustUIKnobStyle extends FaustUINentryStyle { + knobwidth?: number; + knobcolor?: string; + knoboncolor?: string; + needlecolor?: string; +} +declare class Knob extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + canvas: HTMLCanvasElement; + inputNumber: HTMLInputElement; + input: HTMLInputElement; + ctx: CanvasRenderingContext2D; + componentWillMount(): this; + handleChange: (e: Event) => void; + setStyle: () => void; + componentDidMount(): this; + mount(): this; + paint: () => void; + getValueFromDelta(e: PointerDragEvent): number; + handlePointerDrag: (e: PointerDragEvent) => void; +} +export interface FaustUIMenuStyle extends FaustUIItemStyle { + fontname?: string; + fontsize?: number; + fontface?: "regular" | "bold" | "italic" | "bold italic"; + bgcolor?: string; + bordercolor?: string; + labelcolor?: string; + textcolor?: string; +} +declare class Menu extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + select: HTMLSelectElement; + componentWillMount(): this; + getOptions(): void; + handleChange: (e: Event) => void; + setStyle: () => void; + componentDidMount(): this; + mount(): this; +} +export interface FaustUIRadioStyle extends FaustUIItemStyle { + fontname?: string; + fontsize?: number; + fontface?: "regular" | "bold" | "italic" | "bold italic"; + bgcolor?: string; + bordercolor?: string; + labelcolor?: string; + textcolor?: string; +} +declare class Radio extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + group: HTMLDivElement; + componentWillMount(): this; + getOptions: () => void; + setStyle: () => void; + componentDidMount(): this; + mount(): this; +} +export interface FaustUILedStyle extends FaustUINentryStyle { + shape?: "circle" | "square"; + ledbgcolor?: string; + coldcolor?: string; + warmcolor?: string; + hotcolor?: string; + overloadcolor?: string; +} +declare class Led extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + canvasDiv: HTMLDivElement; + canvas: HTMLCanvasElement; + tempCanvas: HTMLCanvasElement; + ctx: CanvasRenderingContext2D; + tempCtx: CanvasRenderingContext2D; + componentWillMount(): this; + setStyle: () => void; + componentDidMount(): this; + mount(): this; + paint: () => void; +} +declare class Numerical extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + input: HTMLInputElement; + componentWillMount(): this; + setStyle: () => void; + componentDidMount(): this; + mount(): this; +} +export interface FaustUIBargraphStyle extends FaustUINentryStyle { + barwidth?: number; + barbgcolor?: string; + coldcolor?: string; + warmcolor?: string; + hotcolor?: string; + overloadcolor?: string; +} +declare class VBargraph extends AbstractItem { + static get defaultProps(): FaustUIItemProps; + className: string; + canvas: HTMLCanvasElement; + input: HTMLInputElement; + flexDiv: HTMLDivElement; + canvasDiv: HTMLDivElement; + ctx: CanvasRenderingContext2D; + componentWillMount(): this; + setStyle: () => void; + componentDidMount(): this; + mount(): this; + paintValue: number; + maxValue: number; + maxTimer: number; + paint: () => void; +} +export interface LayoutProps { + type: TLayoutType; + left?: number; + top?: number; + offsetLeft?: number; // relative to parent group + offsetTop?: number; + width: number; + height: number; + sizing: "horizontal" | "vertical" | "both" | "none"; +} +export type TLayoutType = "vgroup" | "hgroup" | "tgroup" | "hbargraph" | "vbargraph" | "vslider" | "hslider" | "button" | "checkbox" | "nentry" | "soundfile" | "knob" | "menu" | "radio" | "led" | "numerical"; +export interface IItem { + /** + * Initial type of item given by Faust compiler + */ + type: FaustUIType; + /** + * Initial item label given by Faust compiler + */ + label: string; + /** + * Calculated layout + */ + layout: LayoutProps; + /** + * Adjust group width and height by its items' dimensions + */ + adjust(): this; + /** + * Expand flexible items within a group + * + * @param dX - Extra horizontal spaces that this group could take + * @param dY - Extra vertical spaces that this group could take + */ + expand(dX: number, dY: number): this; + /** + * calculate all the items' absolute coordination (in grids) + */ + offset(): this; +} +declare abstract class AbstractItem$1 implements IItem { + type: FaustUIInputType | FaustUIOutputType; + label: string; + address: string; + url: string; + index: number; + init: number; + min: number; + max: number; + meta?: FaustUIMeta[]; + layout: LayoutProps; + constructor(item: FaustUIItem); + adjust(): this; + expand(dX: number, dY: number): this; + offset(): this; +} +declare abstract class AbstractGroup implements IItem { + static padding: number; + static labelHeight: number; + static spaceBetween: number; + isRoot: boolean; + type: FaustUIGroupType; + label: string; + items: (AbstractGroup | AbstractItem$1)[]; + layout: LayoutProps; + constructor(group: { + type: FaustUIGroupType; + label: string; + items: (AbstractGroup | AbstractItem$1)[]; + }, isRoot?: boolean); + /** + * find recursively if the group has horizontal-sizable item + */ + get hasHSizingDesc(): boolean; + /** + * find recursively if the group has vertical-sizable item + */ + get hasVSizingDesc(): boolean; + adjust(): this; + expand(dX: number, dY: number): this; + offset(): this; +} +declare abstract class AbstractInputItem extends AbstractItem$1 { + init: number; + step: number; + constructor(item: FaustUIInputItem); +} +declare abstract class AbstractOutputItem extends AbstractItem$1 { +} +declare class Group extends AbstractComponent { + static parseMeta(metaIn: FaustUIMeta[]): { + metaObject: FaustUIMeta; + enums?: { + [key: string]: number; + }; + }; + static getComponent(item: AbstractGroup | AbstractInputItem | AbstractOutputItem, emitter: FaustUI, grid: number): Nentry | VSlider | Soundfile | Button | Knob | Menu | Radio | Led | Numerical | VBargraph | Group; + /** + * DOM Div container of the group + */ + container: HTMLDivElement; + /** + * DOM Div container of label canvas + */ + label: HTMLDivElement; + /** + * Use canvas as label to fit full text in. + */ + labelCanvas: HTMLCanvasElement; + labelCtx: CanvasRenderingContext2D; + tabs: HTMLDivElement; + children: (AbstractItem | Group)[]; + layout: LayoutProps; + setState(newState: { + [key in keyof FaustUIGroupProps]?: FaustUIGroupProps[key]; + }): void; + componentWillMount(): this; + paintLabel(): this; + updateUI: () => void; + mount(): this; + componentDidMount(): this; +} +export interface IOptions { + root: HTMLDivElement; + ui?: FaustUIDescriptor; + listenWindowResize?: boolean; + listenWindowMessage?: boolean; +} +/** + * The main class of UI constructor, + * listening to `resize` window event to resize component, + * listening to `message` window event to change UI or param value. + * See readme. + */ +export declare class FaustUI { + componentMap: { + [path: string]: AbstractItem[]; + }; + DOMroot: HTMLDivElement; + faustUIRoot: Group; + hostWindow: Window; + grid: number; + private _ui; + private _layout; + /** + * Calculate incoming UI's layout, bind window events + */ + constructor(options: IOptions); + /** + * Render the UI to DOM root + */ + mount(): void; + /** + * This method should be called by components to register itself to map. + */ + register(path: string, item: AbstractItem): void; + /** + * Notify the component to change its value. + */ + paramChangeByDSP(path: string, value: number): void; + /** + * Can be overriden, called by components when its value is changed by user. + */ + paramChangeByUI: (path: string, value: number) => void; + /** + * Calculate UI layout in grid then calculate grid size. + */ + calc(): void; + /** + * Calculate grid size by DOM root size and layout size in grids. + */ + calcGrid(): number; + /** + * Force recalculate grid size and resize UI + */ + resize(): void; + get ui(): FaustUIItem[]; + set ui(uiIn: FaustUIItem[]); + get layout(): LayoutProps; + get minWidth(): number; + get minHeight(): number; +} +export declare const instantiate: () => void; + +export {}; diff --git a/dist/faust-ui/index.html b/dist/faust-ui/index.html new file mode 100644 index 00000000..fc56dbf8 --- /dev/null +++ b/dist/faust-ui/index.html @@ -0,0 +1,17 @@ + + + + + + + + FaustUI + + + +
+ + + + + \ No newline at end of file diff --git a/dist/faust-ui/index.js b/dist/faust-ui/index.js new file mode 100644 index 00000000..52bb12b1 --- /dev/null +++ b/dist/faust-ui/index.js @@ -0,0 +1,5635 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define([], factory); + else if(typeof exports === 'object') + exports["FaustUI"] = factory(); + else + root["FaustUI"] = factory(); +})(self, () => { +return /******/ (() => { // webpackBootstrap +/******/ "use strict"; +/******/ var __webpack_modules__ = ({ + +/***/ "./node_modules/@shren/typed-event-emitter/dist/index.js": +/*!***************************************************************!*\ + !*** ./node_modules/@shren/typed-event-emitter/dist/index.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.TypedEventEmitter = exports.$AnyEventType = void 0; +exports.$AnyEventType = Symbol("__TypedEventListener_AnyEventType"); +class TypedEventEmitter { + constructor() { + this._listeners = { [exports.$AnyEventType]: [] }; + } + get listeners() { + return this._listeners; + } + getListeners(eventName) { + if (!(eventName in this._listeners)) + this._listeners[eventName] = []; + return this._listeners[eventName]; + } + on(eventName, listener) { + if (this.getListeners(eventName).indexOf(listener) === -1) + this.getListeners(eventName).push(listener); + } + once(eventName, listener) { + const listenerWithOff = (arg, emitter) => { + const returnValue = listener(arg, emitter); + this.off(eventName, listenerWithOff); + return returnValue; + }; + this.on(eventName, listenerWithOff); + } + onAny(listener) { + this._listeners[exports.$AnyEventType].push(listener); + } + off(eventName, listener) { + const i = this.getListeners(eventName).indexOf(listener); + if (i !== -1) + this.getListeners(eventName).splice(i, 1); + } + offAny(listener) { + const i = this._listeners[exports.$AnyEventType].indexOf(listener); + if (i !== -1) + this._listeners[exports.$AnyEventType].splice(i, 1); + } + async emit(eventName, eventData, options) { + var _a; + let listeners = this.getListeners(eventName); + let anyListeners = (options === null || options === void 0 ? void 0 : options.excludeAny) ? [] : this._listeners[exports.$AnyEventType]; + if (!listeners.length && !anyListeners.length) + return []; + if ((_a = options === null || options === void 0 ? void 0 : options.exclude) === null || _a === void 0 ? void 0 : _a.length) { + const { exclude } = options; + listeners = listeners.filter(l => exclude.indexOf(l) === -1); + anyListeners = anyListeners.filter(l => exclude.indexOf(l) === -1); + } + return Promise.all([...listeners.map(f => f(eventData, this)), ...anyListeners.map(f => f(eventName, eventData, this))]); + } + async emitSerial(eventName, eventData, options) { + var _a; + let listeners = this.getListeners(eventName); + let anyListeners = (options === null || options === void 0 ? void 0 : options.excludeAny) ? [] : this._listeners[exports.$AnyEventType]; + if (!listeners.length && !anyListeners.length) + return []; + if ((_a = options === null || options === void 0 ? void 0 : options.exclude) === null || _a === void 0 ? void 0 : _a.length) { + const { exclude } = options; + listeners = listeners.filter(l => exclude.indexOf(l) === -1); + anyListeners = anyListeners.filter(l => exclude.indexOf(l) === -1); + } + const returnValues = []; + for (let i = 0; i < listeners.length; i++) { + const listener = listeners[i]; + returnValues[i] = await listener(eventData, this); + } + for (let i = 0; i < anyListeners.length; i++) { + const listener = anyListeners[i]; + returnValues[listeners.length + i] = await listener(eventName, eventData, this); + } + return returnValues; + } + emitSync(eventName, eventData, options) { + var _a; + let listeners = this.getListeners(eventName); + let anyListeners = (options === null || options === void 0 ? void 0 : options.excludeAny) ? [] : this._listeners[exports.$AnyEventType]; + if (!listeners.length && !anyListeners.length) + return []; + if ((_a = options === null || options === void 0 ? void 0 : options.exclude) === null || _a === void 0 ? void 0 : _a.length) { + const { exclude } = options; + listeners = listeners.filter(l => exclude.indexOf(l) === -1); + anyListeners = anyListeners.filter(l => exclude.indexOf(l) === -1); + } + return [...listeners.map(f => f(eventData, this)), ...anyListeners.map(f => f(eventName, eventData, this))]; + } + offAll(eventName) { + if (eventName) { + this._listeners[eventName] = []; + } + else { + this._listeners = { [exports.$AnyEventType]: [] }; + } + } + listenerCount(eventName) { + const anyListenerCount = this._listeners[exports.$AnyEventType].length; + if (!(eventName in this._listeners)) + return anyListenerCount; + return this._listeners[eventName].length + anyListenerCount; + } +} +exports.TypedEventEmitter = TypedEventEmitter; +exports["default"] = TypedEventEmitter; +//# sourceMappingURL=index.js.map + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Base.scss": +/*!***************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Base.scss ***! + \***************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component { + display: flex; + position: absolute; + flex-direction: column; + overflow: hidden; +} +.faust-ui-component:focus { + outline: none; +} +.faust-ui-component > .faust-ui-component-label { + position: relative; + margin-top: 4px; + width: 100%; + user-select: none; +} +.faust-ui-component > .faust-ui-component-label > canvas { + position: relative; + display: block; + max-width: 100%; + max-height: 100%; +} +.faust-ui-component input { + box-shadow: none; +}`, "",{"version":3,"sources":["webpack://./src/components/Base.scss"],"names":[],"mappings":"AAAA;EACI,aAAA;EACA,kBAAA;EACA,sBAAA;EACA,gBAAA;AACJ;AAAI;EACI,aAAA;AAER;AAAI;EACI,kBAAA;EACA,eAAA;EACA,WAAA;EACA,iBAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,eAAA;EACA,gBAAA;AAGZ;AAAI;EACI,gBAAA;AAER","sourcesContent":[".faust-ui-component {\n display: flex;\n position: absolute;\n flex-direction: column;\n overflow: hidden;\n &:focus {\n outline: none;\n }\n & > .faust-ui-component-label {\n position: relative;\n margin-top: 4px;\n width: 100%;\n user-select: none;\n & > canvas {\n position: relative;\n display: block;\n max-width: 100%;\n max-height: 100%;\n }\n }\n & input {\n box-shadow: none;\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Button.scss": +/*!*****************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Button.scss ***! + \*****************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-button > div { + display: flex; + position: relative; + cursor: pointer; + border-width: 1px; + text-align: center; + border-radius: 4px; + flex: 1 0 auto; + border-style: solid; +} +.faust-ui-component.faust-ui-component-button > div > span { + user-select: none; + margin: auto; +}`, "",{"version":3,"sources":["webpack://./src/components/Button.scss"],"names":[],"mappings":"AACI;EACI,aAAA;EACA,kBAAA;EACA,eAAA;EACA,iBAAA;EACA,kBAAA;EACA,kBAAA;EACA,cAAA;EACA,mBAAA;AAAR;AACQ;EACI,iBAAA;EACA,YAAA;AACZ","sourcesContent":[".faust-ui-component.faust-ui-component-button {\n & > div {\n display: flex;\n position: relative;\n cursor: pointer;\n border-width: 1px;\n text-align: center;\n border-radius: 4px;\n flex: 1 0 auto;\n border-style: solid;\n & > span {\n user-select: none;\n margin: auto;\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Checkbox.scss": +/*!*******************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Checkbox.scss ***! + \*******************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-checkbox > div { + display: flex; + position: relative; + cursor: pointer; + border-width: 1px; + text-align: center; + border-radius: 1px; + flex: 1 0 auto; + border-style: solid; +} +.faust-ui-component.faust-ui-component-checkbox > div > span { + margin: auto; + user-select: none; +}`, "",{"version":3,"sources":["webpack://./src/components/Checkbox.scss"],"names":[],"mappings":"AACI;EACI,aAAA;EACA,kBAAA;EACA,eAAA;EACA,iBAAA;EACA,kBAAA;EACA,kBAAA;EACA,cAAA;EACA,mBAAA;AAAR;AACQ;EACI,YAAA;EACA,iBAAA;AACZ","sourcesContent":[".faust-ui-component.faust-ui-component-checkbox {\n & > div {\n display: flex;\n position: relative;\n cursor: pointer;\n border-width: 1px;\n text-align: center;\n border-radius: 1px;\n flex: 1 0 auto;\n border-style: solid;\n & > span {\n margin: auto;\n user-select: none;\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Group.scss": +/*!****************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Group.scss ***! + \****************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-group { + position: absolute; + display: block; + background-color: rgba(80, 80, 80, 0.75); + border-radius: 4px; + border: 1px rgba(255, 255, 255, 0.25) solid; +} +.faust-ui-group > .faust-ui-group-label { + position: relative; + margin: 4px; + width: calc(100% - 8px); + user-select: none; +} +.faust-ui-group > .faust-ui-group-label > canvas { + position: relative; + display: block; + max-width: 100%; + max-height: 100%; +} +.faust-ui-group .faust-ui-tgroup-tabs { + position: absolute; + display: inline-block; + white-space: nowrap; + left: 0px; +} +.faust-ui-group .faust-ui-tgroup-tabs .faust-ui-tgroup-tab { + position: relative; + display: inline-block; + border-radius: 5px; + cursor: pointer; + text-overflow: ellipsis; + white-space: nowrap; + user-select: none; + margin: 10px; + text-align: center; + background-color: rgba(255, 255, 255, 0.5); +} +.faust-ui-group .faust-ui-tgroup-tabs .faust-ui-tgroup-tab:hover { + background-color: rgb(255, 255, 255); +} +.faust-ui-group .faust-ui-tgroup-tabs .faust-ui-tgroup-tab.active { + background-color: rgb(40, 40, 40); + color: white; +}`, "",{"version":3,"sources":["webpack://./src/components/Group.scss"],"names":[],"mappings":"AACA;EACI,kBAAA;EACA,cAAA;EACA,wCAAA;EACA,kBAAA;EACA,2CAAA;AAAJ;AACI;EACI,kBAAA;EACA,WAAA;EACA,uBAAA;EACA,iBAAA;AACR;AAAQ;EACI,kBAAA;EACA,cAAA;EACA,eAAA;EACA,gBAAA;AAEZ;AACI;EACI,kBAAA;EACA,qBAAA;EACA,mBAAA;EACA,SAAA;AACR;AAAQ;EACI,kBAAA;EACA,qBAAA;EACA,kBAAA;EACA,eAAA;EACA,uBAAA;EACA,mBAAA;EACA,iBAAA;EACA,YAAA;EACA,kBAAA;EACA,0CAAA;AAEZ;AADY;EACI,oCAAA;AAGhB;AADY;EACI,iCAAA;EACA,YAAA;AAGhB","sourcesContent":["\n.faust-ui-group {\n position: absolute;\n display: block;\n background-color: rgba(80, 80, 80, 0.75);\n border-radius: 4px;\n border: 1px rgba(255, 255, 255, 0.25) solid;\n & > .faust-ui-group-label {\n position: relative;\n margin: 4px;\n width: calc(100% - 8px);\n user-select: none;\n & > canvas {\n position: relative;\n display: block;\n max-width: 100%;\n max-height: 100%;\n }\n }\n & .faust-ui-tgroup-tabs {\n position: absolute;\n display: inline-block;\n white-space: nowrap;\n left: 0px;\n & .faust-ui-tgroup-tab {\n position: relative;\n display: inline-block;\n border-radius: 5px;\n cursor: pointer;\n text-overflow: ellipsis;\n white-space: nowrap;\n user-select: none;\n margin: 10px;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.5);\n &:hover {\n background-color: rgba(255, 255, 255, 1);\n }\n &.active {\n background-color: rgba(40, 40, 40, 1);\n color: white;\n }\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/HBargraph.scss": +/*!********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/HBargraph.scss ***! + \********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-label { + flex: 0 0 auto; +} +.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv { + position: relative; + display: flex; + flex-direction: row-reverse; + flex: 1 1 auto; + width: 100%; + height: auto; +} +.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv > .faust-ui-component-hbargraph-canvasdiv { + position: relative; + display: block; + flex: 1 1 auto; + height: 100%; + margin: auto; +} +.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv > .faust-ui-component-hbargraph-canvasdiv > canvas { + position: absolute; + display: block; + height: 100%; + width: 100%; +} +.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv > input { + position: relative; + display: block; + flex: 0 1 auto; + text-align: center; + background-color: rgba(255, 255, 255, 0.25); + margin: auto 5px auto auto; + border-width: 0px; + border-radius: 4px; + width: calc(20% - 13px); + padding: 2px 4px; +}`, "",{"version":3,"sources":["webpack://./src/components/HBargraph.scss"],"names":[],"mappings":"AACI;EACI,cAAA;AAAR;AAEI;EACI,kBAAA;EACA,aAAA;EACA,2BAAA;EACA,cAAA;EACA,WAAA;EACA,YAAA;AAAR;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,YAAA;EACA,YAAA;AACZ;AAAY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAEhB;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,uBAAA;EACA,gBAAA;AACZ","sourcesContent":[".faust-ui-component.faust-ui-component-hbargraph {\n & > .faust-ui-component-label {\n flex: 0 0 auto;\n }\n & > .faust-ui-component-hbargraph-flexdiv {\n position: relative;\n display: flex;\n flex-direction: row-reverse;\n flex: 1 1 auto;\n width: 100%;\n height: auto;\n & > .faust-ui-component-hbargraph-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n height: 100%;\n margin: auto;\n & > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n }\n }\n & > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: auto 5px auto auto;\n border-width: 0px;\n border-radius: 4px;\n width: calc(20% - 13px);\n padding: 2px 4px;\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/HSlider.scss": +/*!******************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/HSlider.scss ***! + \******************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-label { + flex: 0 0 auto; +} +.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv { + position: relative; + display: flex; + flex-direction: row-reverse; + flex: 1 1 auto; + width: 100%; + height: auto; +} +.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > .faust-ui-component-hslider-canvasdiv { + position: relative; + display: block; + flex: 1 1 auto; + height: 100%; + margin: auto; +} +.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > .faust-ui-component-hslider-canvasdiv > canvas { + position: absolute; + display: block; + height: 100%; + width: 100%; +} +.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > input { + position: relative; + display: block; + flex: 0 1 auto; + text-align: center; + background-color: rgba(255, 255, 255, 0.25); + margin: auto 5px auto auto; + border-width: 0px; + border-radius: 4px; + width: calc(20% - 13px); + padding: 2px 4px; + -moz-appearance: textfield; +} +.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > input::-webkit-outer-spin-button { + -webkit-appearance: none; + margin: 0; +}`, "",{"version":3,"sources":["webpack://./src/components/HSlider.scss"],"names":[],"mappings":"AACI;EACI,cAAA;AAAR;AAEI;EACI,kBAAA;EACA,aAAA;EACA,2BAAA;EACA,cAAA;EACA,WAAA;EACA,YAAA;AAAR;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,YAAA;EACA,YAAA;AACZ;AAAY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAEhB;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,uBAAA;EACA,gBAAA;EACA,0BAAA;AACZ;AAAY;EAEI,wBAAA;EACA,SAAA;AAChB","sourcesContent":[".faust-ui-component.faust-ui-component-hslider {\n & > .faust-ui-component-label {\n flex: 0 0 auto;\n }\n & > .faust-ui-component-hslider-flexdiv {\n position: relative;\n display: flex;\n flex-direction: row-reverse;\n flex: 1 1 auto;\n width: 100%;\n height: auto;\n & > .faust-ui-component-hslider-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n height: 100%;\n margin: auto;\n & > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n }\n }\n & > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: auto 5px auto auto;\n border-width: 0px;\n border-radius: 4px;\n width: calc(20% - 13px);\n padding: 2px 4px;\n -moz-appearance:textfield;\n &::-webkit-inner-spin-button, \n &::-webkit-outer-spin-button {\n -webkit-appearance: none;\n margin: 0;\n }\n }\n }\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Knob.scss": +/*!***************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Knob.scss ***! + \***************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-knob { + align-items: center; +} +.faust-ui-component.faust-ui-component-knob > canvas { + position: relative; + display: block; + flex: 1 1 auto; + min-height: 50%; + width: 100%; +} +.faust-ui-component.faust-ui-component-knob > input { + position: relative; + display: block; + flex: 0 1 auto; + text-align: center; + background-color: rgba(255, 255, 255, 0.25); + margin: 0px; + border-width: 0px; + border-radius: 4px; + max-width: calc(100% - 8px); + padding: 2px 4px; + -moz-appearance: textfield; +} +.faust-ui-component.faust-ui-component-knob > input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-knob > input::-webkit-outer-spin-button { + -webkit-appearance: none; + margin: 0; +}`, "",{"version":3,"sources":["webpack://./src/components/Knob.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,eAAA;EACA,WAAA;AAER;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,WAAA;EACA,iBAAA;EACA,kBAAA;EACA,2BAAA;EACA,gBAAA;EACA,0BAAA;AAER;AADQ;EAEI,wBAAA;EACA,SAAA;AAEZ","sourcesContent":[".faust-ui-component.faust-ui-component-knob {\n align-items: center;\n & > canvas {\n position: relative;\n display: block;\n flex: 1 1 auto;\n min-height: 50%;\n width: 100%;\n }\n & > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: 0px;\n border-width: 0px;\n border-radius: 4px;\n max-width: calc(100% - 8px);\n padding: 2px 4px;\n -moz-appearance:textfield;\n &::-webkit-inner-spin-button, \n &::-webkit-outer-spin-button {\n -webkit-appearance: none;\n margin: 0;\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Led.scss": +/*!**************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Led.scss ***! + \**************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-led { + align-items: center; +} +.faust-ui-component.faust-ui-component-led > .faust-ui-component-label { + flex: 0 0 auto; +} +.faust-ui-component.faust-ui-component-led > .faust-ui-component-led-canvasdiv { + position: relative; + display: block; + flex: 1 1 auto; + width: 100%; +} +.faust-ui-component.faust-ui-component-led > .faust-ui-component-led-canvasdiv > canvas { + position: absolute; + display: block; + height: 100%; + width: 100%; +}`, "",{"version":3,"sources":["webpack://./src/components/Led.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;AAER;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,WAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAGZ","sourcesContent":[".faust-ui-component.faust-ui-component-led {\n align-items: center;\n & > .faust-ui-component-label {\n flex: 0 0 auto;\n }\n & > .faust-ui-component-led-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n width: 100%;\n & > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n }\n }\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Menu.scss": +/*!***************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Menu.scss ***! + \***************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-menu { + align-items: center; +} +.faust-ui-component.faust-ui-component-menu > select { + margin: 0px; + text-align: center; + border-width: 1px; + border-radius: 4px; + padding: 2px 4px; + width: calc(100% - 8px); +}`, "",{"version":3,"sources":["webpack://./src/components/Menu.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,WAAA;EACA,kBAAA;EACA,iBAAA;EACA,kBAAA;EACA,gBAAA;EACA,uBAAA;AAER","sourcesContent":[".faust-ui-component.faust-ui-component-menu {\n align-items: center;\n & > select {\n margin: 0px;\n text-align: center;\n border-width: 1px;\n border-radius: 4px;\n padding: 2px 4px;\n width: calc(100% - 8px);\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Nentry.scss": +/*!*****************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Nentry.scss ***! + \*****************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-nentry { + align-items: center; +} +.faust-ui-component.faust-ui-component-nentry input { + margin: 0px; + text-align: center; + border-width: 1px; + border-radius: 4px; + padding: 2px 4px; + width: calc(100% - 8px); +} +.faust-ui-component.faust-ui-component-nentry input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-nentry input::-webkit-outer-spin-button { + opacity: 1; +}`, "",{"version":3,"sources":["webpack://./src/components/Nentry.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,WAAA;EACA,kBAAA;EACA,iBAAA;EACA,kBAAA;EACA,gBAAA;EACA,uBAAA;AAER;AADQ;EAEI,UAAA;AAEZ","sourcesContent":[".faust-ui-component.faust-ui-component-nentry {\n align-items: center;\n & input {\n margin: 0px;\n text-align: center;\n border-width: 1px;\n border-radius: 4px;\n padding: 2px 4px;\n width: calc(100% - 8px);\n &::-webkit-inner-spin-button, \n &::-webkit-outer-spin-button {\n opacity: 1;\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Numerical.scss": +/*!********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Numerical.scss ***! + \********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-numerical { + align-items: center; +} +.faust-ui-component.faust-ui-component-numerical > input { + position: relative; + display: block; + flex: 0 1 auto; + text-align: center; + background-color: rgba(255, 255, 255, 0.25); + margin: auto; + border-width: 0px; + border-radius: 4px; + width: calc(100% - 8px); + padding: 2px 4px; +}`, "",{"version":3,"sources":["webpack://./src/components/Numerical.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,YAAA;EACA,iBAAA;EACA,kBAAA;EACA,uBAAA;EACA,gBAAA;AAER","sourcesContent":[".faust-ui-component.faust-ui-component-numerical {\n align-items: center;\n & > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: auto;\n border-width: 0px;\n border-radius: 4px;\n width: calc(100% - 8px);\n padding: 2px 4px;\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Radio.scss": +/*!****************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Radio.scss ***! + \****************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-radio { + align-items: center; +} +.faust-ui-component.faust-ui-component-radio > .faust-ui-component-label { + flex: 0 0 auto; + margin-top: auto; +} +.faust-ui-component.faust-ui-component-radio > .faust-ui-component-radio-group { + flex: 0 0 auto; + margin-bottom: auto; + border-width: 1px; + border-radius: 4px; + padding: 2px 4px; + width: calc(100% - 8px); +} +.faust-ui-component.faust-ui-component-radio > .faust-ui-component-radio-group > div { + text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; +}`, "",{"version":3,"sources":["webpack://./src/components/Radio.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;EACA,gBAAA;AAER;AAAI;EACI,cAAA;EACA,mBAAA;EACA,iBAAA;EACA,kBAAA;EACA,gBAAA;EACA,uBAAA;AAER;AADQ;EACI,uBAAA;EACA,mBAAA;EACA,gBAAA;AAGZ","sourcesContent":[".faust-ui-component.faust-ui-component-radio {\n align-items: center;\n & > .faust-ui-component-label {\n flex: 0 0 auto;\n margin-top: auto;\n }\n & > .faust-ui-component-radio-group {\n flex: 0 0 auto;\n margin-bottom: auto;\n border-width: 1px;\n border-radius: 4px;\n padding: 2px 4px;\n width: calc(100% - 8px);\n & > div {\n text-overflow: ellipsis;\n white-space: nowrap;\n overflow: hidden;\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Soundfile.scss": +/*!********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Soundfile.scss ***! + \********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-soundfile > div { + display: flex; + position: relative; + cursor: pointer; + border-width: 1px; + text-align: center; + border-radius: 4px; + flex: 1 0 auto; + border-style: solid; +} +.faust-ui-component.faust-ui-component-soundfile > div > span { + user-select: none; + margin: auto; +}`, "",{"version":3,"sources":["webpack://./src/components/Soundfile.scss"],"names":[],"mappings":"AACI;EACI,aAAA;EACA,kBAAA;EACA,eAAA;EACA,iBAAA;EACA,kBAAA;EACA,kBAAA;EACA,cAAA;EACA,mBAAA;AAAR;AACQ;EACI,iBAAA;EACA,YAAA;AACZ","sourcesContent":[".faust-ui-component.faust-ui-component-soundfile {\n & > div {\n display: flex;\n position: relative;\n cursor: pointer;\n border-width: 1px;\n text-align: center;\n border-radius: 4px;\n flex: 1 0 auto;\n border-style: solid;\n & > span {\n user-select: none;\n margin: auto;\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/VBargraph.scss": +/*!********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/VBargraph.scss ***! + \********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-vbargraph { + align-items: center; +} +.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-label { + flex: 0 0 auto; +} +.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv { + position: relative; + display: flex; + flex-direction: column; + flex: 1 1 auto; + width: 100%; + height: inherit; +} +.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv > .faust-ui-component-vbargraph-canvasdiv { + position: relative; + display: block; + flex: 1 1 auto; + width: 100%; +} +.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv > .faust-ui-component-vbargraph-canvasdiv > canvas { + position: absolute; + display: block; + height: 100%; + width: 100%; +} +.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv > input { + position: relative; + display: block; + flex: 0 1 auto; + text-align: center; + background-color: rgba(255, 255, 255, 0.25); + margin: 5px auto auto auto; + border-width: 0px; + border-radius: 4px; + height: 5%; + width: calc(100% - 8px); + padding: 2px 4px; +}`, "",{"version":3,"sources":["webpack://./src/components/VBargraph.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;AAER;AAAI;EACI,kBAAA;EACA,aAAA;EACA,sBAAA;EACA,cAAA;EACA,WAAA;EACA,eAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,WAAA;AAGZ;AAFY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAIhB;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,UAAA;EACA,uBAAA;EACA,gBAAA;AAGZ","sourcesContent":[".faust-ui-component.faust-ui-component-vbargraph {\n align-items: center;\n & > .faust-ui-component-label {\n flex: 0 0 auto;\n }\n & > .faust-ui-component-vbargraph-flexdiv {\n position: relative;\n display: flex;\n flex-direction: column;\n flex: 1 1 auto;\n width: 100%;\n height: inherit;\n & > .faust-ui-component-vbargraph-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n width: 100%;\n & > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n }\n }\n & > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: 5px auto auto auto;\n border-width: 0px;\n border-radius: 4px;\n height: 5%;\n width: calc(100% - 8px);\n padding: 2px 4px;\n }\n }\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/VSlider.scss": +/*!******************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/VSlider.scss ***! + \******************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-vslider { + align-items: center; +} +.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-label { + flex: 0 0 auto; +} +.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv { + position: relative; + display: flex; + flex-direction: column; + flex: 1 1 auto; + width: 100%; + height: auto; +} +.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv > .faust-ui-component-vslider-canvasdiv { + position: relative; + display: block; + flex: 1 1 auto; + width: 100%; +} +.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv > .faust-ui-component-vslider-canvasdiv > canvas { + position: absolute; + display: block; + height: 100%; + width: 100%; +} +.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv input { + position: relative; + display: block; + flex: 0 1 auto; + text-align: center; + background-color: rgba(255, 255, 255, 0.25); + margin: 5px auto auto auto; + border-width: 0px; + border-radius: 4px; + height: 5%; + max-width: calc(100% - 8px); + padding: 2px 4px; + -moz-appearance: textfield; +} +.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv input::-webkit-outer-spin-button { + -webkit-appearance: none; + margin: 0; +}`, "",{"version":3,"sources":["webpack://./src/components/VSlider.scss"],"names":[],"mappings":"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;AAER;AAAI;EACI,kBAAA;EACA,aAAA;EACA,sBAAA;EACA,cAAA;EACA,WAAA;EACA,YAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,WAAA;AAGZ;AAFY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAIhB;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,UAAA;EACA,2BAAA;EACA,gBAAA;EACA,0BAAA;AAGZ;AAFY;EAEI,wBAAA;EACA,SAAA;AAGhB","sourcesContent":[".faust-ui-component.faust-ui-component-vslider {\n align-items: center;\n & > .faust-ui-component-label {\n flex: 0 0 auto;\n }\n & > .faust-ui-component-vslider-flexdiv {\n position: relative;\n display: flex;\n flex-direction: column;\n flex: 1 1 auto;\n width: 100%;\n height: auto;\n & > .faust-ui-component-vslider-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n width: 100%;\n & > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n }\n }\n & input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: 5px auto auto auto;\n border-width: 0px;\n border-radius: 4px;\n height: 5%;\n max-width: calc(100% - 8px);\n padding: 2px 4px;\n -moz-appearance:textfield;\n &::-webkit-inner-spin-button, \n &::-webkit-outer-spin-button {\n -webkit-appearance: none;\n margin: 0;\n }\n }\n }\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/index.scss": +/*!*****************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/index.scss ***! + \*****************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-root { + margin: 0px auto; + flex: 1 0 auto; + position: relative !important; + background-color: transparent !important; + border: none !important; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; +}`, "",{"version":3,"sources":["webpack://./src/index.scss"],"names":[],"mappings":"AAAA;EACI,gBAAA;EACA,cAAA;EACA,6BAAA;EACA,wCAAA;EACA,uBAAA;EACA,kMAAA;AACJ","sourcesContent":[".faust-ui-root {\n margin: 0px auto;\n flex: 1 0 auto;\n position: relative !important;\n background-color: transparent !important;\n border: none !important;\n font-family: -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, \"Noto Sans\", sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\", \"Noto Color Emoji\";\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/runtime/api.js": +/*!*****************************************************!*\ + !*** ./node_modules/css-loader/dist/runtime/api.js ***! + \*****************************************************/ +/***/ ((module) => { + + + +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = function (cssWithMappingToString) { + var list = []; + + // return the list of modules as css string + list.toString = function toString() { + return this.map(function (item) { + var content = ""; + var needLayer = typeof item[5] !== "undefined"; + if (item[4]) { + content += "@supports (".concat(item[4], ") {"); + } + if (item[2]) { + content += "@media ".concat(item[2], " {"); + } + if (needLayer) { + content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {"); + } + content += cssWithMappingToString(item); + if (needLayer) { + content += "}"; + } + if (item[2]) { + content += "}"; + } + if (item[4]) { + content += "}"; + } + return content; + }).join(""); + }; + + // import a list of modules into the list + list.i = function i(modules, media, dedupe, supports, layer) { + if (typeof modules === "string") { + modules = [[null, modules, undefined]]; + } + var alreadyImportedModules = {}; + if (dedupe) { + for (var k = 0; k < this.length; k++) { + var id = this[k][0]; + if (id != null) { + alreadyImportedModules[id] = true; + } + } + } + for (var _k = 0; _k < modules.length; _k++) { + var item = [].concat(modules[_k]); + if (dedupe && alreadyImportedModules[item[0]]) { + continue; + } + if (typeof layer !== "undefined") { + if (typeof item[5] === "undefined") { + item[5] = layer; + } else { + item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}"); + item[5] = layer; + } + } + if (media) { + if (!item[2]) { + item[2] = media; + } else { + item[1] = "@media ".concat(item[2], " {").concat(item[1], "}"); + item[2] = media; + } + } + if (supports) { + if (!item[4]) { + item[4] = "".concat(supports); + } else { + item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}"); + item[4] = supports; + } + } + list.push(item); + } + }; + return list; +}; + +/***/ }), + +/***/ "./node_modules/css-loader/dist/runtime/sourceMaps.js": +/*!************************************************************!*\ + !*** ./node_modules/css-loader/dist/runtime/sourceMaps.js ***! + \************************************************************/ +/***/ ((module) => { + + + +module.exports = function (item) { + var content = item[1]; + var cssMapping = item[3]; + if (!cssMapping) { + return content; + } + if (typeof btoa === "function") { + var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping)))); + var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64); + var sourceMapping = "/*# ".concat(data, " */"); + return [content].concat([sourceMapping]).join("\n"); + } + return [content].join("\n"); +}; + +/***/ }), + +/***/ "./src/FaustUI.ts": +/*!************************!*\ + !*** ./src/FaustUI.ts ***! + \************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ FaustUI) +/* harmony export */ }); +/* harmony import */ var _layout_Layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./layout/Layout */ "./src/layout/Layout.ts"); +/* harmony import */ var _components_Group__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./components/Group */ "./src/components/Group.ts"); +/* harmony import */ var _index_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index.scss */ "./src/index.scss"); + + + +class FaustUI { + /** + * Calculate incoming UI's layout, bind window events + */ + constructor(options) { + this.componentMap = {}; + /** + * Can be overriden, called by components when its value is changed by user. + */ + this.paramChangeByUI = (path, value) => { + if (!this.hostWindow) + return; + this.hostWindow.postMessage({ path, value, type: "param" }, "*"); + }; + const { root, ui: uiIn, listenWindowResize, listenWindowMessage } = options; + this.DOMroot = root; + this.ui = uiIn || []; + if (typeof listenWindowResize === "undefined" || listenWindowResize === true) { + window.addEventListener("resize", () => { + this.resize(); + }); + } + if (typeof listenWindowMessage === "undefined" || listenWindowMessage === true) { + window.addEventListener("message", (e) => { + const { data, source } = e; + this.hostWindow = source; + const { type } = data; + if (!type) + return; + if (type === "ui") { + this.ui = data.ui; + } else if (type === "param") { + const { path, value } = data; + this.paramChangeByDSP(path, value); + } + }); + } + } + /** + * Render the UI to DOM root + */ + mount() { + this.componentMap = {}; + this.DOMroot.innerHTML = ""; + const props = { + label: "", + type: "vgroup", + items: this.ui, + style: { + grid: this.grid, + width: this.layout.width, + height: this.layout.height, + left: this.layout.offsetLeft, + top: this.layout.offsetTop + }, + isRoot: true, + emitter: this + }; + this.faustUIRoot = new _components_Group__WEBPACK_IMPORTED_MODULE_1__["default"](props); + this.faustUIRoot.componentWillMount(); + this.faustUIRoot.mount(); + this.DOMroot.appendChild(this.faustUIRoot.container); + this.faustUIRoot.componentDidMount(); + } + /** + * This method should be called by components to register itself to map. + */ + register(path, item) { + if (this.componentMap[path]) + this.componentMap[path].push(item); + else + this.componentMap[path] = [item]; + } + /** + * Notify the component to change its value. + */ + paramChangeByDSP(path, value) { + if (this.componentMap[path]) + this.componentMap[path].forEach((item) => item.setState({ value })); + } + /** + * Calculate UI layout in grid then calculate grid size. + */ + calc() { + const { items, layout } = _layout_Layout__WEBPACK_IMPORTED_MODULE_0__["default"].calc(this.ui); + this._ui = items; + this._layout = layout; + this.calcGrid(); + } + /** + * Calculate grid size by DOM root size and layout size in grids. + */ + calcGrid() { + const { width, height } = this.DOMroot.getBoundingClientRect(); + const grid = Math.max(40, Math.min(width / this._layout.width, height / this._layout.height)); + this.grid = grid; + return grid; + } + /** + * Force recalculate grid size and resize UI + */ + resize() { + if (!this.faustUIRoot) + return; + this.calcGrid(); + this.faustUIRoot.setState({ style: { grid: this.grid } }); + } + get ui() { + return this._ui; + } + set ui(uiIn) { + this._ui = uiIn; + this.calc(); + this.mount(); + } + get layout() { + return this._layout; + } + get minWidth() { + return this._layout.width * 40 + 1; + } + get minHeight() { + return this._layout.height * 40 + 1; + } +} + + +/***/ }), + +/***/ "./src/components/AbstractComponent.ts": +/*!*********************************************!*\ + !*** ./src/components/AbstractComponent.ts ***! + \*********************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ AbstractComponent) +/* harmony export */ }); +/* harmony import */ var _shren_typed_event_emitter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @shren/typed-event-emitter */ "./node_modules/@shren/typed-event-emitter/dist/index.js"); +var __defProp = Object.defineProperty; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; + +class AbstractComponent extends _shren_typed_event_emitter__WEBPACK_IMPORTED_MODULE_0__["default"] { + /** + * Initiate default state with incoming state. + */ + constructor(props) { + super(); + /** + * Frame count in order to reduce frame rate + */ + this.$frame = 0; + /** + * Frame reducing factor, 1 = render at every browser rendering tick, 2 will skip one every two ticks. + */ + this.frameReduce = 1; + /** + * `requestAnimationFrame` callback + */ + this.raf = () => { + this.$frame++; + if (this.$frame % this.frameReduce !== 0) { + this.$raf = window.requestAnimationFrame(this.raf); + return; + } + this.$raf = void 0; + this.tasks.forEach((f) => f()); + this.tasks = []; + }; + /** + * tasks to execute in next redering tick + */ + this.tasks = []; + this.state = __spreadValues(__spreadValues({}, this.defaultProps), props); + } + get defaultProps() { + return this.constructor.defaultProps; + } + /** + * set internal state and fire events for UI parts subscribed + */ + setState(newState) { + let shouldUpdate = false; + for (const stateKey in newState) { + const stateValue = newState[stateKey]; + if (stateKey in this.state && this.state[stateKey] !== stateValue) { + this.state[stateKey] = stateValue; + shouldUpdate = true; + } else + return; + if (shouldUpdate) + this.emit(stateKey, this.state[stateKey]); + } + } + /** + * Use this method to request a new rendering + * schedule what you need to do in next render tick in `raf` callback + */ + schedule(func) { + if (this.tasks.indexOf(func) === -1) + this.tasks.push(func); + if (this.$raf) + return; + this.$raf = window.requestAnimationFrame(this.raf); + } +} +/** + * The default state of the component. + */ +AbstractComponent.defaultProps = {}; + + +/***/ }), + +/***/ "./src/components/AbstractItem.ts": +/*!****************************************!*\ + !*** ./src/components/AbstractItem.ts ***! + \****************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ AbstractItem) +/* harmony export */ }); +/* harmony import */ var _AbstractComponent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractComponent */ "./src/components/AbstractComponent.ts"); +/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/components/utils.ts"); +/* harmony import */ var _Base_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Base.scss */ "./src/components/Base.scss"); +var __defProp = Object.defineProperty; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; + + + +const _AbstractItem = class extends _AbstractComponent__WEBPACK_IMPORTED_MODULE_0__["default"] { + /** + * Initiate default state with incoming state. + */ + constructor(props) { + super(props); + this.frameReduce = 3; + /** + * Default DOM event listeners, unify mousedown and touchstart events + * For mouse or touch events, please use `handlePointerDown` `handlePointerUp` `handlePointerDrag` callbacks + */ + this.handleKeyDown = (e) => { + }; + this.handleKeyUp = (e) => { + }; + this.handleTouchStart = (e) => { + e.preventDefault(); + const rect = e.currentTarget.getBoundingClientRect(); + let prevX = e.touches[0].clientX; + let prevY = e.touches[0].clientY; + const fromX = prevX - rect.left; + const fromY = prevY - rect.top; + const prevValue = this.state.value; + this.handlePointerDown({ x: fromX, y: fromY, originalEvent: e }); + const handleTouchMove = (e2) => { + e2.preventDefault(); + const clientX = e2.changedTouches[0].clientX; + const clientY = e2.changedTouches[0].clientY; + const movementX = clientX - prevX; + const movementY = clientY - prevY; + prevX = clientX; + prevY = clientY; + const x = clientX - rect.left; + const y = clientY - rect.top; + this.handlePointerDrag({ prevValue, x, y, fromX, fromY, movementX, movementY, originalEvent: e2 }); + }; + const handleTouchEnd = (e2) => { + e2.preventDefault(); + const x = e2.changedTouches[0].clientX - rect.left; + const y = e2.changedTouches[0].clientY - rect.top; + this.handlePointerUp({ x, y, originalEvent: e2 }); + document.removeEventListener("touchmove", handleTouchMove); + document.removeEventListener("touchend", handleTouchEnd); + }; + document.addEventListener("touchmove", handleTouchMove, { passive: false }); + document.addEventListener("touchend", handleTouchEnd, { passive: false }); + }; + this.handleWheel = (e) => { + }; + this.handleClick = (e) => { + }; + this.handleMouseDown = (e) => { + e.preventDefault(); + e.currentTarget.focus(); + const rect = e.currentTarget.getBoundingClientRect(); + const fromX = e.clientX - rect.left; + const fromY = e.clientY - rect.top; + const prevValue = this.state.value; + this.handlePointerDown({ x: fromX, y: fromY, originalEvent: e }); + const handleMouseMove = (e2) => { + e2.preventDefault(); + const x = e2.clientX - rect.left; + const y = e2.clientY - rect.top; + this.handlePointerDrag({ prevValue, x, y, fromX, fromY, movementX: e2.movementX, movementY: e2.movementY, originalEvent: e2 }); + }; + const handleMouseUp = (e2) => { + e2.preventDefault(); + const x = e2.clientX - rect.left; + const y = e2.clientY - rect.top; + this.handlePointerUp({ x, y, originalEvent: e2 }); + document.removeEventListener("mousemove", handleMouseMove); + document.removeEventListener("mouseup", handleMouseUp); + }; + document.addEventListener("mousemove", handleMouseMove); + document.addEventListener("mouseup", handleMouseUp); + }; + this.handleMouseOver = (e) => { + }; + this.handleMouseOut = (e) => { + }; + this.handleContextMenu = (e) => { + }; + this.handlePointerDown = (e) => { + }; + this.handlePointerDrag = (e) => { + }; + this.handlePointerUp = (e) => { + }; + this.handleFocusIn = (e) => this.setState({ focus: true }); + this.handleFocusOut = (e) => this.setState({ focus: false }); + this.state.style = __spreadValues(__spreadValues({}, this.defaultProps.style), props.style); + if (this.state.emitter) + this.state.emitter.register(this.state.address, this); + } + /** + * Get a nearest valid number + */ + toValidNumber(value) { + const { min, max, step } = this.state; + if (typeof min !== "number" || typeof max !== "number") + return value; + const v = Math.min(max, Math.max(min, value)); + if (!step) + return v; + return min + Math.floor((v - min) / step) * step; + } + /** + * Use this method if you want the emitter to send value to DSP + */ + setValue(valueIn) { + const value = this.toValidNumber(valueIn); + const changed = this.setState({ value }); + if (changed) + this.change(value); + return changed; + } + /** + * Send value to DSP + */ + change(valueIn) { + if (this.state.emitter) + this.state.emitter.paramChangeByUI(this.state.address, typeof valueIn === "number" ? valueIn : this.state.value); + } + /** + * set internal state and fire events for UI parts subscribed + * This will not send anything to DSP + * @returns is state updated + */ + setState(newState) { + let shouldUpdate = false; + for (const key in newState) { + const stateKey = key; + const stateValue = newState[stateKey]; + if (stateKey === "style") { + for (const styleKey in newState.style) { + if (styleKey in this.state.style) { + this.state.style[styleKey] = newState.style[styleKey]; + shouldUpdate = true; + } + } + } else if (stateKey in this.state && this.state[stateKey] !== stateValue) { + this.state[stateKey] = stateValue; + shouldUpdate = true; + } else + return false; + if (shouldUpdate) + this.emit(stateKey, this.state[stateKey]); + } + return shouldUpdate; + } + /** + * Create container with class name + * override it with `super.componentWillMount();` + */ + componentWillMount() { + this.container = document.createElement("div"); + this.container.className = ["faust-ui-component", "faust-ui-component-" + this.className].join(" "); + this.container.tabIndex = 1; + this.container.id = this.state.address; + if (this.state.tooltip) + this.container.title = this.state.tooltip; + this.label = document.createElement("div"); + this.label.className = "faust-ui-component-label"; + this.labelCanvas = document.createElement("canvas"); + this.labelCtx = this.labelCanvas.getContext("2d"); + return this; + } + /** + * Here append all child DOM to container + */ + mount() { + this.label.appendChild(this.labelCanvas); + return this; + } + paintLabel(align) { + const label = this.state.label; + const color = this.state.style.labelcolor; + const ctx = this.labelCtx; + const canvas = this.labelCanvas; + const ratio = window.devicePixelRatio || 1; + let { width, height } = this.label.getBoundingClientRect(); + if (!width || !height) + return this; + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + ctx.clearRect(0, 0, width, height); + ctx.fillStyle = color; + ctx.textBaseline = "middle"; + ctx.textAlign = align || "center"; + ctx.font = `bold ${height * 0.9}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"`; + ctx.fillText(label, align === "left" ? 0 : align === "right" ? width : width / 2, height / 2, width); + return this; + } + /** + * will call this method when mounted + */ + componentDidMount() { + const handleResize = () => { + const { grid, left, top, width, height } = this.state.style; + this.container.style.width = `${width * grid}px`; + this.container.style.height = `${height * grid}px`; + this.container.style.left = `${left * grid}px`; + this.container.style.top = `${top * grid}px`; + this.label.style.height = `${grid * 0.25}px`; + this.paintLabel(); + }; + this.on("style", () => this.schedule(handleResize)); + handleResize(); + return this; + } + /** + * Count steps in range min-max with step + */ + get stepsCount() { + const { type, max, min, step, enums } = this.state; + const maxSteps = type === "enum" ? enums.length : type === "int" ? max - min : (max - min) / step; + if (step) { + if (type === "enum") + return enums.length; + if (type === "int") + return Math.min(Math.floor((max - min) / (Math.round(step) || 1)), maxSteps); + return Math.floor((max - min) / step); + } + return maxSteps; + } + /** + * Normalized value between 0 - 1. + */ + get distance() { + const { type, max, min, value, enums, scale } = this.state; + return _AbstractItem.getDistance({ type, max, min, value, enums, scale }); + } + static getDistance(state) { + const { type, max, min, value, enums, scale } = state; + if (type === "enum") + return value / (enums.length - 1); + const v = scale === "exp" ? (0,_utils__WEBPACK_IMPORTED_MODULE_1__.normLog)(value, min, max) : scale === "log" ? (0,_utils__WEBPACK_IMPORTED_MODULE_1__.normExp)(value, min, max) : value; + return (0,_utils__WEBPACK_IMPORTED_MODULE_1__.normalize)(v, min, max); + } + /** + * Mousemove pixels for each step + */ + get stepRange() { + const full = 100; + const stepsCount = this.stepsCount; + return full / stepsCount; + } +}; +let AbstractItem = _AbstractItem; +/** + * The default state of the component. + */ +AbstractItem.defaultProps = { + value: 0, + active: true, + focus: false, + label: "", + address: "", + min: 0, + max: 1, + enums: {}, + type: "float", + unit: "", + scale: "linear", + step: 0.01, + style: { width: 45, height: 15, left: 0, top: 0, labelcolor: "rgba(226, 222, 255, 0.5)" } +}; + + + +/***/ }), + +/***/ "./src/components/Button.ts": +/*!**********************************!*\ + !*** ./src/components/Button.ts ***! + \**********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Button) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _Button_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Button.scss */ "./src/components/Button.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class Button extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "button"; + this.setStyle = () => { + const { value, style } = this.state; + const { height, grid, fontsize, fontname, fontface, textcolor, textoncolor, bgoncolor, bgcolor, bordercolor, borderoncolor } = style; + this.btn.style.backgroundColor = value ? bgoncolor : bgcolor; + this.btn.style.borderColor = value ? borderoncolor : bordercolor; + this.btn.style.color = value ? textoncolor : textcolor; + this.btn.style.fontSize = `${fontsize || height * grid / 4}px`; + this.btn.style.fontFamily = `${fontname}, sans-serif`; + this.btn.style.fontStyle = fontface; + }; + this.handlePointerDown = () => { + this.setValue(1); + }; + this.handlePointerUp = () => { + this.setValue(0); + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "normal", + bgcolor: "rgba(40, 40, 40, 1)", + bgoncolor: "rgba(18, 18, 18, 1)", + bordercolor: "rgba(80, 80, 80, 1)", + borderoncolor: "rgba(255, 165, 0, 1)", + textcolor: "rgba(226, 222, 255, 0.5)", + textoncolor: "rgba(255, 165, 0, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.btn = document.createElement("div"); + this.span = document.createElement("span"); + this.span.innerText = this.state.label; + this.setStyle(); + return this; + } + mount() { + this.btn.appendChild(this.span); + this.container.appendChild(this.btn); + return super.mount(); + } + componentDidMount() { + super.componentDidMount(); + this.btn.addEventListener("mousedown", this.handleMouseDown); + this.btn.addEventListener("touchstart", this.handleTouchStart); + this.on("style", () => this.schedule(this.setStyle)); + const labelChange = () => this.span.innerText = this.state.label; + this.on("label", () => this.schedule(labelChange)); + this.on("value", () => this.schedule(this.setStyle)); + return this; + } +} + + +/***/ }), + +/***/ "./src/components/Checkbox.ts": +/*!************************************!*\ + !*** ./src/components/Checkbox.ts ***! + \************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Checkbox) +/* harmony export */ }); +/* harmony import */ var _Button__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Button */ "./src/components/Button.ts"); +/* harmony import */ var _Checkbox_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Checkbox.scss */ "./src/components/Checkbox.scss"); + + +class Checkbox extends _Button__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "checkbox"; + this.handlePointerDown = () => { + this.setValue(1 - this.state.value); + }; + this.handlePointerUp = () => { + }; + } +} + + +/***/ }), + +/***/ "./src/components/Group.ts": +/*!*********************************!*\ + !*** ./src/components/Group.ts ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Group) +/* harmony export */ }); +/* harmony import */ var _AbstractComponent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractComponent */ "./src/components/AbstractComponent.ts"); +/* harmony import */ var _HSlider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./HSlider */ "./src/components/HSlider.ts"); +/* harmony import */ var _VSlider__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./VSlider */ "./src/components/VSlider.ts"); +/* harmony import */ var _Nentry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Nentry */ "./src/components/Nentry.ts"); +/* harmony import */ var _Soundfile__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Soundfile */ "./src/components/Soundfile.ts"); +/* harmony import */ var _Button__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./Button */ "./src/components/Button.ts"); +/* harmony import */ var _Checkbox__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./Checkbox */ "./src/components/Checkbox.ts"); +/* harmony import */ var _Knob__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./Knob */ "./src/components/Knob.ts"); +/* harmony import */ var _Menu__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./Menu */ "./src/components/Menu.ts"); +/* harmony import */ var _Radio__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./Radio */ "./src/components/Radio.ts"); +/* harmony import */ var _Led__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./Led */ "./src/components/Led.ts"); +/* harmony import */ var _Numerical__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./Numerical */ "./src/components/Numerical.ts"); +/* harmony import */ var _HBargraph__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./HBargraph */ "./src/components/HBargraph.ts"); +/* harmony import */ var _VBargraph__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./VBargraph */ "./src/components/VBargraph.ts"); +/* harmony import */ var _layout_Layout__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../layout/Layout */ "./src/layout/Layout.ts"); +/* harmony import */ var _Group_scss__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./Group.scss */ "./src/components/Group.scss"); + + + + + + + + + + + + + + + + +class Group extends _AbstractComponent__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.updateUI = () => { + this.children = []; + const { style, type, items, emitter, isRoot } = this.state; + const { grid, left, top, width, height } = style; + if (!this.state.isRoot) + this.label.style.height = `${grid * 0.3}px`; + this.container.style.left = `${left * grid}px`; + this.container.style.top = `${top * grid}px`; + this.container.style.width = `${width * grid}px`; + this.container.style.height = `${height * grid}px`; + this.container.className = ["faust-ui-group", `faust-ui-${type}`, `${isRoot ? "faust-ui-root" : ""}`].join(" "); + items.forEach((item) => { + if (item.type.endsWith("group")) { + const component = Group.getComponent(item, emitter, grid); + if (component) + this.children.push(component); + } else { + const ioItem = item; + const itemComponent = Group.getComponent(ioItem, this.state.emitter, grid); + if (itemComponent) + this.children.push(itemComponent); + } + }); + if (type === "tgroup") { + this.tabs.innerHTML = ""; + this.tabs.style.height = `${grid}px`; + this.tabs.style.top = `${0.25 * grid}px`; + this.state.items.forEach((item, i) => { + const label = item.label; + const tab = document.createElement("span"); + tab.innerText = label; + tab.className = "faust-ui-tgroup-tab"; + tab.style.fontSize = `${0.25 * grid}px`; + tab.style.width = `${2 * grid - 20}px`; + tab.style.height = `${grid - 20}px`; + tab.style.lineHeight = `${grid - 20}px`; + tab.addEventListener("click", () => { + const groups = []; + for (let j = 0; j < this.container.children.length; j++) { + const element = this.container.children[j]; + if (j > 1) + groups.push(element); + } + for (let j = 0; j < groups.length; j++) { + const element = groups[j]; + element.style.visibility = i === j ? "visible" : "hidden"; + } + for (let j = 0; j < this.tabs.children.length; j++) { + const e = this.tabs.children[j]; + if (i !== j) { + if (e.classList.contains("active")) + e.classList.remove("active"); + } else + e.classList.add("active"); + } + }); + this.tabs.appendChild(tab); + }); + } + }; + } + static parseMeta(metaIn) { + const metaObject = {}; + if (!metaIn) + return { metaObject }; + metaIn.forEach((m) => Object.assign(metaObject, m)); + if (metaObject.style) { + const enumsRegex = /\{(?:(?:'|_|-)(.+?)(?:'|_|-):([-+]?[0-9]*\.?[0-9]+?);)+(?:(?:'|_|-)(.+?)(?:'|_|-):([-+]?[0-9]*\.?[0-9]+?))\}/; + const matched = metaObject.style.match(enumsRegex); + if (matched) { + const itemsRegex = /(?:(?:'|_|-)(.+?)(?:'|_|-):([-+]?[0-9]*\.?[0-9]+?))/g; + const enums = {}; + let item; + while (item = itemsRegex.exec(matched[0])) { + enums[item[1]] = +item[2]; + } + return { metaObject, enums }; + } + } + return { metaObject }; + } + static getComponent(item, emitter, grid) { + const type = _layout_Layout__WEBPACK_IMPORTED_MODULE_14__["default"].predictType(item); + if (type.endsWith("group")) { + const { label: label2, items, type: type2, layout: layout2 } = item; + const props2 = { + label: label2, + type: type2, + items, + style: { + grid, + width: layout2.width, + height: layout2.height, + left: layout2.offsetLeft, + top: layout2.offsetTop, + labelcolor: "rgba(255, 255, 255, 0.7)" + }, + emitter + }; + return new Group(props2); + } + const ioItem = item; + const { metaObject, enums } = this.parseMeta(ioItem.meta); + const { tooltip, unit, scale } = metaObject; + const { label, min, max, address, layout } = ioItem; + const props = { + label, + address, + tooltip, + unit, + scale: scale || "linear", + emitter, + enums, + style: { + grid, + width: layout.width, + height: layout.height, + left: layout.offsetLeft, + top: layout.offsetTop + }, + type: "float", + min: isFinite(min) ? min : 0, + max: isFinite(max) ? max : 1, + step: "step" in item ? +item.step : 1, + value: "init" in item ? +item.init || 0 : 0 + }; + if (type === "button") + return new _Button__WEBPACK_IMPORTED_MODULE_5__["default"](props); + if (type === "checkbox") + return new _Checkbox__WEBPACK_IMPORTED_MODULE_6__["default"](props); + if (type === "nentry") + return new _Nentry__WEBPACK_IMPORTED_MODULE_3__["default"](props); + if (type === "soundfile") + return new _Soundfile__WEBPACK_IMPORTED_MODULE_4__["default"](props); + if (type === "knob") + return new _Knob__WEBPACK_IMPORTED_MODULE_7__["default"](props); + if (type === "menu") + return new _Menu__WEBPACK_IMPORTED_MODULE_8__["default"](props); + if (type === "radio") + return new _Radio__WEBPACK_IMPORTED_MODULE_9__["default"](props); + if (type === "hslider") + return new _HSlider__WEBPACK_IMPORTED_MODULE_1__["default"](props); + if (type === "vslider") + return new _VSlider__WEBPACK_IMPORTED_MODULE_2__["default"](props); + if (type === "hbargraph") + return new _HBargraph__WEBPACK_IMPORTED_MODULE_12__["default"](props); + if (type === "vbargraph") + return new _VBargraph__WEBPACK_IMPORTED_MODULE_13__["default"](props); + if (type === "numerical") + return new _Numerical__WEBPACK_IMPORTED_MODULE_11__["default"](props); + if (type === "led") + return new _Led__WEBPACK_IMPORTED_MODULE_10__["default"](props); + return null; + } + setState(newState) { + let shouldUpdate = false; + for (const key in newState) { + const stateKey = key; + const stateValue = newState[stateKey]; + if (stateKey === "style") { + for (const key2 in newState.style) { + const styleKey = key2; + if (styleKey in this.state.style) { + this.state.style[styleKey] = newState.style[styleKey]; + shouldUpdate = true; + } + } + } else if (stateKey in this.state && this.state[stateKey] !== stateValue) { + this.state[stateKey] = stateValue; + shouldUpdate = true; + } else + return; + if (shouldUpdate) + this.emit(stateKey, this.state[stateKey]); + } + } + componentWillMount() { + this.container = document.createElement("div"); + this.tabs = document.createElement("div"); + this.tabs.className = "faust-ui-tgroup-tabs"; + if (!this.state.isRoot) { + this.label = document.createElement("div"); + this.label.className = "faust-ui-group-label"; + this.labelCanvas = document.createElement("canvas"); + this.labelCtx = this.labelCanvas.getContext("2d"); + } + this.updateUI(); + this.children.forEach((item) => item.componentWillMount()); + return this; + } + paintLabel() { + if (this.state.isRoot) + return this; + const label = this.state.label; + const color = this.state.style.labelcolor; + const ctx = this.labelCtx; + const canvas = this.labelCanvas; + const ratio = window.devicePixelRatio || 1; + let { width, height } = this.label.getBoundingClientRect(); + if (!width || !height) + return this; + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + ctx.clearRect(0, 0, width, height); + ctx.fillStyle = color; + ctx.textBaseline = "middle"; + ctx.textAlign = "left"; + ctx.font = `bold ${height * 0.9}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"`; + ctx.fillText(label, 0, height / 2, width); + return this; + } + mount() { + if (!this.state.isRoot) { + this.label.appendChild(this.labelCanvas); + this.container.appendChild(this.label); + } + if (this.tabs.children.length) + this.container.appendChild(this.tabs); + this.children.forEach((item) => { + item.mount(); + this.container.appendChild(item.container); + }); + return this; + } + componentDidMount() { + const handleResize = () => { + const { grid, left, top, width, height } = this.state.style; + if (!this.state.isRoot) + this.label.style.height = `${grid * 0.3}px`; + this.container.style.width = `${width * grid}px`; + this.container.style.height = `${height * grid}px`; + this.container.style.left = `${left * grid}px`; + this.container.style.top = `${top * grid}px`; + if (this.state.type === "tgroup") { + this.tabs.style.height = `${grid}px`; + this.tabs.style.top = `${0.25 * grid}px`; + for (let i = 0; i < this.tabs.children.length; i++) { + const tab = this.tabs.children[i]; + tab.style.fontSize = `${0.25 * grid}px`; + tab.style.width = `${2 * grid - 20}px`; + tab.style.height = `${grid - 20}px`; + tab.style.lineHeight = `${grid - 20}px`; + } + } + this.paintLabel(); + this.children.forEach((item) => item.setState({ style: { grid } })); + }; + this.on("style", () => this.schedule(handleResize)); + const itemsChange = () => { + this.updateUI(); + this.children.forEach((item) => item.componentWillMount()); + }; + this.on("items", () => this.schedule(itemsChange)); + const labelChange = () => { + this.paintLabel(); + this.label.title = this.state.label; + }; + this.on("label", () => this.schedule(labelChange)); + this.paintLabel(); + if (this.tabs && this.tabs.children.length) + this.tabs.children[0].click(); + this.children.forEach((item) => item.componentDidMount()); + return this; + } +} + + +/***/ }), + +/***/ "./src/components/HBargraph.ts": +/*!*************************************!*\ + !*** ./src/components/HBargraph.ts ***! + \*************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ HBargraph) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _VBargraph__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./VBargraph */ "./src/components/VBargraph.ts"); +/* harmony import */ var _HBargraph_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./HBargraph.scss */ "./src/components/HBargraph.scss"); + + + +class HBargraph extends _VBargraph__WEBPACK_IMPORTED_MODULE_1__["default"] { + constructor() { + super(...arguments); + this.className = "hbargraph"; + this.setStyle = () => { + const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + this.input.style.fontSize = `${fontsize || height * grid * 0.2}px`; + this.input.style.color = textcolor; + this.container.style.backgroundColor = bgcolor; + this.container.style.borderColor = bordercolor; + }; + this.paint = () => { + const { barwidth, barbgcolor, coldcolor, warmcolor, hotcolor, overloadcolor } = this.state.style; + const { type, max, min, enums, scale, value } = this.state; + const ctx = this.ctx; + const canvas = this.canvas; + const ratio = window.devicePixelRatio || 1; + let { width, height } = this.canvasDiv.getBoundingClientRect(); + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + const drawWidth = width * 0.9; + const drawHeight = barwidth || Math.min(height / 3, drawWidth * 0.05); + const left = width * 0.05; + const top = (height - drawHeight) * 0.5; + this.paintValue = value; + const paintValue = this.paintValue; + if (paintValue > this.maxValue) { + this.maxValue = paintValue; + if (this.maxTimer) + window.clearTimeout(this.maxTimer); + this.maxTimer = window.setTimeout(() => { + this.maxValue = this.paintValue; + this.maxTimer = void 0; + this.schedule(this.paint); + }, 1e3); + } + if (paintValue < this.maxValue && typeof this.maxTimer === "undefined") { + this.maxTimer = window.setTimeout(() => { + this.maxValue = this.paintValue; + this.maxTimer = void 0; + this.schedule(this.paint); + }, 1e3); + } + const maxValue = this.maxValue; + const coldStop = (-18 - min) / (max - min); + const warmStop = (-6 - min) / (max - min); + const hotStop = (-3 - min) / (max - min); + const overloadStop = Math.max(0, -min / (max - min)); + const gradient = ctx.createLinearGradient(left, 0, drawWidth, 0); + if (coldStop <= 1 && coldStop >= 0) + gradient.addColorStop(coldStop, coldcolor); + else if (coldStop > 1) + gradient.addColorStop(1, coldcolor); + if (warmStop <= 1 && warmStop >= 0) + gradient.addColorStop(warmStop, warmcolor); + if (hotStop <= 1 && hotStop >= 0) + gradient.addColorStop(hotStop, hotcolor); + if (overloadStop <= 1 && overloadStop >= 0) + gradient.addColorStop(overloadStop, overloadcolor); + else if (overloadStop < 0) + gradient.addColorStop(0, coldcolor); + ctx.fillStyle = barbgcolor; + if (paintValue < 0) + ctx.fillRect(left, top, drawWidth * overloadStop, drawHeight); + if (paintValue < max) + ctx.fillRect(left + drawWidth * overloadStop + 1, top, drawWidth * (1 - overloadStop) - 1, drawHeight); + ctx.fillStyle = gradient; + if (paintValue > min) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(0, paintValue) })); + ctx.fillRect(left, top, distance * drawWidth, drawHeight); + } + if (paintValue > 0) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(max, paintValue) }) - overloadStop); + ctx.fillRect(left + overloadStop * drawWidth + 1, top, distance * drawWidth - 1, drawHeight); + } + if (maxValue > paintValue) { + if (maxValue <= 0) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(0, maxValue) })); + ctx.fillRect(left + distance * drawWidth - 1, top, 1, drawHeight); + } + if (maxValue > 0) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(max, maxValue) }) - overloadStop); + ctx.fillRect(left + Math.min(drawWidth - 1, (overloadStop + distance) * drawWidth), top, 1, drawHeight); + } + } + }; + } + paintLabel() { + return super.paintLabel("left"); + } +} + + +/***/ }), + +/***/ "./src/components/HSlider.ts": +/*!***********************************!*\ + !*** ./src/components/HSlider.ts ***! + \***********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ HSlider) +/* harmony export */ }); +/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils */ "./src/components/utils.ts"); +/* harmony import */ var _VSlider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./VSlider */ "./src/components/VSlider.ts"); +/* harmony import */ var _HSlider_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./HSlider.scss */ "./src/components/HSlider.scss"); + + + +class HSlider extends _VSlider__WEBPACK_IMPORTED_MODULE_1__["default"] { + constructor() { + super(...arguments); + this.className = "hslider"; + this.setStyle = () => { + const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + this.input.style.fontSize = `${fontsize || height * grid * 0.2}px`; + this.input.style.color = textcolor; + this.container.style.backgroundColor = bgcolor; + this.container.style.borderColor = bordercolor; + }; + this.paint = () => { + const { sliderwidth, sliderbgcolor, sliderbgoncolor, slidercolor } = this.state.style; + const ctx = this.ctx; + const canvas = this.canvas; + const distance = this.distance; + const ratio = window.devicePixelRatio || 1; + let { width, height } = this.canvasDiv.getBoundingClientRect(); + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + const drawWidth = width * 0.9; + const drawHeight = sliderwidth || Math.min(height / 3, drawWidth * 0.05); + const left = width * 0.05; + const top = (height - drawHeight) * 0.5; + const borderRadius = drawHeight * 0.25; + this.interactionRect = [left, 0, drawWidth, height]; + const grd = ctx.createLinearGradient(left, 0, left + drawWidth, 0); + grd.addColorStop(Math.max(0, Math.min(1, distance)), sliderbgoncolor); + grd.addColorStop(Math.max(0, Math.min(1, distance)), sliderbgcolor); + ctx.fillStyle = grd; + (0,_utils__WEBPACK_IMPORTED_MODULE_0__.fillRoundedRect)(ctx, left, top, drawWidth, drawHeight, borderRadius); + ctx.fillStyle = slidercolor; + (0,_utils__WEBPACK_IMPORTED_MODULE_0__.fillRoundedRect)(ctx, left + drawWidth * distance - drawHeight, top - drawHeight, drawHeight * 2, drawHeight * 3, borderRadius); + }; + } + paintLabel() { + return super.paintLabel("left"); + } +} + + +/***/ }), + +/***/ "./src/components/Knob.ts": +/*!********************************!*\ + !*** ./src/components/Knob.ts ***! + \********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Knob) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/components/utils.ts"); +/* harmony import */ var _Knob_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Knob.scss */ "./src/components/Knob.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + + +class Knob extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "knob"; + this.handleChange = (e) => { + const value = parseFloat(e.currentTarget.value); + if (isFinite(value)) { + const changed = this.setValue(+this.inputNumber.value); + if (changed) + return; + } + this.input.value = this.inputNumber.value + (this.state.unit || ""); + }; + this.setStyle = () => { + const { fontsize, height, grid, textcolor, bgcolor, bordercolor } = this.state.style; + this.input.style.fontSize = `${fontsize || height * grid * 0.1}px`; + this.input.style.color = textcolor; + this.container.style.backgroundColor = bgcolor; + this.container.style.borderColor = bordercolor; + }; + this.paint = () => { + const { knobwidth, knobcolor, knoboncolor, needlecolor } = this.state.style; + const ctx = this.ctx; + const canvas = this.canvas; + const distance = this.distance; + const ratio = window.devicePixelRatio || 1; + let { width, height } = this.canvas.getBoundingClientRect(); + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + const start = 5 / 8 * Math.PI; + const end = 19 / 8 * Math.PI; + const valPos = start + (0,_utils__WEBPACK_IMPORTED_MODULE_1__.toRad)(distance * 315); + const dialHeight = Math.min(width, height) * 0.75; + const dialRadius = dialHeight * 0.5; + const dialCenterX = width * 0.5; + const dialCenterY = height * 0.5; + const valuePosX = dialCenterX + dialHeight * 0.5 * Math.cos(valPos); + const valuePosY = dialCenterY + dialHeight * 0.5 * Math.sin(valPos); + const lineWidth = knobwidth || dialRadius * 0.2; + ctx.strokeStyle = knobcolor; + ctx.lineWidth = lineWidth; + ctx.lineCap = "round"; + ctx.beginPath(); + ctx.arc(dialCenterX, dialCenterY, dialRadius, valPos, end); + ctx.stroke(); + if (distance) { + ctx.strokeStyle = knoboncolor; + ctx.beginPath(); + ctx.arc(dialCenterX, dialCenterY, dialRadius, start, valPos); + ctx.stroke(); + } + ctx.strokeStyle = needlecolor; + ctx.beginPath(); + ctx.moveTo(dialCenterX, dialCenterY); + ctx.lineTo(valuePosX, valuePosY); + ctx.stroke(); + }; + this.handlePointerDrag = (e) => { + const newValue = this.getValueFromDelta(e); + if (newValue !== this.state.value) + this.setValue(newValue); + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(18, 18, 18, 0)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)", + knobwidth: void 0, + knobcolor: "rgba(18, 18, 18, 1)", + knoboncolor: "rgba(255, 165, 0, 1)", + needlecolor: "rgba(200, 200, 200, 0.75)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.canvas = document.createElement("canvas"); + this.canvas.width = 10; + this.canvas.height = 10; + this.ctx = this.canvas.getContext("2d"); + this.inputNumber = document.createElement("input"); + this.inputNumber.type = "number"; + this.inputNumber.value = (+this.state.value.toFixed(3)).toString(); + this.inputNumber.max = this.state.max.toString(); + this.inputNumber.min = this.state.min.toString(); + this.inputNumber.step = this.state.step.toString(); + this.input = document.createElement("input"); + this.input.value = this.inputNumber.value + (this.state.unit || ""); + this.input.spellcheck = false; + this.setStyle(); + return this; + } + componentDidMount() { + super.componentDidMount(); + this.input.addEventListener("change", this.handleChange); + this.canvas.addEventListener("mousedown", this.handleMouseDown); + this.canvas.addEventListener("touchstart", this.handleTouchStart, { passive: false }); + this.on("style", () => { + this.schedule(this.setStyle); + this.schedule(this.paint); + }); + this.on("label", () => this.schedule(this.paintLabel)); + const valueChange = () => { + this.inputNumber.value = (+this.state.value.toFixed(3)).toString(); + this.input.value = this.inputNumber.value + (this.state.unit || ""); + }; + this.on("value", () => { + this.schedule(valueChange); + this.schedule(this.paint); + }); + const maxChange = () => this.inputNumber.max = this.state.max.toString(); + this.on("max", () => { + this.schedule(maxChange); + this.schedule(this.paint); + }); + const minChange = () => this.inputNumber.min = this.state.min.toString(); + this.on("min", () => { + this.schedule(minChange); + this.schedule(this.paint); + }); + const stepChange = () => this.inputNumber.step = this.state.step.toString(); + this.on("step", () => { + this.schedule(stepChange); + this.schedule(this.paint); + }); + this.schedule(this.paint); + return this; + } + mount() { + this.container.appendChild(this.label); + this.container.appendChild(this.canvas); + this.container.appendChild(this.input); + return super.mount(); + } + getValueFromDelta(e) { + const { type, min, max, enums, scale } = this.state; + const step = type === "enum" ? 1 : this.state.step || 1; + const stepRange = this.stepRange; + const stepsCount = this.stepsCount; + const range = 100; + const prevDistance = _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ value: e.prevValue, type, min, max, enums, scale }) * range; + const distance = prevDistance + e.fromY - e.y; + const denormalized = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.denormalize)(distance / range, min, max); + const v = scale === "exp" ? (0,_utils__WEBPACK_IMPORTED_MODULE_1__.normExp)(denormalized, min, max) : scale === "log" ? (0,_utils__WEBPACK_IMPORTED_MODULE_1__.normLog)(denormalized, min, max) : denormalized; + let steps = Math.round((0,_utils__WEBPACK_IMPORTED_MODULE_1__.normalize)(v, min, max) * range / stepRange); + steps = Math.min(stepsCount, Math.max(0, steps)); + if (type === "enum") + return steps; + if (type === "int") + return Math.round(steps * step + min); + return steps * step + min; + } +} + + +/***/ }), + +/***/ "./src/components/Led.ts": +/*!*******************************!*\ + !*** ./src/components/Led.ts ***! + \*******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Led) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _Led_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Led.scss */ "./src/components/Led.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class Led extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "led"; + this.setStyle = () => { + const { bgcolor, bordercolor } = this.state.style; + this.container.style.backgroundColor = bgcolor; + this.container.style.borderColor = bordercolor; + }; + this.paint = () => { + const { shape, ledbgcolor, coldcolor, warmcolor, hotcolor, overloadcolor } = this.state.style; + const { min, max } = this.state; + const { canvas, ctx, tempCanvas, tempCtx, distance } = this; + const ratio = window.devicePixelRatio || 1; + let { width, height } = canvas.getBoundingClientRect(); + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + const drawHeight = Math.min(height, width) * 0.75; + const drawWidth = drawHeight; + const left = (width - drawWidth) * 0.5; + const top = (height - drawHeight) * 0.5; + const coldStop = (-18 - min) / (max - min); + const warmStop = (-6 - min) / (max - min); + const hotStop = (-3 - min) / (max - min); + const overloadStop = -min / (max - min); + const gradient = tempCtx.createLinearGradient(0, 0, tempCanvas.width, 0); + if (coldStop <= 1 && coldStop >= 0) + gradient.addColorStop(coldStop, coldcolor); + else if (coldStop > 1) + gradient.addColorStop(1, coldcolor); + if (warmStop <= 1 && warmStop >= 0) + gradient.addColorStop(warmStop, warmcolor); + if (hotStop <= 1 && hotStop >= 0) + gradient.addColorStop(hotStop, hotcolor); + if (overloadStop <= 1 && overloadStop >= 0) + gradient.addColorStop(overloadStop, overloadcolor); + else if (overloadStop < 0) + gradient.addColorStop(0, coldcolor); + tempCtx.fillStyle = gradient; + tempCtx.fillRect(0, 0, tempCanvas.width, 10); + const d = tempCtx.getImageData(Math.min(tempCanvas.width - 1, distance * tempCanvas.width), 0, 1, 1).data; + if (distance) + ctx.fillStyle = `rgb(${d[0]}, ${d[1]}, ${d[2]})`; + else + ctx.fillStyle = ledbgcolor; + if (shape === "circle") + ctx.arc(width / 2, height / 2, width / 2 - left, 0, 2 * Math.PI); + else + ctx.rect(left, top, drawWidth, drawHeight); + ctx.fill(); + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(18, 18, 18, 0)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)", + shape: "circle", + ledbgcolor: "rgba(18, 18, 18, 1)", + coldcolor: "rgba(12, 248, 100, 1)", + warmcolor: "rgba(195, 248, 100, 1)", + hotcolor: "rgba(255, 193, 10, 1)", + overloadcolor: "rgba(255, 10, 10, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.canvasDiv = document.createElement("div"); + this.canvasDiv.className = `faust-ui-component-${this.className}-canvasdiv`; + this.canvas = document.createElement("canvas"); + this.canvas.width = 10; + this.canvas.height = 10; + this.ctx = this.canvas.getContext("2d"); + this.tempCanvas = document.createElement("canvas"); + this.tempCtx = this.tempCanvas.getContext("2d"); + this.tempCanvas.width = 128; + this.tempCanvas.height = 1; + this.setStyle(); + return this; + } + componentDidMount() { + super.componentDidMount(); + this.canvas.addEventListener("mousedown", this.handleMouseDown); + this.canvas.addEventListener("touchstart", this.handleTouchStart, { passive: false }); + this.on("style", () => this.schedule(this.setStyle)); + this.on("label", () => this.schedule(this.paintLabel)); + this.on("value", () => this.schedule(this.paint)); + this.on("max", () => this.schedule(this.paint)); + this.on("min", () => this.schedule(this.paint)); + this.on("step", () => this.schedule(this.paint)); + this.schedule(this.paint); + return this; + } + mount() { + this.canvasDiv.appendChild(this.canvas); + this.container.appendChild(this.label); + this.container.appendChild(this.canvasDiv); + return super.mount(); + } +} + + +/***/ }), + +/***/ "./src/components/Menu.ts": +/*!********************************!*\ + !*** ./src/components/Menu.ts ***! + \********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Menu) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _Menu_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Menu.scss */ "./src/components/Menu.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class Menu extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "menu"; + this.handleChange = (e) => { + this.setValue(+e.currentTarget.value); + }; + this.setStyle = () => { + const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + this.select.style.backgroundColor = bgcolor; + this.select.style.borderColor = bordercolor; + this.select.style.color = textcolor; + this.select.style.fontSize = `${fontsize || height * grid / 4}px`; + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(255, 255, 255, 0.25)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.select = document.createElement("select"); + this.getOptions(); + this.setStyle(); + return this; + } + getOptions() { + const { enums } = this.state; + this.select.innerHTML = ""; + if (enums) { + let i = 0; + for (const key in enums) { + const option = document.createElement("option"); + option.value = enums[key].toString(); + option.text = key; + if (i === 0) + option.selected = true; + this.select.appendChild(option); + i++; + } + } + } + componentDidMount() { + super.componentDidMount(); + this.select.addEventListener("change", this.handleChange); + this.on("style", () => this.schedule(this.setStyle)); + this.on("label", () => this.schedule(this.paintLabel)); + this.on("enums", () => this.schedule(this.getOptions)); + const valueChange = () => { + for (let i = this.select.children.length - 1; i >= 0; i--) { + const option = this.select.children[i]; + if (+option.value === this.state.value) + this.select.selectedIndex = i; + } + }; + this.on("value", () => this.schedule(valueChange)); + valueChange(); + return this; + } + mount() { + this.container.appendChild(this.label); + this.container.appendChild(this.select); + return super.mount(); + } +} + + +/***/ }), + +/***/ "./src/components/Nentry.ts": +/*!**********************************!*\ + !*** ./src/components/Nentry.ts ***! + \**********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Nentry) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _Nentry_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Nentry.scss */ "./src/components/Nentry.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class Nentry extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "nentry"; + this.handleChange = (e) => { + this.setValue(+e.currentTarget.value); + }; + this.setStyle = () => { + const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + this.input.style.backgroundColor = bgcolor; + this.input.style.borderColor = bordercolor; + this.input.style.color = textcolor; + this.input.style.fontSize = `${fontsize || height * grid / 4}px`; + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(255, 255, 255, 0.25)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.input = document.createElement("input"); + this.input.type = "number"; + this.input.value = (+this.state.value.toFixed(3)).toString(); + this.input.max = this.state.max.toString(); + this.input.min = this.state.min.toString(); + this.input.step = this.state.step.toString(); + this.setStyle(); + return this; + } + componentDidMount() { + super.componentDidMount(); + this.input.addEventListener("change", this.handleChange); + this.on("style", () => this.schedule(this.setStyle)); + this.on("label", () => this.schedule(this.paintLabel)); + const valueChange = () => this.input.value = (+this.state.value.toFixed(3)).toString(); + this.on("value", () => this.schedule(valueChange)); + const maxChange = () => this.input.max = this.state.max.toString(); + this.on("max", () => this.schedule(maxChange)); + const minChange = () => this.input.min = this.state.min.toString(); + this.on("min", () => this.schedule(minChange)); + const stepChange = () => this.input.step = this.state.step.toString(); + this.on("step", () => this.schedule(stepChange)); + return this; + } + mount() { + this.container.appendChild(this.label); + this.container.appendChild(this.input); + return super.mount(); + } +} + + +/***/ }), + +/***/ "./src/components/Numerical.ts": +/*!*************************************!*\ + !*** ./src/components/Numerical.ts ***! + \*************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Numerical) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _Numerical_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Numerical.scss */ "./src/components/Numerical.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class Numerical extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "numerical"; + this.setStyle = () => { + const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + this.input.style.backgroundColor = bgcolor; + this.input.style.borderColor = bordercolor; + this.input.style.color = textcolor; + this.input.style.fontSize = `${fontsize || height * grid / 4}px`; + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(255, 255, 255, 0.25)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.input = document.createElement("input"); + this.input.disabled = true; + this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || ""); + this.setStyle(); + return this; + } + componentDidMount() { + super.componentDidMount(); + this.on("style", () => this.schedule(this.setStyle)); + this.on("label", () => this.schedule(this.paintLabel)); + const valueChange = () => this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || ""); + this.on("value", () => this.schedule(valueChange)); + return this; + } + mount() { + this.container.appendChild(this.label); + this.container.appendChild(this.input); + return super.mount(); + } +} + + +/***/ }), + +/***/ "./src/components/Radio.ts": +/*!*********************************!*\ + !*** ./src/components/Radio.ts ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Radio) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _Radio_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Radio.scss */ "./src/components/Radio.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class Radio extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "radio"; + this.getOptions = () => { + const { enums, address } = this.state; + this.group.innerHTML = ""; + if (enums) { + let i = 0; + for (const key in enums) { + const input = document.createElement("input"); + const div = document.createElement("div"); + input.value = enums[key].toString(); + input.name = address; + input.type = "radio"; + if (i === 0) + input.checked = true; + input.addEventListener("change", () => { + if (input.checked) + this.setValue(enums[key]); + }); + div.appendChild(input); + div.append(key); + this.group.appendChild(div); + i++; + } + } + }; + this.setStyle = () => { + const { height, width, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + const fontSize = Math.min(height * grid * 0.1, width * grid * 0.1); + this.group.style.backgroundColor = bgcolor; + this.group.style.borderColor = bordercolor; + this.group.style.color = textcolor; + this.group.style.fontSize = `${fontsize || fontSize}px`; + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(255, 255, 255, 0.25)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.group = document.createElement("div"); + this.group.className = "faust-ui-component-radio-group"; + this.getOptions(); + this.setStyle(); + return this; + } + componentDidMount() { + super.componentDidMount(); + this.on("style", () => this.schedule(this.setStyle)); + this.on("label", () => this.schedule(this.paintLabel)); + this.on("enums", () => this.schedule(this.getOptions)); + const valueChange = () => { + for (let i = this.group.children.length - 1; i >= 0; i--) { + const input = this.group.children[i].querySelector("input"); + if (+input.value === this.state.value) + input.checked = true; + } + }; + this.on("value", () => this.schedule(valueChange)); + valueChange(); + return this; + } + mount() { + this.container.appendChild(this.label); + this.container.appendChild(this.group); + return super.mount(); + } +} + + +/***/ }), + +/***/ "./src/components/Soundfile.ts": +/*!*************************************!*\ + !*** ./src/components/Soundfile.ts ***! + \*************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Soundfile) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _Soundfile_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Soundfile.scss */ "./src/components/Soundfile.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class Soundfile extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "soundfile"; + this.setStyle = () => { + const { value, style } = this.state; + const { height, grid, fontsize, fontname, fontface, textcolor, textoncolor, bgoncolor, bgcolor, bordercolor, borderoncolor } = style; + this.btn.style.backgroundColor = value ? bgoncolor : bgcolor; + this.btn.style.borderColor = value ? borderoncolor : bordercolor; + this.btn.style.color = value ? textoncolor : textcolor; + this.btn.style.fontSize = `${fontsize || height * grid / 4}px`; + this.btn.style.fontFamily = `${fontname}, sans-serif`; + this.btn.style.fontStyle = fontface; + }; + this.handlePointerDown = () => { + }; + this.handlePointerUp = () => { + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "normal", + bgcolor: "rgba(40, 40, 40, 1)", + bgoncolor: "rgba(18, 18, 18, 1)", + bordercolor: "rgba(80, 80, 80, 1)", + borderoncolor: "rgba(255, 165, 0, 1)", + textcolor: "rgba(226, 222, 255, 0.5)", + textoncolor: "rgba(255, 165, 0, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.btn = document.createElement("div"); + this.span = document.createElement("span"); + this.span.innerText = this.state.label; + this.setStyle(); + return this; + } + mount() { + this.btn.appendChild(this.span); + this.container.appendChild(this.btn); + return super.mount(); + } + componentDidMount() { + super.componentDidMount(); + this.btn.addEventListener("mousedown", this.handleMouseDown); + this.btn.addEventListener("touchstart", this.handleTouchStart); + this.on("style", () => this.schedule(this.setStyle)); + const labelChange = () => this.span.innerText = this.state.label; + this.on("label", () => this.schedule(labelChange)); + this.on("value", () => this.schedule(this.setStyle)); + return this; + } +} + + +/***/ }), + +/***/ "./src/components/VBargraph.ts": +/*!*************************************!*\ + !*** ./src/components/VBargraph.ts ***! + \*************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ VBargraph) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _VBargraph_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./VBargraph.scss */ "./src/components/VBargraph.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + +class VBargraph extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "vbargraph"; + this.setStyle = () => { + const { height, width, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + const fontSize = Math.min(height * grid * 0.05, width * grid * 0.2); + this.input.style.fontSize = `${fontsize || fontSize}px`; + this.input.style.color = textcolor; + this.container.style.backgroundColor = bgcolor; + this.container.style.borderColor = bordercolor; + }; + this.paintValue = 0; + this.maxValue = -Infinity; + this.paint = () => { + const { barwidth, barbgcolor, coldcolor, warmcolor, hotcolor, overloadcolor } = this.state.style; + const { type, max, min, enums, scale, value } = this.state; + const ctx = this.ctx; + const canvas = this.canvas; + const ratio = window.devicePixelRatio || 1; + let { width, height } = this.canvasDiv.getBoundingClientRect(); + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + const drawHeight = height * 0.9; + const drawWidth = barwidth || Math.min(width / 3, drawHeight * 0.05); + const left = (width - drawWidth) * 0.5; + const top = height * 0.05; + this.paintValue = value; + const paintValue = this.paintValue; + if (paintValue > this.maxValue) { + this.maxValue = paintValue; + if (this.maxTimer) + window.clearTimeout(this.maxTimer); + this.maxTimer = window.setTimeout(() => { + this.maxValue = this.paintValue; + this.maxTimer = void 0; + this.schedule(this.paint); + }, 1e3); + } + if (paintValue < this.maxValue && typeof this.maxTimer === "undefined") { + this.maxTimer = window.setTimeout(() => { + this.maxValue = this.paintValue; + this.maxTimer = void 0; + this.schedule(this.paint); + }, 1e3); + } + const maxValue = this.maxValue; + const coldStop = (-18 - min) / (max - min); + const warmStop = (-6 - min) / (max - min); + const hotStop = (-3 - min) / (max - min); + const overloadStop = Math.max(0, -min / (max - min)); + const gradient = ctx.createLinearGradient(0, drawHeight, 0, top); + if (coldStop <= 1 && coldStop >= 0) + gradient.addColorStop(coldStop, coldcolor); + else if (coldStop > 1) + gradient.addColorStop(1, coldcolor); + if (warmStop <= 1 && warmStop >= 0) + gradient.addColorStop(warmStop, warmcolor); + if (hotStop <= 1 && hotStop >= 0) + gradient.addColorStop(hotStop, hotcolor); + if (overloadStop <= 1 && overloadStop >= 0) + gradient.addColorStop(overloadStop, overloadcolor); + else if (overloadStop < 0) + gradient.addColorStop(0, coldcolor); + ctx.fillStyle = barbgcolor; + if (paintValue < 0) + ctx.fillRect(left, top + (1 - overloadStop) * drawHeight, drawWidth, drawHeight * overloadStop); + if (paintValue < max) + ctx.fillRect(left, top, drawWidth, (1 - overloadStop) * drawHeight - 1); + ctx.fillStyle = gradient; + if (paintValue > min) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(0, paintValue) })); + ctx.fillRect(left, top + (1 - distance) * drawHeight, drawWidth, drawHeight * distance); + } + if (paintValue > 0) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(max, paintValue) }) - overloadStop); + ctx.fillRect(left, top + (1 - overloadStop - distance) * drawHeight, drawWidth, drawHeight * distance - 1); + } + if (maxValue > paintValue) { + if (maxValue <= 0) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(0, maxValue) })); + ctx.fillRect(left, top + (1 - distance) * drawHeight, drawWidth, 1); + } + if (maxValue > 0) { + const distance = Math.max(0, _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"].getDistance({ type, max, min, enums, scale, value: Math.min(max, maxValue) }) - overloadStop); + ctx.fillRect(left, Math.max(top, top + (1 - overloadStop - distance) * drawHeight - 1), drawWidth, 1); + } + } + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(18, 18, 18, 0)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)", + barwidth: void 0, + barbgcolor: "rgba(18, 18, 18, 1)", + coldcolor: "rgba(12, 248, 100, 1)", + warmcolor: "rgba(195, 248, 100, 1)", + hotcolor: "rgba(255, 193, 10, 1)", + overloadcolor: "rgba(255, 10, 10, 1)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.flexDiv = document.createElement("div"); + this.flexDiv.className = `faust-ui-component-${this.className}-flexdiv`; + this.canvasDiv = document.createElement("div"); + this.canvasDiv.className = `faust-ui-component-${this.className}-canvasdiv`; + this.canvas = document.createElement("canvas"); + this.canvas.width = 10; + this.canvas.height = 10; + this.ctx = this.canvas.getContext("2d"); + this.input = document.createElement("input"); + this.input.disabled = true; + this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || ""); + this.setStyle(); + return this; + } + componentDidMount() { + super.componentDidMount(); + this.canvas.addEventListener("mousedown", this.handleMouseDown); + this.canvas.addEventListener("touchstart", this.handleTouchStart, { passive: false }); + this.on("style", () => { + this.schedule(this.setStyle); + this.schedule(this.paint); + }); + this.on("label", () => this.schedule(this.paintLabel)); + const valueChange = () => this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || ""); + this.on("value", () => { + this.schedule(valueChange); + this.schedule(this.paint); + }); + this.on("max", () => this.schedule(this.paint)); + this.on("min", () => this.schedule(this.paint)); + this.on("step", () => this.schedule(this.paint)); + this.schedule(this.paint); + return this; + } + mount() { + this.canvasDiv.appendChild(this.canvas); + this.flexDiv.appendChild(this.canvasDiv); + this.flexDiv.appendChild(this.input); + this.container.appendChild(this.label); + this.container.appendChild(this.flexDiv); + return super.mount(); + } +} + + +/***/ }), + +/***/ "./src/components/VSlider.ts": +/*!***********************************!*\ + !*** ./src/components/VSlider.ts ***! + \***********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ VSlider) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/components/AbstractItem.ts"); +/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/components/utils.ts"); +/* harmony import */ var _VSlider_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./VSlider.scss */ "./src/components/VSlider.scss"); +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + + +class VSlider extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.className = "vslider"; + this.interactionRect = [0, 0, 0, 0]; + this.handleChange = (e) => { + const value = parseFloat(e.currentTarget.value); + if (isFinite(value)) { + const changed = this.setValue(+value); + if (changed) + return; + } + this.input.value = this.inputNumber.value + (this.state.unit || ""); + }; + this.setStyle = () => { + const { height, width, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style; + const fontSize = Math.min(height * grid * 0.05, width * grid * 0.2); + this.input.style.fontSize = `${fontsize || fontSize}px`; + this.input.style.color = textcolor; + this.container.style.backgroundColor = bgcolor; + this.container.style.borderColor = bordercolor; + }; + this.paint = () => { + const { sliderwidth, sliderbgcolor, sliderbgoncolor, slidercolor } = this.state.style; + const ctx = this.ctx; + const canvas = this.canvas; + const distance = this.distance; + const ratio = window.devicePixelRatio || 1; + let { width, height } = this.canvasDiv.getBoundingClientRect(); + width = Math.floor(width); + height = Math.floor(height); + const scaledWidth = Math.floor(width * ratio); + const scaledHeight = Math.floor(height * ratio); + canvas.width = scaledWidth; + canvas.height = scaledHeight; + ctx.scale(ratio, ratio); + const drawHeight = height * 0.9; + const drawWidth = sliderwidth || Math.min(width / 3, drawHeight * 0.05); + const left = (width - drawWidth) * 0.5; + const top = height * 0.05; + const borderRadius = drawWidth * 0.25; + this.interactionRect = [0, top, width, drawHeight]; + const grd = ctx.createLinearGradient(0, top, 0, top + drawHeight); + grd.addColorStop(Math.max(0, Math.min(1, 1 - distance)), sliderbgcolor); + grd.addColorStop(Math.max(0, Math.min(1, 1 - distance)), sliderbgoncolor); + ctx.fillStyle = grd; + (0,_utils__WEBPACK_IMPORTED_MODULE_1__.fillRoundedRect)(ctx, left, top, drawWidth, drawHeight, borderRadius); + ctx.fillStyle = slidercolor; + (0,_utils__WEBPACK_IMPORTED_MODULE_1__.fillRoundedRect)(ctx, left - drawWidth, top + drawHeight * (1 - distance) - drawWidth, drawWidth * 3, drawWidth * 2, borderRadius); + }; + this.handlePointerDown = (e) => { + const { value } = this.state; + if (e.x < this.interactionRect[0] || e.x > this.interactionRect[0] + this.interactionRect[2] || e.y < this.interactionRect[1] || e.y > this.interactionRect[1] + this.interactionRect[3]) + return; + const newValue = this.getValueFromPos(e); + if (newValue !== value) + this.setValue(this.getValueFromPos(e)); + }; + this.handlePointerDrag = (e) => { + const newValue = this.getValueFromPos(e); + if (newValue !== this.state.value) + this.setValue(newValue); + }; + } + static get defaultProps() { + const inherited = super.defaultProps; + return __spreadProps(__spreadValues({}, inherited), { + style: __spreadProps(__spreadValues({}, inherited.style), { + fontname: "Arial", + fontsize: void 0, + fontface: "regular", + bgcolor: "rgba(18, 18, 18, 0)", + bordercolor: "rgba(80, 80, 80, 0)", + labelcolor: "rgba(226, 222, 255, 0.5)", + textcolor: "rgba(18, 18, 18, 1)", + sliderwidth: void 0, + sliderbgcolor: "rgba(18, 18, 18, 1)", + sliderbgoncolor: "rgba(255, 165, 0, 1)", + slidercolor: "rgba(200, 200, 200, 0.75)" + }) + }); + } + componentWillMount() { + super.componentWillMount(); + this.flexDiv = document.createElement("div"); + this.flexDiv.className = `faust-ui-component-${this.className}-flexdiv`; + this.canvasDiv = document.createElement("div"); + this.canvasDiv.className = `faust-ui-component-${this.className}-canvasdiv`; + this.canvas = document.createElement("canvas"); + this.canvas.width = 10; + this.canvas.height = 10; + this.ctx = this.canvas.getContext("2d"); + this.inputNumber = document.createElement("input"); + this.inputNumber.type = "number"; + this.inputNumber.value = (+this.state.value.toFixed(3)).toString(); + this.inputNumber.max = this.state.max.toString(); + this.inputNumber.min = this.state.min.toString(); + this.inputNumber.step = this.state.step.toString(); + this.input = document.createElement("input"); + this.input.value = this.inputNumber.value + (this.state.unit || ""); + this.input.spellcheck = false; + this.setStyle(); + return this; + } + componentDidMount() { + super.componentDidMount(); + this.input.addEventListener("change", this.handleChange); + this.canvas.addEventListener("mousedown", this.handleMouseDown); + this.canvas.addEventListener("touchstart", this.handleTouchStart, { passive: false }); + this.on("style", () => { + this.schedule(this.setStyle); + this.schedule(this.paint); + }); + this.on("label", () => this.schedule(this.paintLabel)); + const valueChange = () => { + this.inputNumber.value = (+this.state.value.toFixed(3)).toString(); + this.input.value = this.inputNumber.value + (this.state.unit || ""); + }; + this.on("value", () => { + this.schedule(valueChange); + this.schedule(this.paint); + }); + const maxChange = () => this.inputNumber.max = this.state.max.toString(); + this.on("max", () => { + this.schedule(maxChange); + this.schedule(this.paint); + }); + const minChange = () => this.inputNumber.min = this.state.min.toString(); + this.on("min", () => { + this.schedule(minChange); + this.schedule(this.paint); + }); + const stepChange = () => this.inputNumber.step = this.state.step.toString(); + this.on("step", () => { + this.schedule(stepChange); + this.schedule(this.paint); + }); + this.schedule(this.paint); + return this; + } + mount() { + this.canvasDiv.appendChild(this.canvas); + this.flexDiv.appendChild(this.canvasDiv); + this.flexDiv.appendChild(this.input); + this.container.appendChild(this.label); + this.container.appendChild(this.flexDiv); + return super.mount(); + } + get stepsCount() { + const { type, max, min, step, enums } = this.state; + const maxSteps = type === "enum" ? enums.length : type === "int" ? max - min : (max - min) / step; + if (step) { + if (type === "enum") + return enums.length; + if (type === "int") + return Math.min(Math.floor((max - min) / (Math.round(step) || 0)), maxSteps); + return Math.floor((max - min) / step); + } + return maxSteps; + } + get stepRange() { + const full = this.interactionRect[this.className === "vslider" ? 3 : 2]; + const stepsCount = this.stepsCount; + return full / stepsCount; + } + getValueFromPos(e) { + const { type, min, max, scale } = this.state; + const step = type === "enum" ? 1 : this.state.step || 1; + const stepRange = this.stepRange; + const stepsCount = this.stepsCount; + const distance = this.className === "vslider" ? this.interactionRect[3] - (e.y - this.interactionRect[1]) : e.x - this.interactionRect[0]; + const range = this.className === "vslider" ? this.interactionRect[3] : this.interactionRect[2]; + const denormalized = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.denormalize)(distance / range, min, max); + const v = scale === "exp" ? (0,_utils__WEBPACK_IMPORTED_MODULE_1__.normExp)(denormalized, min, max) : scale === "log" ? (0,_utils__WEBPACK_IMPORTED_MODULE_1__.normLog)(denormalized, min, max) : denormalized; + let steps = Math.round((0,_utils__WEBPACK_IMPORTED_MODULE_1__.normalize)(v, min, max) * range / stepRange); + steps = Math.min(stepsCount, Math.max(0, steps)); + if (type === "enum") + return steps; + if (type === "int") + return Math.round(steps * step + min); + return steps * step + min; + } +} + + +/***/ }), + +/***/ "./src/components/utils.ts": +/*!*********************************!*\ + !*** ./src/components/utils.ts ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ atodb: () => (/* binding */ atodb), +/* harmony export */ dbtoa: () => (/* binding */ dbtoa), +/* harmony export */ denormalize: () => (/* binding */ denormalize), +/* harmony export */ fillRoundedRect: () => (/* binding */ fillRoundedRect), +/* harmony export */ iNormExp: () => (/* binding */ iNormExp), +/* harmony export */ iNormLog: () => (/* binding */ iNormLog), +/* harmony export */ normExp: () => (/* binding */ normExp), +/* harmony export */ normLog: () => (/* binding */ normLog), +/* harmony export */ normalize: () => (/* binding */ normalize), +/* harmony export */ roundedRect: () => (/* binding */ roundedRect), +/* harmony export */ toMIDI: () => (/* binding */ toMIDI), +/* harmony export */ toRad: () => (/* binding */ toRad) +/* harmony export */ }); +const toMIDI = (f) => ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"][(f % 12 + 12) % 12] + Math.round(f / 12 - 2); +const toRad = (degrees) => degrees * Math.PI / 180; +const atodb = (a) => 20 * Math.log10(a); +const dbtoa = (db) => 10 ** (db / 20); +const denormalize = (x, min, max) => min + (max - min) * x; +const normalize = (x, min, max) => (x - min) / (max - min) || 0; +const normLog = (x, min, max) => { + const normalized = normalize(x, min, max); + const logMin = Math.log(Math.max(Number.EPSILON, min)); + const logMax = Math.log(Math.max(Number.EPSILON, max)); + const vLog = denormalize(normalized, logMin, logMax); + const v = Math.exp(vLog); + return Math.max(min, Math.min(max, v)); +}; +const iNormLog = (vIn, min, max) => { + const v = Math.max(min, Math.min(max, vIn)); + const vLog = Math.log(Math.max(Number.EPSILON, v)); + const logMin = Math.log(Math.max(Number.EPSILON, min)); + const logMax = Math.log(Math.max(Number.EPSILON, max)); + const normalized = normalize(vLog, logMin, logMax); + return denormalize(normalized, min, max); +}; +const normExp = iNormLog; +const iNormExp = normLog; +const roundedRect = (ctx, x, y, width, height, radius) => { + const radii = [0, 0, 0, 0]; + if (typeof radius === "number") + radii.fill(radius); + else + radius.forEach((v, i) => radii[i] = v); + ctx.beginPath(); + ctx.moveTo(x + radii[0], y); + ctx.lineTo(x + width - radii[1], y); + ctx.quadraticCurveTo(x + width, y, x + width, y + radii[1]); + ctx.lineTo(x + width, y + height - radii[2]); + ctx.quadraticCurveTo(x + width, y + height, x + width - radii[2], y + height); + ctx.lineTo(x + radii[3], y + height); + ctx.quadraticCurveTo(x, y + height, x, y + height - radii[3]); + ctx.lineTo(x, y + radii[0]); + ctx.quadraticCurveTo(x, y, x + radii[0], y); + ctx.closePath(); + ctx.stroke(); +}; +const fillRoundedRect = (ctx, x, y, width, height, radius) => { + const radii = [0, 0, 0, 0]; + if (typeof radius === "number") + radii.fill(radius); + else + radius.forEach((v, i) => radii[i] = v); + ctx.beginPath(); + ctx.moveTo(x + radii[0], y); + ctx.lineTo(x + width - radii[1], y); + ctx.quadraticCurveTo(x + width, y, x + width, y + radii[1]); + ctx.lineTo(x + width, y + height - radii[2]); + ctx.quadraticCurveTo(x + width, y + height, x + width - radii[2], y + height); + ctx.lineTo(x + radii[3], y + height); + ctx.quadraticCurveTo(x, y + height, x, y + height - radii[3]); + ctx.lineTo(x, y + radii[0]); + ctx.quadraticCurveTo(x, y, x + radii[0], y); + ctx.closePath(); + ctx.fill(); +}; + + +/***/ }), + +/***/ "./src/instantiate.ts": +/*!****************************!*\ + !*** ./src/instantiate.ts ***! + \****************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _FaustUI__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./FaustUI */ "./src/FaustUI.ts"); + +const instantiate = () => { + const faustUI = new _FaustUI__WEBPACK_IMPORTED_MODULE_0__["default"]({ + root: document.getElementById("root"), + listenWindowResize: true, + listenWindowMessage: true + }); + let host; + window.addEventListener("message", (e) => { + const { source } = e; + host = source; + }); + window.addEventListener("keydown", (e) => { + if (host) + host.postMessage({ type: "keydown", key: e.key }, "*"); + }); + window.addEventListener("keyup", (e) => { + if (host) + host.postMessage({ type: "keyup", key: e.key }, "*"); + }); + window.faustUI = faustUI; +}; +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (instantiate); + + +/***/ }), + +/***/ "./src/layout/AbstractGroup.ts": +/*!*************************************!*\ + !*** ./src/layout/AbstractGroup.ts ***! + \*************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ AbstractGroup) +/* harmony export */ }); +const _AbstractGroup = class { + constructor(group, isRoot) { + this.isRoot = !!isRoot; + Object.assign(this, group); + const { hasHSizingDesc, hasVSizingDesc } = this; + const sizing = hasHSizingDesc && hasVSizingDesc ? "both" : hasHSizingDesc ? "horizontal" : hasVSizingDesc ? "vertical" : "none"; + this.layout = { + type: group.type, + width: _AbstractGroup.padding * 2, + height: _AbstractGroup.padding * 2 + (this.isRoot ? 0 : _AbstractGroup.labelHeight), + sizing + }; + } + /** + * find recursively if the group has horizontal-sizable item + */ + get hasHSizingDesc() { + return !!this.items.find((item) => { + if (item instanceof _AbstractGroup) + return item.hasHSizingDesc; + return item.layout.sizing === "horizontal" || item.layout.sizing === "both"; + }); + } + /** + * find recursively if the group has vertical-sizable item + */ + get hasVSizingDesc() { + return !!this.items.find((item) => { + if (item instanceof _AbstractGroup) + return item.hasVSizingDesc; + return item.layout.sizing === "vertical" || item.layout.sizing === "both"; + }); + } + adjust() { + return this; + } + expand(dX, dY) { + return this; + } + offset() { + return this; + } +}; +let AbstractGroup = _AbstractGroup; +AbstractGroup.padding = 0.2; +AbstractGroup.labelHeight = 0.25; +AbstractGroup.spaceBetween = 0.1; + + + +/***/ }), + +/***/ "./src/layout/AbstractInputItem.ts": +/*!*****************************************!*\ + !*** ./src/layout/AbstractInputItem.ts ***! + \*****************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ AbstractInputItem) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/layout/AbstractItem.ts"); + +class AbstractInputItem extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(item) { + super(item); + this.init = +item.init || 0; + this.step = +item.step || 1; + } +} + + +/***/ }), + +/***/ "./src/layout/AbstractItem.ts": +/*!************************************!*\ + !*** ./src/layout/AbstractItem.ts ***! + \************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ AbstractItem) +/* harmony export */ }); +class AbstractItem { + constructor(item) { + Object.assign(this, item); + this.min = isFinite(+this.min) ? +this.min : 0; + this.max = isFinite(+this.max) ? +this.max : 1; + } + adjust() { + return this; + } + expand(dX, dY) { + return this; + } + offset() { + return this; + } +} + + +/***/ }), + +/***/ "./src/layout/AbstractOutputItem.ts": +/*!******************************************!*\ + !*** ./src/layout/AbstractOutputItem.ts ***! + \******************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ AbstractOutputItem) +/* harmony export */ }); +/* harmony import */ var _AbstractItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractItem */ "./src/layout/AbstractItem.ts"); + +class AbstractOutputItem extends _AbstractItem__WEBPACK_IMPORTED_MODULE_0__["default"] { +} + + +/***/ }), + +/***/ "./src/layout/Button.ts": +/*!******************************!*\ + !*** ./src/layout/Button.ts ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Button) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class Button extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "button", + width: 2, + height: 1, + sizing: "horizontal" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Checkbox.ts": +/*!********************************!*\ + !*** ./src/layout/Checkbox.ts ***! + \********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Checkbox) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class Checkbox extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "checkbox", + width: 2, + height: 1, + sizing: "horizontal" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/HBargraph.ts": +/*!*********************************!*\ + !*** ./src/layout/HBargraph.ts ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ HBargraph) +/* harmony export */ }); +/* harmony import */ var _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractOutputItem */ "./src/layout/AbstractOutputItem.ts"); + +class HBargraph extends _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "hbargraph", + width: 5, + height: 1, + sizing: "horizontal" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/HGroup.ts": +/*!******************************!*\ + !*** ./src/layout/HGroup.ts ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ HGroup) +/* harmony export */ }); +/* harmony import */ var _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractGroup */ "./src/layout/AbstractGroup.ts"); + +class HGroup extends _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"] { + adjust() { + this.items.forEach((item) => { + item.adjust(); + this.layout.width += item.layout.width; + this.layout.height = Math.max(this.layout.height, item.layout.height + 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding + (this.isRoot ? 0 : _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].labelHeight)); + }); + this.layout.width += _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].spaceBetween * (this.items.length - 1); + if (this.layout.width < 1) + this.layout.width += 1; + return this; + } + expand(dX) { + let hExpandItems = 0; + this.items.forEach((item) => { + if (item.layout.sizing === "both" || item.layout.sizing === "horizontal") + hExpandItems++; + }); + this.items.forEach((item) => { + let dX$ = 0; + let dY$ = 0; + if (item.layout.sizing === "both" || item.layout.sizing === "horizontal") { + dX$ = hExpandItems ? dX / hExpandItems : 0; + item.layout.width += dX$; + } + if (item.layout.sizing === "both" || item.layout.sizing === "vertical") { + dY$ = this.layout.height - 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding - (this.isRoot ? 0 : _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].labelHeight) - item.layout.height; + item.layout.height += dY$; + } + item.expand(dX$, dY$); + }); + return this; + } + offset() { + const { labelHeight, padding, spaceBetween } = _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"]; + let $left = padding; + const $top = padding + (this.isRoot ? 0 : labelHeight); + const { height } = this.layout; + this.items.forEach((item) => { + item.layout.offsetLeft = $left; + item.layout.offsetTop = $top; + item.layout.offsetTop += (height - (this.isRoot ? 0 : labelHeight) - item.layout.height) / 2 - padding; + item.layout.left = (this.layout.left || 0) + item.layout.offsetLeft; + item.layout.top = (this.layout.top || 0) + item.layout.offsetTop; + item.offset(); + $left += item.layout.width + spaceBetween; + }); + return this; + } +} + + +/***/ }), + +/***/ "./src/layout/HSlider.ts": +/*!*******************************!*\ + !*** ./src/layout/HSlider.ts ***! + \*******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ HSlider) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class HSlider extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "hslider", + width: 5, + height: 1, + sizing: "horizontal" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Knob.ts": +/*!****************************!*\ + !*** ./src/layout/Knob.ts ***! + \****************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Knob) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class Knob extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "knob", + width: 1, + height: 1.75, + sizing: "none" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Layout.ts": +/*!******************************!*\ + !*** ./src/layout/Layout.ts ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Layout) +/* harmony export */ }); +/* harmony import */ var _HSlider__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./HSlider */ "./src/layout/HSlider.ts"); +/* harmony import */ var _VSlider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./VSlider */ "./src/layout/VSlider.ts"); +/* harmony import */ var _Nentry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Nentry */ "./src/layout/Nentry.ts"); +/* harmony import */ var _Soundfile__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Soundfile */ "./src/layout/Soundfile.ts"); +/* harmony import */ var _Button__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Button */ "./src/layout/Button.ts"); +/* harmony import */ var _Checkbox__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./Checkbox */ "./src/layout/Checkbox.ts"); +/* harmony import */ var _Knob__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./Knob */ "./src/layout/Knob.ts"); +/* harmony import */ var _Menu__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./Menu */ "./src/layout/Menu.ts"); +/* harmony import */ var _Radio__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./Radio */ "./src/layout/Radio.ts"); +/* harmony import */ var _Led__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./Led */ "./src/layout/Led.ts"); +/* harmony import */ var _Numerical__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./Numerical */ "./src/layout/Numerical.ts"); +/* harmony import */ var _HBargraph__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./HBargraph */ "./src/layout/HBargraph.ts"); +/* harmony import */ var _VBargraph__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./VBargraph */ "./src/layout/VBargraph.ts"); +/* harmony import */ var _HGroup__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./HGroup */ "./src/layout/HGroup.ts"); +/* harmony import */ var _VGroup__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./VGroup */ "./src/layout/VGroup.ts"); +/* harmony import */ var _TGroup__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./TGroup */ "./src/layout/TGroup.ts"); + + + + + + + + + + + + + + + + +class Layout { + /** + * Get the rendering type of an item by parsing its metadata + */ + static predictType(item) { + if (item.type === "vgroup" || item.type === "hgroup" || item.type === "tgroup" || item.type === "button" || item.type === "checkbox" || item.type === "soundfile") + return item.type; + if (item.type === "hbargraph" || item.type === "vbargraph") { + if (item.meta && item.meta.find((meta) => meta.style && meta.style.startsWith("led"))) + return "led"; + if (item.meta && item.meta.find((meta) => meta.style && meta.style.startsWith("numerical"))) + return "numerical"; + return item.type; + } + if (item.type === "hslider" || item.type === "nentry" || item.type === "vslider") { + if (item.meta && item.meta.find((meta) => meta.style && meta.style.startsWith("knob"))) + return "knob"; + if (item.meta && item.meta.find((meta) => meta.style && meta.style.startsWith("menu"))) + return "menu"; + if (item.meta && item.meta.find((meta) => meta.style && meta.style.startsWith("radio"))) + return "radio"; + } + return item.type; + } + /** + * Get the Layout class constructor of an item + */ + static getItem(item) { + const Ctor = { + hslider: _HSlider__WEBPACK_IMPORTED_MODULE_0__["default"], + vslider: _VSlider__WEBPACK_IMPORTED_MODULE_1__["default"], + nentry: _Nentry__WEBPACK_IMPORTED_MODULE_2__["default"], + soundfile: _Soundfile__WEBPACK_IMPORTED_MODULE_3__["default"], + button: _Button__WEBPACK_IMPORTED_MODULE_4__["default"], + checkbox: _Checkbox__WEBPACK_IMPORTED_MODULE_5__["default"], + knob: _Knob__WEBPACK_IMPORTED_MODULE_6__["default"], + menu: _Menu__WEBPACK_IMPORTED_MODULE_7__["default"], + radio: _Radio__WEBPACK_IMPORTED_MODULE_8__["default"], + led: _Led__WEBPACK_IMPORTED_MODULE_9__["default"], + numerical: _Numerical__WEBPACK_IMPORTED_MODULE_10__["default"], + hbargraph: _HBargraph__WEBPACK_IMPORTED_MODULE_11__["default"], + vbargraph: _VBargraph__WEBPACK_IMPORTED_MODULE_12__["default"], + hgroup: _HGroup__WEBPACK_IMPORTED_MODULE_13__["default"], + vgroup: _VGroup__WEBPACK_IMPORTED_MODULE_14__["default"], + tgroup: _TGroup__WEBPACK_IMPORTED_MODULE_15__["default"] + }; + const layoutType = this.predictType(item); + return new Ctor[layoutType](item); + } + static getItems(items) { + return items.map((item) => { + if ("items" in item) + item.items = this.getItems(item.items); + return this.getItem(item); + }); + } + static calc(ui) { + const rootGroup = new _VGroup__WEBPACK_IMPORTED_MODULE_14__["default"]({ items: this.getItems(ui), type: "vgroup", label: "" }, true); + rootGroup.adjust(); + rootGroup.expand(0, 0); + rootGroup.offset(); + return rootGroup; + } +} + + +/***/ }), + +/***/ "./src/layout/Led.ts": +/*!***************************!*\ + !*** ./src/layout/Led.ts ***! + \***************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Led) +/* harmony export */ }); +/* harmony import */ var _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractOutputItem */ "./src/layout/AbstractOutputItem.ts"); + +class Led extends _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "led", + width: 1, + height: 1, + sizing: "none" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Menu.ts": +/*!****************************!*\ + !*** ./src/layout/Menu.ts ***! + \****************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Menu) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class Menu extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "menu", + width: 2, + height: 1, + sizing: "horizontal" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Nentry.ts": +/*!******************************!*\ + !*** ./src/layout/Nentry.ts ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Nentry) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class Nentry extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "nentry", + width: 1, + height: 1, + sizing: "none" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Numerical.ts": +/*!*********************************!*\ + !*** ./src/layout/Numerical.ts ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Numerical) +/* harmony export */ }); +/* harmony import */ var _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractOutputItem */ "./src/layout/AbstractOutputItem.ts"); + +class Numerical extends _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "numerical", + width: 1, + height: 1, + sizing: "none" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Radio.ts": +/*!*****************************!*\ + !*** ./src/layout/Radio.ts ***! + \*****************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Radio) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class Radio extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "radio", + width: 2, + height: 2, + // TODO: vradio and hradio + sizing: "both" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/Soundfile.ts": +/*!*********************************!*\ + !*** ./src/layout/Soundfile.ts ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ Soundfile) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class Soundfile extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "soundfile", + width: 2, + height: 1, + sizing: "horizontal" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/TGroup.ts": +/*!******************************!*\ + !*** ./src/layout/TGroup.ts ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ TGroup) +/* harmony export */ }); +/* harmony import */ var _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractGroup */ "./src/layout/AbstractGroup.ts"); + +const _TGroup = class extends _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"] { + adjust() { + this.items.forEach((item) => { + item.adjust(); + this.layout.width = Math.max(this.layout.width, item.layout.width + 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding); + this.layout.height = Math.max(this.layout.height, item.layout.height + 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding + _TGroup.labelHeight); + }); + const tabsCount = this.items.length; + this.layout.width = Math.max(this.layout.width, tabsCount * _TGroup.tabLayout.width); + this.layout.height += _TGroup.tabLayout.height; + if (this.layout.width < 1) + this.layout.width += 1; + return this; + } + expand() { + const tabsCount = this.items.length; + this.items.forEach((item) => { + let dY$ = 0; + let dX$ = 0; + if (item.layout.sizing === "both" || item.layout.sizing === "horizontal") + dX$ = this.layout.width - 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding - item.layout.width; + if (item.layout.sizing === "both" || item.layout.sizing === "vertical") + dY$ = this.layout.height - 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding - (this.isRoot ? 0 : _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].labelHeight) - (tabsCount ? _TGroup.tabLayout.height : 0) - item.layout.height; + item.expand(dX$, dY$); + }); + return this; + } + offset() { + const { labelHeight, padding } = _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"]; + const $left = padding; + const $top = padding + (this.isRoot ? 0 : labelHeight) + _TGroup.tabLayout.height; + this.items.forEach((item) => { + item.layout.offsetLeft = $left; + item.layout.offsetTop = $top; + item.layout.left = (this.layout.left || 0) + item.layout.offsetLeft; + item.layout.top = (this.layout.top || 0) + item.layout.offsetTop; + item.offset(); + }); + return this; + } +}; +let TGroup = _TGroup; +TGroup.tabLayout = { + width: 2, + height: 1 +}; + + + +/***/ }), + +/***/ "./src/layout/VBargraph.ts": +/*!*********************************!*\ + !*** ./src/layout/VBargraph.ts ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ VBargraph) +/* harmony export */ }); +/* harmony import */ var _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractOutputItem */ "./src/layout/AbstractOutputItem.ts"); + +class VBargraph extends _AbstractOutputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "vbargraph", + width: 1, + height: 5, + sizing: "vertical" + }; + } +} + + +/***/ }), + +/***/ "./src/layout/VGroup.ts": +/*!******************************!*\ + !*** ./src/layout/VGroup.ts ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ VGroup) +/* harmony export */ }); +/* harmony import */ var _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractGroup */ "./src/layout/AbstractGroup.ts"); + +class VGroup extends _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"] { + adjust() { + this.items.forEach((item) => { + item.adjust(); + this.layout.width = Math.max(this.layout.width, item.layout.width + 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding); + this.layout.height += item.layout.height; + }); + this.layout.height += _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].spaceBetween * (this.items.length - 1); + if (this.layout.width < 1) + this.layout.width += 1; + return this; + } + expand(dX, dY) { + let vExpandItems = 0; + this.items.forEach((item) => { + if (item.layout.sizing === "both" || item.layout.sizing === "vertical") + vExpandItems++; + }); + this.items.forEach((item) => { + let dX$ = 0; + let dY$ = 0; + if (item.layout.sizing === "both" || item.layout.sizing === "horizontal") { + dX$ = this.layout.width - 2 * _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"].padding - item.layout.width; + item.layout.width += dX$; + } + if (item.layout.sizing === "both" || item.layout.sizing === "vertical") { + dY$ = vExpandItems ? dY / vExpandItems : 0; + item.layout.height += dY$; + } + item.expand(dX$, dY$); + }); + return this; + } + offset() { + const { labelHeight, padding, spaceBetween } = _AbstractGroup__WEBPACK_IMPORTED_MODULE_0__["default"]; + const $left = padding; + let $top = padding + (this.isRoot ? 0 : labelHeight); + const { width } = this.layout; + this.items.forEach((item) => { + item.layout.offsetLeft = $left; + item.layout.offsetTop = $top; + item.layout.offsetLeft += (width - item.layout.width) / 2 - padding; + item.layout.left = (this.layout.left || 0) + item.layout.offsetLeft; + item.layout.top = (this.layout.top || 0) + item.layout.offsetTop; + item.offset(); + $top += item.layout.height + spaceBetween; + }); + return this; + } +} + + +/***/ }), + +/***/ "./src/layout/VSlider.ts": +/*!*******************************!*\ + !*** ./src/layout/VSlider.ts ***! + \*******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ VSlider) +/* harmony export */ }); +/* harmony import */ var _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbstractInputItem */ "./src/layout/AbstractInputItem.ts"); + +class VSlider extends _AbstractInputItem__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(...arguments); + this.layout = { + type: "vslider", + width: 1, + height: 5, + sizing: "vertical" + }; + } +} + + +/***/ }), + +/***/ "./src/components/Base.scss": +/*!**********************************!*\ + !*** ./src/components/Base.scss ***! + \**********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Base_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Base.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Base.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Base_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Base_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Base_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Base_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Button.scss": +/*!************************************!*\ + !*** ./src/components/Button.scss ***! + \************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Button_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Button.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Button.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Button_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Button_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Button_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Button_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Checkbox.scss": +/*!**************************************!*\ + !*** ./src/components/Checkbox.scss ***! + \**************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Checkbox_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Checkbox.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Checkbox.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Checkbox_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Checkbox_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Checkbox_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Checkbox_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Group.scss": +/*!***********************************!*\ + !*** ./src/components/Group.scss ***! + \***********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Group_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Group.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Group.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Group_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Group_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Group_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Group_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/HBargraph.scss": +/*!***************************************!*\ + !*** ./src/components/HBargraph.scss ***! + \***************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HBargraph_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./HBargraph.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/HBargraph.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/HSlider.scss": +/*!*************************************!*\ + !*** ./src/components/HSlider.scss ***! + \*************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HSlider_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./HSlider.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/HSlider.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_HSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Knob.scss": +/*!**********************************!*\ + !*** ./src/components/Knob.scss ***! + \**********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Knob_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Knob.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Knob.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Knob_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Knob_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Knob_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Knob_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Led.scss": +/*!*********************************!*\ + !*** ./src/components/Led.scss ***! + \*********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Led_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Led.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Led.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Led_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Led_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Led_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Led_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Menu.scss": +/*!**********************************!*\ + !*** ./src/components/Menu.scss ***! + \**********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Menu_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Menu.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Menu.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Menu_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Menu_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Menu_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Menu_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Nentry.scss": +/*!************************************!*\ + !*** ./src/components/Nentry.scss ***! + \************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Nentry_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Nentry.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Nentry.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Nentry_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Nentry_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Nentry_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Nentry_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Numerical.scss": +/*!***************************************!*\ + !*** ./src/components/Numerical.scss ***! + \***************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Numerical_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Numerical.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Numerical.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Numerical_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Numerical_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Numerical_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Numerical_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Radio.scss": +/*!***********************************!*\ + !*** ./src/components/Radio.scss ***! + \***********************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Radio_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Radio.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Radio.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Radio_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Radio_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Radio_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Radio_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/Soundfile.scss": +/*!***************************************!*\ + !*** ./src/components/Soundfile.scss ***! + \***************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Soundfile_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Soundfile.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/Soundfile.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Soundfile_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Soundfile_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Soundfile_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_Soundfile_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/VBargraph.scss": +/*!***************************************!*\ + !*** ./src/components/VBargraph.scss ***! + \***************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VBargraph_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./VBargraph.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/VBargraph.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VBargraph_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/components/VSlider.scss": +/*!*************************************!*\ + !*** ./src/components/VSlider.scss ***! + \*************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VSlider_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./VSlider.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/components/VSlider.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_VSlider_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./src/index.scss": +/*!************************!*\ + !*** ./src/index.scss ***! + \************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../node_modules/style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../node_modules/style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../node_modules/style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../node_modules/style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"); +/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_index_scss__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../node_modules/css-loader/dist/cjs.js!../node_modules/sass-loader/dist/cjs.js!./index.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/index.scss"); + + + + + + + + + + + +var options = {}; + +options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default()); +options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default()); + + options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head"); + +options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default()); +options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default()); + +var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_index_scss__WEBPACK_IMPORTED_MODULE_6__["default"], options); + + + + + /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_index_scss__WEBPACK_IMPORTED_MODULE_6__["default"] && _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_index_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _node_modules_css_loader_dist_cjs_js_node_modules_sass_loader_dist_cjs_js_index_scss__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined); + + +/***/ }), + +/***/ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js": +/*!****************************************************************************!*\ + !*** ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js ***! + \****************************************************************************/ +/***/ ((module) => { + + + +var stylesInDOM = []; +function getIndexByIdentifier(identifier) { + var result = -1; + for (var i = 0; i < stylesInDOM.length; i++) { + if (stylesInDOM[i].identifier === identifier) { + result = i; + break; + } + } + return result; +} +function modulesToDom(list, options) { + var idCountMap = {}; + var identifiers = []; + for (var i = 0; i < list.length; i++) { + var item = list[i]; + var id = options.base ? item[0] + options.base : item[0]; + var count = idCountMap[id] || 0; + var identifier = "".concat(id, " ").concat(count); + idCountMap[id] = count + 1; + var indexByIdentifier = getIndexByIdentifier(identifier); + var obj = { + css: item[1], + media: item[2], + sourceMap: item[3], + supports: item[4], + layer: item[5] + }; + if (indexByIdentifier !== -1) { + stylesInDOM[indexByIdentifier].references++; + stylesInDOM[indexByIdentifier].updater(obj); + } else { + var updater = addElementStyle(obj, options); + options.byIndex = i; + stylesInDOM.splice(i, 0, { + identifier: identifier, + updater: updater, + references: 1 + }); + } + identifiers.push(identifier); + } + return identifiers; +} +function addElementStyle(obj, options) { + var api = options.domAPI(options); + api.update(obj); + var updater = function updater(newObj) { + if (newObj) { + if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) { + return; + } + api.update(obj = newObj); + } else { + api.remove(); + } + }; + return updater; +} +module.exports = function (list, options) { + options = options || {}; + list = list || []; + var lastIdentifiers = modulesToDom(list, options); + return function update(newList) { + newList = newList || []; + for (var i = 0; i < lastIdentifiers.length; i++) { + var identifier = lastIdentifiers[i]; + var index = getIndexByIdentifier(identifier); + stylesInDOM[index].references--; + } + var newLastIdentifiers = modulesToDom(newList, options); + for (var _i = 0; _i < lastIdentifiers.length; _i++) { + var _identifier = lastIdentifiers[_i]; + var _index = getIndexByIdentifier(_identifier); + if (stylesInDOM[_index].references === 0) { + stylesInDOM[_index].updater(); + stylesInDOM.splice(_index, 1); + } + } + lastIdentifiers = newLastIdentifiers; + }; +}; + +/***/ }), + +/***/ "./node_modules/style-loader/dist/runtime/insertBySelector.js": +/*!********************************************************************!*\ + !*** ./node_modules/style-loader/dist/runtime/insertBySelector.js ***! + \********************************************************************/ +/***/ ((module) => { + + + +var memo = {}; + +/* istanbul ignore next */ +function getTarget(target) { + if (typeof memo[target] === "undefined") { + var styleTarget = document.querySelector(target); + + // Special case to return head of iframe instead of iframe itself + if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) { + try { + // This will throw an exception if access to iframe is blocked + // due to cross-origin restrictions + styleTarget = styleTarget.contentDocument.head; + } catch (e) { + // istanbul ignore next + styleTarget = null; + } + } + memo[target] = styleTarget; + } + return memo[target]; +} + +/* istanbul ignore next */ +function insertBySelector(insert, style) { + var target = getTarget(insert); + if (!target) { + throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid."); + } + target.appendChild(style); +} +module.exports = insertBySelector; + +/***/ }), + +/***/ "./node_modules/style-loader/dist/runtime/insertStyleElement.js": +/*!**********************************************************************!*\ + !*** ./node_modules/style-loader/dist/runtime/insertStyleElement.js ***! + \**********************************************************************/ +/***/ ((module) => { + + + +/* istanbul ignore next */ +function insertStyleElement(options) { + var element = document.createElement("style"); + options.setAttributes(element, options.attributes); + options.insert(element, options.options); + return element; +} +module.exports = insertStyleElement; + +/***/ }), + +/***/ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js": +/*!**********************************************************************************!*\ + !*** ./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js ***! + \**********************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + + + +/* istanbul ignore next */ +function setAttributesWithoutAttributes(styleElement) { + var nonce = true ? __webpack_require__.nc : 0; + if (nonce) { + styleElement.setAttribute("nonce", nonce); + } +} +module.exports = setAttributesWithoutAttributes; + +/***/ }), + +/***/ "./node_modules/style-loader/dist/runtime/styleDomAPI.js": +/*!***************************************************************!*\ + !*** ./node_modules/style-loader/dist/runtime/styleDomAPI.js ***! + \***************************************************************/ +/***/ ((module) => { + + + +/* istanbul ignore next */ +function apply(styleElement, options, obj) { + var css = ""; + if (obj.supports) { + css += "@supports (".concat(obj.supports, ") {"); + } + if (obj.media) { + css += "@media ".concat(obj.media, " {"); + } + var needLayer = typeof obj.layer !== "undefined"; + if (needLayer) { + css += "@layer".concat(obj.layer.length > 0 ? " ".concat(obj.layer) : "", " {"); + } + css += obj.css; + if (needLayer) { + css += "}"; + } + if (obj.media) { + css += "}"; + } + if (obj.supports) { + css += "}"; + } + var sourceMap = obj.sourceMap; + if (sourceMap && typeof btoa !== "undefined") { + css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */"); + } + + // For old IE + /* istanbul ignore if */ + options.styleTagTransform(css, styleElement, options.options); +} +function removeStyleElement(styleElement) { + // istanbul ignore if + if (styleElement.parentNode === null) { + return false; + } + styleElement.parentNode.removeChild(styleElement); +} + +/* istanbul ignore next */ +function domAPI(options) { + if (typeof document === "undefined") { + return { + update: function update() {}, + remove: function remove() {} + }; + } + var styleElement = options.insertStyleElement(options); + return { + update: function update(obj) { + apply(styleElement, options, obj); + }, + remove: function remove() { + removeStyleElement(styleElement); + } + }; +} +module.exports = domAPI; + +/***/ }), + +/***/ "./node_modules/style-loader/dist/runtime/styleTagTransform.js": +/*!*********************************************************************!*\ + !*** ./node_modules/style-loader/dist/runtime/styleTagTransform.js ***! + \*********************************************************************/ +/***/ ((module) => { + + + +/* istanbul ignore next */ +function styleTagTransform(css, styleElement) { + if (styleElement.styleSheet) { + styleElement.styleSheet.cssText = css; + } else { + while (styleElement.firstChild) { + styleElement.removeChild(styleElement.firstChild); + } + styleElement.appendChild(document.createTextNode(css)); + } +} +module.exports = styleTagTransform; + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ id: moduleId, +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/compat get default export */ +/******/ (() => { +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = (module) => { +/******/ var getter = module && module.__esModule ? +/******/ () => (module['default']) : +/******/ () => (module); +/******/ __webpack_require__.d(getter, { a: getter }); +/******/ return getter; +/******/ }; +/******/ })(); +/******/ +/******/ /* webpack/runtime/define property getters */ +/******/ (() => { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = (exports, definition) => { +/******/ for(var key in definition) { +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ })(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ (() => { +/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) +/******/ })(); +/******/ +/******/ /* webpack/runtime/make namespace object */ +/******/ (() => { +/******/ // define __esModule on exports +/******/ __webpack_require__.r = (exports) => { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ })(); +/******/ +/******/ /* webpack/runtime/nonce */ +/******/ (() => { +/******/ __webpack_require__.nc = undefined; +/******/ })(); +/******/ +/************************************************************************/ +var __webpack_exports__ = {}; +// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk. +(() => { +/*!**********************!*\ + !*** ./src/index.ts ***! + \**********************/ +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ FaustUI: () => (/* reexport safe */ _FaustUI__WEBPACK_IMPORTED_MODULE_0__["default"]), +/* harmony export */ instantiate: () => (/* reexport safe */ _instantiate__WEBPACK_IMPORTED_MODULE_1__["default"]) +/* harmony export */ }); +/* harmony import */ var _FaustUI__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./FaustUI */ "./src/FaustUI.ts"); +/* harmony import */ var _instantiate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./instantiate */ "./src/instantiate.ts"); + + + +})(); + +/******/ return __webpack_exports__; +/******/ })() +; +}); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/dist/faust-ui/index.js.map b/dist/faust-ui/index.js.map new file mode 100644 index 00000000..d685b992 --- /dev/null +++ b/dist/faust-ui/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;;;;;;;;;;ACVa;AACb,8CAA6C,EAAE,aAAa,EAAC;AAC7D,yBAAyB,GAAG,qBAAqB;AACjD,qBAAqB;AACrB;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA,wBAAwB,sBAAsB;AAC9C;AACA;AACA;AACA,wBAAwB,yBAAyB;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB,kBAAe;AACf;;;;;;;;;;;;;;;;;;AC1GA;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,2FAA2F,UAAU,WAAW,WAAW,WAAW,KAAK,KAAK,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,WAAW,KAAK,KAAK,WAAW,UAAU,UAAU,WAAW,KAAK,KAAK,WAAW,8CAA8C,oBAAoB,yBAAyB,6BAA6B,uBAAuB,eAAe,wBAAwB,OAAO,qCAAqC,6BAA6B,0BAA0B,sBAAsB,4BAA4B,sBAAsB,iCAAiC,6BAA6B,8BAA8B,+BAA+B,WAAW,OAAO,eAAe,2BAA2B,OAAO,GAAG,mBAAmB;AACp1B;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;AC9BvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,6FAA6F,UAAU,WAAW,UAAU,WAAW,WAAW,WAAW,UAAU,WAAW,KAAK,KAAK,WAAW,UAAU,wEAAwE,eAAe,wBAAwB,6BAA6B,0BAA0B,4BAA4B,6BAA6B,6BAA6B,yBAAyB,8BAA8B,oBAAoB,gCAAgC,2BAA2B,WAAW,OAAO,GAAG,mBAAmB;AACnoB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACpBvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,+FAA+F,UAAU,WAAW,UAAU,WAAW,WAAW,WAAW,UAAU,WAAW,KAAK,KAAK,UAAU,WAAW,0EAA0E,eAAe,wBAAwB,6BAA6B,0BAA0B,4BAA4B,6BAA6B,6BAA6B,yBAAyB,8BAA8B,oBAAoB,2BAA2B,gCAAgC,WAAW,OAAO,GAAG,mBAAmB;AACvoB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACpBvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,4FAA4F,WAAW,UAAU,WAAW,WAAW,WAAW,KAAK,KAAK,WAAW,UAAU,WAAW,WAAW,KAAK,KAAK,WAAW,UAAU,UAAU,WAAW,KAAK,KAAK,WAAW,WAAW,WAAW,UAAU,KAAK,KAAK,WAAW,WAAW,WAAW,UAAU,WAAW,WAAW,WAAW,UAAU,WAAW,WAAW,KAAK,KAAK,WAAW,MAAM,KAAK,WAAW,UAAU,6CAA6C,yBAAyB,qBAAqB,+CAA+C,yBAAyB,kDAAkD,iCAAiC,6BAA6B,sBAAsB,kCAAkC,4BAA4B,sBAAsB,iCAAiC,6BAA6B,8BAA8B,+BAA+B,WAAW,OAAO,+BAA+B,6BAA6B,gCAAgC,8BAA8B,oBAAoB,kCAAkC,iCAAiC,oCAAoC,iCAAiC,8BAA8B,sCAAsC,kCAAkC,gCAAgC,2BAA2B,iCAAiC,yDAAyD,uBAAuB,2DAA2D,eAAe,wBAAwB,wDAAwD,+BAA+B,eAAe,WAAW,OAAO,GAAG,mBAAmB;AACrwD;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;AClDvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,gGAAgG,UAAU,KAAK,KAAK,WAAW,UAAU,WAAW,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,MAAM,KAAK,WAAW,UAAU,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,WAAW,WAAW,2EAA2E,qCAAqC,yBAAyB,OAAO,iDAAiD,6BAA6B,wBAAwB,sCAAsC,yBAAyB,sBAAsB,uBAAuB,uDAAuD,iCAAiC,6BAA6B,6BAA6B,2BAA2B,2BAA2B,0BAA0B,qCAAqC,iCAAiC,+BAA+B,8BAA8B,eAAe,WAAW,qBAAqB,iCAAiC,6BAA6B,6BAA6B,iCAAiC,0DAA0D,yCAAyC,gCAAgC,iCAAiC,sCAAsC,+BAA+B,WAAW,OAAO,GAAG,mBAAmB;AACpiD;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;AC1CvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,8FAA8F,UAAU,KAAK,KAAK,WAAW,UAAU,WAAW,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,MAAM,KAAK,WAAW,UAAU,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,WAAW,WAAW,WAAW,KAAK,KAAK,WAAW,UAAU,0EAA0E,qCAAqC,yBAAyB,OAAO,+CAA+C,6BAA6B,wBAAwB,sCAAsC,yBAAyB,sBAAsB,uBAAuB,qDAAqD,iCAAiC,6BAA6B,6BAA6B,2BAA2B,2BAA2B,0BAA0B,qCAAqC,iCAAiC,+BAA+B,8BAA8B,eAAe,WAAW,qBAAqB,iCAAiC,6BAA6B,6BAA6B,iCAAiC,0DAA0D,yCAAyC,gCAAgC,iCAAiC,sCAAsC,+BAA+B,wCAAwC,wFAAwF,2CAA2C,4BAA4B,eAAe,WAAW,OAAO,GAAG,qBAAqB;AAC/xD;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;AC/CvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,2FAA2F,WAAW,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,WAAW,WAAW,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,KAAK,KAAK,WAAW,UAAU,sEAAsE,0BAA0B,kBAAkB,6BAA6B,yBAAyB,yBAAyB,0BAA0B,sBAAsB,OAAO,iBAAiB,6BAA6B,yBAAyB,yBAAyB,6BAA6B,sDAAsD,sBAAsB,4BAA4B,6BAA6B,sCAAsC,2BAA2B,oCAAoC,gFAAgF,uCAAuC,wBAAwB,WAAW,OAAO,GAAG,mBAAmB;AAChmC;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACjCvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,0FAA0F,WAAW,KAAK,KAAK,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,qEAAqE,0BAA0B,qCAAqC,yBAAyB,OAAO,6CAA6C,6BAA6B,yBAAyB,yBAAyB,sBAAsB,sBAAsB,iCAAiC,6BAA6B,2BAA2B,0BAA0B,WAAW,OAAO,GAAG,qBAAqB;AAChtB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACxBvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,2FAA2F,WAAW,KAAK,KAAK,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,sEAAsE,0BAA0B,kBAAkB,sBAAsB,6BAA6B,4BAA4B,6BAA6B,2BAA2B,kCAAkC,OAAO,GAAG,mBAAmB;AACjf;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACjBvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,6FAA6F,WAAW,KAAK,KAAK,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,KAAK,KAAK,UAAU,wEAAwE,0BAA0B,eAAe,sBAAsB,6BAA6B,4BAA4B,6BAA6B,2BAA2B,kCAAkC,gFAAgF,yBAAyB,WAAW,OAAO,GAAG,mBAAmB;AAC1nB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACpBvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,gGAAgG,WAAW,KAAK,KAAK,WAAW,UAAU,UAAU,WAAW,WAAW,UAAU,WAAW,WAAW,WAAW,WAAW,2EAA2E,0BAA0B,iBAAiB,6BAA6B,yBAAyB,yBAAyB,6BAA6B,sDAAsD,uBAAuB,4BAA4B,6BAA6B,kCAAkC,2BAA2B,OAAO,GAAG,mBAAmB;AAC1qB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACrBvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,4FAA4F,WAAW,KAAK,KAAK,UAAU,WAAW,KAAK,KAAK,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,KAAK,KAAK,WAAW,WAAW,WAAW,uEAAuE,0BAA0B,qCAAqC,yBAAyB,2BAA2B,OAAO,2CAA2C,yBAAyB,8BAA8B,4BAA4B,6BAA6B,2BAA2B,kCAAkC,mBAAmB,sCAAsC,kCAAkC,+BAA+B,WAAW,OAAO,GAAG,mBAAmB;AAC/zB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;AC1BvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,gGAAgG,UAAU,WAAW,UAAU,WAAW,WAAW,WAAW,UAAU,WAAW,KAAK,KAAK,WAAW,UAAU,2EAA2E,eAAe,wBAAwB,6BAA6B,0BAA0B,4BAA4B,6BAA6B,6BAA6B,yBAAyB,8BAA8B,oBAAoB,gCAAgC,2BAA2B,WAAW,OAAO,GAAG,mBAAmB;AACzoB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACpBvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,gGAAgG,WAAW,KAAK,KAAK,UAAU,KAAK,KAAK,WAAW,UAAU,WAAW,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,MAAM,KAAK,WAAW,UAAU,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,UAAU,WAAW,WAAW,2EAA2E,0BAA0B,qCAAqC,yBAAyB,OAAO,iDAAiD,6BAA6B,wBAAwB,iCAAiC,yBAAyB,sBAAsB,0BAA0B,uDAAuD,iCAAiC,6BAA6B,6BAA6B,0BAA0B,0BAA0B,qCAAqC,iCAAiC,+BAA+B,8BAA8B,eAAe,WAAW,qBAAqB,iCAAiC,6BAA6B,6BAA6B,iCAAiC,0DAA0D,yCAAyC,gCAAgC,iCAAiC,yBAAyB,sCAAsC,+BAA+B,WAAW,OAAO,GAAG,qBAAqB;AAChlD;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;AC7CvC;AAC6G;AACjB;AAC5F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,8FAA8F,WAAW,KAAK,KAAK,UAAU,KAAK,KAAK,WAAW,UAAU,WAAW,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,KAAK,KAAK,WAAW,UAAU,UAAU,UAAU,MAAM,KAAK,WAAW,UAAU,UAAU,WAAW,WAAW,WAAW,WAAW,WAAW,UAAU,WAAW,WAAW,WAAW,KAAK,KAAK,WAAW,UAAU,0EAA0E,0BAA0B,qCAAqC,yBAAyB,OAAO,+CAA+C,6BAA6B,wBAAwB,iCAAiC,yBAAyB,sBAAsB,uBAAuB,qDAAqD,iCAAiC,6BAA6B,6BAA6B,0BAA0B,0BAA0B,qCAAqC,iCAAiC,+BAA+B,8BAA8B,eAAe,WAAW,mBAAmB,iCAAiC,6BAA6B,6BAA6B,iCAAiC,0DAA0D,yCAAyC,gCAAgC,iCAAiC,yBAAyB,0CAA0C,+BAA+B,wCAAwC,wFAAwF,2CAA2C,4BAA4B,eAAe,WAAW,OAAO,GAAG,mBAAmB;AACt0D;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;AClDvC;AAC0G;AACjB;AACzF,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,iFAAiF,WAAW,UAAU,WAAW,WAAW,WAAW,WAAW,yCAAyC,uBAAuB,qBAAqB,oCAAoC,+CAA+C,8BAA8B,uNAAuN,GAAG,mBAAmB;AAC7kB;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;ACd1B;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA,gDAAgD;AAChD;AACA;AACA,qFAAqF;AACrF;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,iBAAiB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,qBAAqB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,sFAAsF,qBAAqB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,iDAAiD,qBAAqB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,sDAAsD,qBAAqB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACpFa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,cAAc;AACrE;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACdqC;AAEE;AAGjB;AAeP,MAAM,QAAQ;AAAA;AAAA;AAAA;AAAA,EAWzB,YAAY,SAAmB;AAV/B,wBAAwD,CAAC;AA4EzD;AAAA;AAAA;AAAA,2BAAkB,CAAC,MAAc,UAAkB;AAC/C,UAAI,CAAC,KAAK;AAAY;AACtB,WAAK,WAAW,YAAY,EAAE,MAAM,OAAO,MAAM,QAAQ,GAAG,GAAG;AAAA,IACnE;AApEI,UAAM,EAAE,MAAM,IAAI,MAAM,oBAAoB,oBAAoB,IAAI;AACpE,SAAK,UAAU;AACf,SAAK,KAAK,QAAQ,CAAC;AACnB,QAAI,OAAO,uBAAuB,eAAe,uBAAuB,MAAM;AAC1E,aAAO,iBAAiB,UAAU,MAAM;AACpC,aAAK,OAAO;AAAA,MAChB,CAAC;AAAA,IACL;AACA,QAAI,OAAO,wBAAwB,eAAe,wBAAwB,MAAM;AAC5E,aAAO,iBAAiB,WAAW,CAAC,MAAM;AACtC,cAAM,EAAE,MAAM,OAAO,IAAI;AACzB,aAAK,aAAa;AAClB,cAAM,EAAE,KAAK,IAAI;AACjB,YAAI,CAAC;AAAM;AACX,YAAI,SAAS,MAAM;AACf,eAAK,KAAK,KAAK;AAAA,QACnB,WAAW,SAAS,SAAS;AACzB,gBAAM,EAAE,MAAM,MAAM,IAAI;AACxB,eAAK,iBAAiB,MAAM,KAAK;AAAA,QACrC;AAAA,MACJ,CAAC;AAAA,IACL;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA,EAIA,QAAQ;AACJ,SAAK,eAAe,CAAC;AACrB,SAAK,QAAQ,YAAY;AACzB,UAAM,QAA2B;AAAA,MAC7B,OAAO;AAAA,MACP,MAAM;AAAA,MACN,OAAO,KAAK;AAAA,MACZ,OAAO;AAAA,QACH,MAAM,KAAK;AAAA,QACX,OAAO,KAAK,OAAO;AAAA,QACnB,QAAQ,KAAK,OAAO;AAAA,QACpB,MAAM,KAAK,OAAO;AAAA,QAClB,KAAK,KAAK,OAAO;AAAA,MACrB;AAAA,MACA,QAAQ;AAAA,MACR,SAAS;AAAA,IACb;AACA,SAAK,cAAc,IAAI,yDAAK,CAAC,KAAK;AAClC,SAAK,YAAY,mBAAmB;AACpC,SAAK,YAAY,MAAM;AACvB,SAAK,QAAQ,YAAY,KAAK,YAAY,SAAS;AACnD,SAAK,YAAY,kBAAkB;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA,EAIA,SAAS,MAAc,MAAyB;AAC5C,QAAI,KAAK,aAAa,IAAI;AAAG,WAAK,aAAa,IAAI,EAAE,KAAK,IAAI;AAAA;AACzD,WAAK,aAAa,IAAI,IAAI,CAAC,IAAI;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA,EAIA,iBAAiB,MAAc,OAAe;AAC1C,QAAI,KAAK,aAAa,IAAI;AAAG,WAAK,aAAa,IAAI,EAAE,QAAQ,UAAQ,KAAK,SAAS,EAAE,MAAM,CAAC,CAAC;AAAA,EACjG;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO;AACH,UAAM,EAAE,OAAO,OAAO,IAAI,sDAAM,CAAC,KAAK,KAAK,EAAE;AAC7C,SAAK,MAAM;AACX,SAAK,UAAU;AACf,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAIA,WAAW;AACP,UAAM,EAAE,OAAO,OAAO,IAAI,KAAK,QAAQ,sBAAsB;AAC7D,UAAM,OAAO,KAAK,IAAI,IAAI,KAAK,IAAI,QAAQ,KAAK,QAAQ,OAAO,SAAS,KAAK,QAAQ,MAAM,CAAC;AAC5F,SAAK,OAAO;AACZ,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAIA,SAAS;AACL,QAAI,CAAC,KAAK;AAAa;AACvB,SAAK,SAAS;AACd,SAAK,YAAY,SAAS,EAAE,OAAO,EAAE,MAAM,KAAK,KAAK,EAAE,CAAC;AAAA,EAC5D;AAAA,EACA,IAAI,KAAK;AACL,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,IAAI,GAAG,MAAM;AACT,SAAK,MAAM;AACX,SAAK,KAAK;AACV,SAAK,MAAM;AAAA,EACf;AAAA,EACA,IAAI,SAAS;AACT,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,IAAI,WAAW;AACX,WAAO,KAAK,QAAQ,QAAQ,KAAK;AAAA,EACrC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,QAAQ,SAAS,KAAK;AAAA,EACtC;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACjJ2D;AAE5C,MAAe,0BAA6D,kEAAiB,CAAI;AAAA;AAAA;AAAA;AAAA,EA+C5G,YAAY,OAAW;AACnB,UAAM;AA/BV;AAAA;AAAA;AAAA,SAAQ,SAAS;AAIjB;AAAA;AAAA;AAAA,uBAAc;AASd;AAAA;AAAA;AAAA,SAAQ,MAAM,MAAM;AAChB,WAAK;AACL,UAAI,KAAK,SAAS,KAAK,gBAAgB,GAAG;AACtC,aAAK,OAAO,OAAO,sBAAsB,KAAK,GAAG;AACjD;AAAA,MACJ;AACA,WAAK,OAAO;AACZ,WAAK,MAAM,QAAQ,OAAK,EAAE,CAAC;AAC3B,WAAK,QAAQ,CAAC;AAAA,IAClB;AAIA;AAAA;AAAA;AAAA,SAAQ,QAAuB,CAAC;AAM5B,SAAK,QAAQ,kCAAK,KAAK,eAAiB;AAAA,EAC5C;AAAA,EA7CA,IAAI,eAAe;AACf,WAAQ,KAAK,YAAyC;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA,EA+CA,SAAS,UAAsB;AAC3B,QAAI,eAAe;AACnB,eAAW,YAAY,UAAU;AAC7B,YAAM,aAAa,SAAS,QAAQ;AACpC,UAAI,YAAY,KAAK,SAAS,KAAK,MAAM,QAAQ,MAAM,YAAY;AAC/D,aAAK,MAAM,QAAQ,IAAI;AACvB,uBAAe;AAAA,MACnB;AAAO;AACP,UAAI;AAAc,aAAK,KAAK,UAAU,KAAK,MAAM,QAAQ,CAAC;AAAA,IAC9D;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,MAAiB;AACtB,QAAI,KAAK,MAAM,QAAQ,IAAI,MAAM;AAAI,WAAK,MAAM,KAAK,IAAI;AACzD,QAAI,KAAK;AAAM;AACf,SAAK,OAAO,OAAO,sBAAsB,KAAK,GAAG;AAAA,EACrD;AACJ;AAAA;AAAA;AAAA;AA1E8B,kBAInB,eAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACNI;AACE;AAEjC;AAcrB,MAA8B,gBAA9B,cAA+E,0DAAiB,CAAsB;AAAA;AAAA;AAAA;AAAA,EAkHlH,YAAY,OAA6B;AACrC,UAAM,KAAK;AA/Ef,uBAAc;AAKd;AAAA;AAAA;AAAA;AAAA,yBAAgB,CAAC,MAAqB;AAAA,IAAC;AACvC,uBAAc,CAAC,MAAqB;AAAA,IAAC;AACrC,4BAAmB,CAAC,MAAkB;AAClC,QAAE,eAAe;AACjB,YAAM,OAAQ,EAAE,cAA8B,sBAAsB;AACpE,UAAI,QAAQ,EAAE,QAAQ,CAAC,EAAE;AACzB,UAAI,QAAQ,EAAE,QAAQ,CAAC,EAAE;AACzB,YAAM,QAAQ,QAAQ,KAAK;AAC3B,YAAM,QAAQ,QAAQ,KAAK;AAC3B,YAAM,YAAY,KAAK,MAAM;AAC7B,WAAK,kBAAkB,EAAE,GAAG,OAAO,GAAG,OAAO,eAAe,EAAE,CAAC;AAC/D,YAAM,kBAAkB,CAACA,OAAkB;AACvC,QAAAA,GAAE,eAAe;AACjB,cAAM,UAAUA,GAAE,eAAe,CAAC,EAAE;AACpC,cAAM,UAAUA,GAAE,eAAe,CAAC,EAAE;AACpC,cAAM,YAAY,UAAU;AAC5B,cAAM,YAAY,UAAU;AAC5B,gBAAQ;AACR,gBAAQ;AACR,cAAM,IAAI,UAAU,KAAK;AACzB,cAAM,IAAI,UAAU,KAAK;AACzB,aAAK,kBAAkB,EAAE,WAAW,GAAG,GAAG,OAAO,OAAO,WAAW,WAAW,eAAeA,GAAE,CAAC;AAAA,MACpG;AACA,YAAM,iBAAiB,CAACA,OAAkB;AACtC,QAAAA,GAAE,eAAe;AACjB,cAAM,IAAIA,GAAE,eAAe,CAAC,EAAE,UAAU,KAAK;AAC7C,cAAM,IAAIA,GAAE,eAAe,CAAC,EAAE,UAAU,KAAK;AAC7C,aAAK,gBAAgB,EAAE,GAAG,GAAG,eAAeA,GAAE,CAAC;AAC/C,iBAAS,oBAAoB,aAAa,eAAe;AACzD,iBAAS,oBAAoB,YAAY,cAAc;AAAA,MAC3D;AACA,eAAS,iBAAiB,aAAa,iBAAiB,EAAE,SAAS,MAAM,CAAC;AAC1E,eAAS,iBAAiB,YAAY,gBAAgB,EAAE,SAAS,MAAM,CAAC;AAAA,IAC5E;AACA,uBAAc,CAAC,MAAkB;AAAA,IAAC;AAClC,uBAAc,CAAC,MAAkB;AAAA,IAAC;AAClC,2BAAkB,CAAC,MAAkB;AACjC,QAAE,eAAe;AACjB,MAAC,EAAE,cAA8B,MAAM;AACvC,YAAM,OAAQ,EAAE,cAA8B,sBAAsB;AACpE,YAAM,QAAQ,EAAE,UAAU,KAAK;AAC/B,YAAM,QAAQ,EAAE,UAAU,KAAK;AAC/B,YAAM,YAAY,KAAK,MAAM;AAC7B,WAAK,kBAAkB,EAAE,GAAG,OAAO,GAAG,OAAO,eAAe,EAAE,CAAC;AAC/D,YAAM,kBAAkB,CAACA,OAAkB;AACvC,QAAAA,GAAE,eAAe;AACjB,cAAM,IAAIA,GAAE,UAAU,KAAK;AAC3B,cAAM,IAAIA,GAAE,UAAU,KAAK;AAC3B,aAAK,kBAAkB,EAAE,WAAW,GAAG,GAAG,OAAO,OAAO,WAAWA,GAAE,WAAW,WAAWA,GAAE,WAAW,eAAeA,GAAE,CAAC;AAAA,MAC9H;AACA,YAAM,gBAAgB,CAACA,OAAkB;AACrC,QAAAA,GAAE,eAAe;AACjB,cAAM,IAAIA,GAAE,UAAU,KAAK;AAC3B,cAAM,IAAIA,GAAE,UAAU,KAAK;AAC3B,aAAK,gBAAgB,EAAE,GAAG,GAAG,eAAeA,GAAE,CAAC;AAC/C,iBAAS,oBAAoB,aAAa,eAAe;AACzD,iBAAS,oBAAoB,WAAW,aAAa;AAAA,MACzD;AACA,eAAS,iBAAiB,aAAa,eAAe;AACtD,eAAS,iBAAiB,WAAW,aAAa;AAAA,IACtD;AACA,2BAAkB,CAAC,MAAkB;AAAA,IAAC;AACtC,0BAAiB,CAAC,MAAkB;AAAA,IAAC;AACrC,6BAAoB,CAAC,MAAkB;AAAA,IAAC;AACxC,6BAAoB,CAAC,MAAwB;AAAA,IAAC;AAC9C,6BAAoB,CAAC,MAAwB;AAAA,IAAC;AAC9C,2BAAkB,CAAC,MAAsB;AAAA,IAAC;AAC1C,yBAAgB,CAAC,MAAkB,KAAK,SAAS,EAAE,OAAO,KAAK,CAAC;AAChE,0BAAiB,CAAC,MAAkB,KAAK,SAAS,EAAE,OAAO,MAAM,CAAC;AAO9D,SAAK,MAAM,QAAQ,kCAAK,KAAK,aAAa,QAAU,MAAM;AAC1D,QAAI,KAAK,MAAM;AAAS,WAAK,MAAM,QAAQ,SAAS,KAAK,MAAM,SAAS,IAAI;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA,EAIA,cAAc,OAAe;AACzB,UAAM,EAAE,KAAK,KAAK,KAAK,IAAI,KAAK;AAChC,QAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ;AAAU,aAAO;AAC/D,UAAM,IAAI,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,CAAC;AAC5C,QAAI,CAAC;AAAM,aAAO;AAClB,WAAO,MAAM,KAAK,OAAO,IAAI,OAAO,IAAI,IAAI;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA,EAIA,SAAS,SAAiB;AACtB,UAAM,QAAQ,KAAK,cAAc,OAAO;AACxC,UAAM,UAAU,KAAK,SAAS,EAAE,MAAM,CAAC;AACvC,QAAI;AAAS,WAAK,OAAO,KAAK;AAC9B,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAIA,OAAO,SAAkB;AACrB,QAAI,KAAK,MAAM;AAAS,WAAK,MAAM,QAAQ,gBAAgB,KAAK,MAAM,SAAS,OAAO,YAAY,WAAW,UAAU,KAAK,MAAM,KAAK;AAAA,EAC3I;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,UAA6E;AAClF,QAAI,eAAe;AACnB,eAAW,OAAO,UAAU;AACxB,YAAM,WAAW;AACjB,YAAM,aAAa,SAAS,QAAQ;AACpC,UAAI,aAAa,SAAS;AACtB,mBAAW,YAAY,SAAS,OAAO;AACnC,cAAI,YAAY,KAAK,MAAM,OAA8G;AACrI,iBAAK,MAAM,MAAM,QAAQ,IAAI,SAAS,MAAM,QAAQ;AACpD,2BAAe;AAAA,UACnB;AAAA,QACJ;AAAA,MACJ,WAAW,YAAY,KAAK,SAAS,KAAK,MAAM,QAAQ,MAAM,YAAY;AACtE,QAAC,KAAK,MAAc,QAAQ,IAAI;AAChC,uBAAe;AAAA,MACnB;AAAO,eAAO;AACd,UAAI;AAAc,aAAK,KAAK,UAAU,KAAK,MAAM,QAAQ,CAAC;AAAA,IAC9D;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,qBAAqB;AACjB,SAAK,YAAY,SAAS,cAAc,KAAK;AAC7C,SAAK,UAAU,YAAY,CAAC,sBAAsB,wBAAwB,KAAK,SAAS,EAAE,KAAK,GAAG;AAClG,SAAK,UAAU,WAAW;AAC1B,SAAK,UAAU,KAAK,KAAK,MAAM;AAC/B,QAAI,KAAK,MAAM;AAAS,WAAK,UAAU,QAAQ,KAAK,MAAM;AAC1D,SAAK,QAAQ,SAAS,cAAc,KAAK;AACzC,SAAK,MAAM,YAAY;AACvB,SAAK,cAAc,SAAS,cAAc,QAAQ;AAClD,SAAK,WAAW,KAAK,YAAY,WAAW,IAAI;AAChD,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAIA,QAAQ;AACJ,SAAK,MAAM,YAAY,KAAK,WAAW;AACvC,WAAO;AAAA,EACX;AAAA,EACA,WAAW,OAAyB;AAChC,UAAM,QAAQ,KAAK,MAAM;AACzB,UAAM,QAAQ,KAAK,MAAM,MAAM;AAC/B,UAAM,MAAM,KAAK;AACjB,UAAM,SAAS,KAAK;AACpB,UAAM,QAAQ,OAAO,oBAAoB;AACzC,QAAI,EAAE,OAAO,OAAO,IAAI,KAAK,MAAM,sBAAsB;AACzD,QAAI,CAAC,SAAS,CAAC;AAAQ,aAAO;AAC9B,YAAQ,KAAK,MAAM,KAAK;AACxB,aAAS,KAAK,MAAM,MAAM;AAC1B,UAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,UAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,WAAO,QAAQ;AACf,WAAO,SAAS;AAGhB,QAAI,MAAM,OAAO,KAAK;AACtB,QAAI,UAAU,GAAG,GAAG,OAAO,MAAM;AACjC,QAAI,YAAY;AAChB,QAAI,eAAe;AACnB,QAAI,YAAY,SAAS;AACzB,QAAI,OAAO,QAAQ,SAAS;AAC5B,QAAI,SAAS,OAAO,UAAU,SAAS,IAAI,UAAU,UAAU,QAAQ,QAAQ,GAAG,SAAS,GAAG,KAAK;AACnG,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAIA,oBAAoB;AAChB,UAAM,eAAe,MAAM;AACvB,YAAM,EAAE,MAAM,MAAM,KAAK,OAAO,OAAO,IAAI,KAAK,MAAM;AACtD,WAAK,UAAU,MAAM,QAAQ,GAAG,QAAQ;AACxC,WAAK,UAAU,MAAM,SAAS,GAAG,SAAS;AAC1C,WAAK,UAAU,MAAM,OAAO,GAAG,OAAO;AACtC,WAAK,UAAU,MAAM,MAAM,GAAG,MAAM;AACpC,WAAK,MAAM,MAAM,SAAS,GAAG,OAAO;AACpC,WAAK,WAAW;AAAA,IACpB;AACA,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,YAAY,CAAC;AAClD,iBAAa;AACb,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,aAAa;AACb,UAAM,EAAE,MAAM,KAAK,KAAK,MAAM,MAAM,IAAI,KAAK;AAC7C,UAAM,WAAW,SAAS,SAAS,MAAM,SAAS,SAAS,QAAQ,MAAM,OAAO,MAAM,OAAO;AAC7F,QAAI,MAAM;AACN,UAAI,SAAS;AAAQ,eAAO,MAAM;AAClC,UAAI,SAAS;AAAO,eAAO,KAAK,IAAI,KAAK,OAAO,MAAM,QAAQ,KAAK,MAAM,IAAI,KAAK,EAAE,GAAG,QAAQ;AAC/F,aAAO,KAAK,OAAO,MAAM,OAAO,IAAI;AAAA,IACxC;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,WAAW;AACX,UAAM,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,MAAM,IAAI,KAAK;AACrD,WAAO,cAAa,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,MAAM,CAAC;AAAA,EAC3E;AAAA,EACA,OAAO,YAAY,OAAwJ;AACvK,UAAM,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,MAAM,IAAI;AAChD,QAAI,SAAS;AAAQ,aAAO,SAAS,MAAM,SAAS;AACpD,UAAM,IAAI,UAAU,QAAQ,+CAAO,CAAC,OAAO,KAAK,GAAG,IAAI,UAAU,QAAQ,+CAAO,CAAC,OAAO,KAAK,GAAG,IAAI;AACpG,WAAO,iDAAS,CAAC,GAAG,KAAK,GAAG;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,YAAY;AACZ,UAAM,OAAO;AACb,UAAM,aAAa,KAAK;AACxB,WAAO,OAAO;AAAA,EAClB;AACJ;AA5QA,IAA8B,eAA9B;AAAA;AAAA;AAAA;AAA8B,aAInB,eAAmD;AAAA,EACtD,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,OAAO;AAAA,EACP,SAAS;AAAA,EACT,KAAK;AAAA,EACL,KAAK;AAAA,EACL,OAAO,CAAC;AAAA,EACR,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,MAAM;AAAA,EACN,OAAO,EAAE,OAAO,IAAI,QAAQ,IAAI,MAAM,GAAG,KAAK,GAAG,YAAY,2BAA2B;AAC5F;AAnCJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACA0C;AAEnB;AAaR,MAAM,eAAe,qDAAY,CAAqB;AAAA,EAArE;AAAA;AAmBI,qBAAY;AAYZ,oBAAW,MAAM;AACb,YAAM,EAAE,OAAO,MAAM,IAAI,KAAK;AAC9B,YAAM,EAAE,QAAQ,MAAM,UAAU,UAAU,UAAU,WAAW,aAAa,WAAW,SAAS,aAAa,cAAc,IAAI;AAC/H,WAAK,IAAI,MAAM,kBAAkB,QAAQ,YAAY;AACrD,WAAK,IAAI,MAAM,cAAc,QAAQ,gBAAgB;AACrD,WAAK,IAAI,MAAM,QAAQ,QAAQ,cAAc;AAC7C,WAAK,IAAI,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AACzD,WAAK,IAAI,MAAM,aAAa,GAAG;AAC/B,WAAK,IAAI,MAAM,YAAY;AAAA,IAC/B;AAgBA,6BAAoB,MAAM;AACtB,WAAK,SAAS,CAAC;AAAA,IACnB;AACA,2BAAkB,MAAM;AACpB,WAAK,SAAS,CAAC;AAAA,IACnB;AAAA;AAAA,EA5DA,WAAW,eAAqD;AAC5D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,WAAW;AAAA,QACX,aAAa;AAAA,QACb,eAAe;AAAA,QACf,WAAW;AAAA,QACX,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,EACJ;AAAA,EAKA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,MAAM,SAAS,cAAc,KAAK;AACvC,SAAK,OAAO,SAAS,cAAc,MAAM;AACzC,SAAK,KAAK,YAAY,KAAK,MAAM;AACjC,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAWA,QAAQ;AACJ,SAAK,IAAI,YAAY,KAAK,IAAI;AAC9B,SAAK,UAAU,YAAY,KAAK,GAAG;AACnC,WAAO,MAAM,MAAM;AAAA,EACvB;AAAA,EACA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,IAAI,iBAAiB,aAAa,KAAK,eAAe;AAC3D,SAAK,IAAI,iBAAiB,cAAc,KAAK,gBAAgB;AAC7D,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,UAAM,cAAc,MAAM,KAAK,KAAK,YAAY,KAAK,MAAM;AAC3D,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,WAAO;AAAA,EACX;AAOJ;;;;;;;;;;;;;;;;;AC7E8B;AACL;AAEV,MAAM,iBAAiB,+CAAM,CAAC;AAAA,EAA7C;AAAA;AACI,qBAAY;AAEZ,6BAAoB,MAAM;AACtB,WAAK,SAAS,IAAI,KAAK,MAAM,KAAK;AAAA,IACtC;AACA,2BAAkB,MAAM;AAAA,IACxB;AAAA;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACVoD;AAEpB;AACA;AACF;AACM;AACN;AACI;AACR;AACA;AACE;AACJ;AACY;AACA;AACA;AACE;AAOhB;AAKP,MAAM,cAAc,0DAAiB,CAAoB;AAAA,EAAxE;AAAA;AA6JI,oBAAW,MAAM;AACb,WAAK,WAAW,CAAC;AACjB,YAAM,EAAE,OAAO,MAAM,OAAO,SAAS,OAAO,IAAI,KAAK;AACrD,YAAM,EAAE,MAAM,MAAM,KAAK,OAAO,OAAO,IAAI;AAC3C,UAAI,CAAC,KAAK,MAAM;AAAQ,aAAK,MAAM,MAAM,SAAS,GAAG,OAAO;AAC5D,WAAK,UAAU,MAAM,OAAO,GAAG,OAAO;AACtC,WAAK,UAAU,MAAM,MAAM,GAAG,MAAM;AACpC,WAAK,UAAU,MAAM,QAAQ,GAAG,QAAQ;AACxC,WAAK,UAAU,MAAM,SAAS,GAAG,SAAS;AAC1C,WAAK,UAAU,YAAY,CAAC,kBAAkB,YAAY,QAAQ,GAAG,SAAS,kBAAkB,IAAI,EAAE,KAAK,GAAG;AAC9G,YAAM,QAAQ,CAAC,SAAS;AACpB,YAAI,KAAK,KAAK,SAAS,OAAO,GAAG;AAC7B,gBAAM,YAAY,MAAM,aAAa,MAAM,SAAS,IAAI;AACxD,cAAI;AAAW,iBAAK,SAAS,KAAK,SAAS;AAAA,QAC/C,OAAO;AACH,gBAAM,SAAS;AACf,gBAAM,gBAAgB,MAAM,aAAa,QAAQ,KAAK,MAAM,SAAS,IAAI;AACzE,cAAI;AAAe,iBAAK,SAAS,KAAK,aAAa;AAAA,QACvD;AAAA,MACJ,CAAC;AACD,UAAI,SAAS,UAAU;AACnB,aAAK,KAAK,YAAY;AACtB,aAAK,KAAK,MAAM,SAAS,GAAG;AAC5B,aAAK,KAAK,MAAM,MAAM,GAAG,OAAO;AAChC,aAAK,MAAM,MAAM,QAAQ,CAAC,MAAM,MAAM;AAClC,gBAAM,QAAQ,KAAK;AACnB,gBAAM,MAAM,SAAS,cAAc,MAAM;AACzC,cAAI,YAAY;AAChB,cAAI,YAAY;AAChB,cAAI,MAAM,WAAW,GAAG,OAAO;AAC/B,cAAI,MAAM,QAAQ,GAAG,IAAI,OAAO;AAChC,cAAI,MAAM,SAAS,GAAG,OAAO;AAC7B,cAAI,MAAM,aAAa,GAAG,OAAO;AACjC,cAAI,iBAAiB,SAAS,MAAM;AAChC,kBAAM,SAA2B,CAAC;AAClC,qBAAS,IAAI,GAAG,IAAI,KAAK,UAAU,SAAS,QAAQ,KAAK;AACrD,oBAAM,UAAU,KAAK,UAAU,SAAS,CAAC;AACzC,kBAAI,IAAI;AAAG,uBAAO,KAAK,OAAO;AAAA,YAClC;AACA,qBAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,oBAAM,UAAU,OAAO,CAAC;AACxB,sBAAQ,MAAM,aAAa,MAAM,IAAI,YAAY;AAAA,YACrD;AACA,qBAAS,IAAI,GAAG,IAAI,KAAK,KAAK,SAAS,QAAQ,KAAK;AAChD,oBAAM,IAAI,KAAK,KAAK,SAAS,CAAC;AAC9B,kBAAI,MAAM,GAAG;AACT,oBAAI,EAAE,UAAU,SAAS,QAAQ;AAAG,oBAAE,UAAU,OAAO,QAAQ;AAAA,cACnE;AAAO,kBAAE,UAAU,IAAI,QAAQ;AAAA,YACnC;AAAA,UACJ,CAAC;AACD,eAAK,KAAK,YAAY,GAAG;AAAA,QAC7B,CAAC;AAAA,MACL;AAAA,IACJ;AAAA;AAAA,EAjNA,OAAO,UAAU,QAAuF;AACpG,UAAM,aAA0B,CAAC;AACjC,QAAI,CAAC;AAAQ,aAAO,EAAE,WAAW;AACjC,WAAO,QAAQ,OAAK,OAAO,OAAO,YAAY,CAAC,CAAC;AAChD,QAAI,WAAW,OAAO;AAClB,YAAM,aAAa;AACnB,YAAM,UAAU,WAAW,MAAM,MAAM,UAAU;AACjD,UAAI,SAAS;AACT,cAAM,aAAa;AACnB,cAAM,QAAmC,CAAC;AAC1C,YAAI;AAEJ,eAAO,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,GAAG;AACvC,gBAAM,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;AAAA,QAC5B;AACA,eAAO,EAAE,YAAY,MAAM;AAAA,MAC/B;AAAA,IACJ;AACA,WAAO,EAAE,WAAW;AAAA,EACxB;AAAA,EACA,OAAO,aAAa,MAAgF,SAAkB,MAAc;AAChI,UAAM,OAAO,uDAAM,CAAC,YAAY,IAAI;AACpC,QAAI,KAAK,SAAS,OAAO,GAAG;AACxB,YAAM,EAAE,OAAAC,QAAO,OAAO,MAAAC,OAAM,QAAAC,QAAO,IAAI;AACvC,YAAMC,SAAoB;AAAA,QACtB,OAAAH;AAAA,QACA,MAAAC;AAAA,QACA;AAAA,QACA,OAAO;AAAA,UACH;AAAA,UACA,OAAOC,QAAO;AAAA,UACd,QAAQA,QAAO;AAAA,UACf,MAAMA,QAAO;AAAA,UACb,KAAKA,QAAO;AAAA,UACZ,YAAY;AAAA,QAChB;AAAA,QACA;AAAA,MACJ;AACA,aAAO,IAAI,MAAMC,MAAK;AAAA,IAC1B;AACA,UAAM,SAAS;AACf,UAAM,EAAE,YAAY,MAAM,IAAI,KAAK,UAAU,OAAO,IAAI;AACxD,UAAM,EAAE,SAAS,MAAM,MAAM,IAAI;AACjC,UAAM,EAAE,OAAO,KAAK,KAAK,SAAS,OAAO,IAAI;AAC7C,UAAM,QAA4C;AAAA,MAC9C;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,OAAO,SAAS;AAAA,MAChB;AAAA,MACA;AAAA,MACA,OAAO;AAAA,QACH;AAAA,QACA,OAAO,OAAO;AAAA,QACd,QAAQ,OAAO;AAAA,QACf,MAAM,OAAO;AAAA,QACb,KAAK,OAAO;AAAA,MAChB;AAAA,MACA,MAAM;AAAA,MACN,KAAK,SAAS,GAAG,IAAI,MAAM;AAAA,MAC3B,KAAK,SAAS,GAAG,IAAI,MAAM;AAAA,MAC3B,MAAM,UAAU,OAAO,CAAC,KAAK,OAAO;AAAA,MACpC,OAAO,UAAU,OAAO,CAAC,KAAK,QAAQ,IAAI;AAAA,IAC9C;AACA,QAAI,SAAS;AAAU,aAAO,IAAI,+CAAM,CAAC,KAAK;AAC9C,QAAI,SAAS;AAAY,aAAO,IAAI,iDAAQ,CAAC,KAAK;AAClD,QAAI,SAAS;AAAU,aAAO,IAAI,+CAAM,CAAC,KAAK;AAC9C,QAAI,SAAS;AAAa,aAAO,IAAI,kDAAS,CAAC,KAAK;AACpD,QAAI,SAAS;AAAQ,aAAO,IAAI,6CAAI,CAAC,KAAK;AAC1C,QAAI,SAAS;AAAQ,aAAO,IAAI,6CAAI,CAAC,KAAK;AAC1C,QAAI,SAAS;AAAS,aAAO,IAAI,8CAAK,CAAC,KAAK;AAC5C,QAAI,SAAS;AAAW,aAAO,IAAI,gDAAO,CAAC,KAAK;AAChD,QAAI,SAAS;AAAW,aAAO,IAAI,gDAAO,CAAC,KAAK;AAChD,QAAI,SAAS;AAAa,aAAO,IAAI,mDAAS,CAAC,KAAK;AACpD,QAAI,SAAS;AAAa,aAAO,IAAI,mDAAS,CAAC,KAAK;AACpD,QAAI,SAAS;AAAa,aAAO,IAAI,mDAAS,CAAC,KAAK;AACpD,QAAI,SAAS;AAAO,aAAO,IAAI,6CAAG,CAAC,KAAK;AACxC,WAAO;AAAA,EACX;AAAA,EAiBA,SAAS,UAAyE;AAC9E,QAAI,eAAe;AACnB,eAAW,OAAO,UAAU;AACxB,YAAM,WAAW;AACjB,YAAM,aAAa,SAAS,QAAQ;AACpC,UAAI,aAAa,SAAS;AACtB,mBAAWC,QAAO,SAAS,OAAO;AAC9B,gBAAM,WAAWA;AACjB,cAAI,YAAY,KAAK,MAAM,OAA8G;AACrI,YAAC,KAAK,MAAM,MAAc,QAAQ,IAAI,SAAS,MAAM,QAAQ;AAC7D,2BAAe;AAAA,UACnB;AAAA,QACJ;AAAA,MACJ,WAAW,YAAY,KAAK,SAAS,KAAK,MAAM,QAAQ,MAAM,YAAY;AACtE,QAAC,KAAK,MAAc,QAAQ,IAAI;AAChC,uBAAe;AAAA,MACnB;AAAO;AACP,UAAI;AAAc,aAAK,KAAK,UAAU,KAAK,MAAM,QAAQ,CAAC;AAAA,IAC9D;AAAA,EACJ;AAAA,EACA,qBAAqB;AACjB,SAAK,YAAY,SAAS,cAAc,KAAK;AAC7C,SAAK,OAAO,SAAS,cAAc,KAAK;AACxC,SAAK,KAAK,YAAY;AACtB,QAAI,CAAC,KAAK,MAAM,QAAQ;AACpB,WAAK,QAAQ,SAAS,cAAc,KAAK;AACzC,WAAK,MAAM,YAAY;AACvB,WAAK,cAAc,SAAS,cAAc,QAAQ;AAClD,WAAK,WAAW,KAAK,YAAY,WAAW,IAAI;AAAA,IACpD;AACA,SAAK,SAAS;AACd,SAAK,SAAS,QAAQ,UAAQ,KAAK,mBAAmB,CAAC;AACvD,WAAO;AAAA,EACX;AAAA,EACA,aAAa;AACT,QAAI,KAAK,MAAM;AAAQ,aAAO;AAC9B,UAAM,QAAQ,KAAK,MAAM;AACzB,UAAM,QAAQ,KAAK,MAAM,MAAM;AAC/B,UAAM,MAAM,KAAK;AACjB,UAAM,SAAS,KAAK;AACpB,UAAM,QAAQ,OAAO,oBAAoB;AACzC,QAAI,EAAE,OAAO,OAAO,IAAI,KAAK,MAAM,sBAAsB;AACzD,QAAI,CAAC,SAAS,CAAC;AAAQ,aAAO;AAC9B,YAAQ,KAAK,MAAM,KAAK;AACxB,aAAS,KAAK,MAAM,MAAM;AAC1B,UAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,UAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,WAAO,QAAQ;AACf,WAAO,SAAS;AAGhB,QAAI,MAAM,OAAO,KAAK;AACtB,QAAI,UAAU,GAAG,GAAG,OAAO,MAAM;AACjC,QAAI,YAAY;AAChB,QAAI,eAAe;AACnB,QAAI,YAAY;AAChB,QAAI,OAAO,QAAQ,SAAS;AAC5B,QAAI,SAAS,OAAO,GAAG,SAAS,GAAG,KAAK;AACxC,WAAO;AAAA,EACX;AAAA,EAuDA,QAAQ;AACJ,QAAI,CAAC,KAAK,MAAM,QAAQ;AACpB,WAAK,MAAM,YAAY,KAAK,WAAW;AACvC,WAAK,UAAU,YAAY,KAAK,KAAK;AAAA,IACzC;AACA,QAAI,KAAK,KAAK,SAAS;AAAQ,WAAK,UAAU,YAAY,KAAK,IAAI;AACnE,SAAK,SAAS,QAAQ,CAAC,SAAS;AAC5B,WAAK,MAAM;AACX,WAAK,UAAU,YAAY,KAAK,SAAS;AAAA,IAC7C,CAAC;AACD,WAAO;AAAA,EACX;AAAA,EACA,oBAAoB;AAChB,UAAM,eAAe,MAAM;AACvB,YAAM,EAAE,MAAM,MAAM,KAAK,OAAO,OAAO,IAAI,KAAK,MAAM;AACtD,UAAI,CAAC,KAAK,MAAM;AAAQ,aAAK,MAAM,MAAM,SAAS,GAAG,OAAO;AAC5D,WAAK,UAAU,MAAM,QAAQ,GAAG,QAAQ;AACxC,WAAK,UAAU,MAAM,SAAS,GAAG,SAAS;AAC1C,WAAK,UAAU,MAAM,OAAO,GAAG,OAAO;AACtC,WAAK,UAAU,MAAM,MAAM,GAAG,MAAM;AACpC,UAAI,KAAK,MAAM,SAAS,UAAU;AAC9B,aAAK,KAAK,MAAM,SAAS,GAAG;AAC5B,aAAK,KAAK,MAAM,MAAM,GAAG,OAAO;AAChC,iBAAS,IAAI,GAAG,IAAI,KAAK,KAAK,SAAS,QAAQ,KAAK;AAChD,gBAAM,MAAM,KAAK,KAAK,SAAS,CAAC;AAChC,cAAI,MAAM,WAAW,GAAG,OAAO;AAC/B,cAAI,MAAM,QAAQ,GAAG,IAAI,OAAO;AAChC,cAAI,MAAM,SAAS,GAAG,OAAO;AAC7B,cAAI,MAAM,aAAa,GAAG,OAAO;AAAA,QACrC;AAAA,MACJ;AACA,WAAK,WAAW;AAChB,WAAK,SAAS,QAAQ,UAAQ,KAAK,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;AAAA,IACpE;AACA,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,YAAY,CAAC;AAClD,UAAM,cAAc,MAAM;AACtB,WAAK,SAAS;AACd,WAAK,SAAS,QAAQ,UAAQ,KAAK,mBAAmB,CAAC;AAAA,IAC3D;AACA,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,UAAM,cAAc,MAAM;AACtB,WAAK,WAAW;AAChB,WAAK,MAAM,QAAQ,KAAK,MAAM;AAAA,IAClC;AACA,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,SAAK,WAAW;AAChB,QAAI,KAAK,QAAQ,KAAK,KAAK,SAAS;AAAQ,MAAC,KAAK,KAAK,SAAS,CAAC,EAAsB,MAAM;AAC7F,SAAK,SAAS,QAAQ,UAAQ,KAAK,kBAAkB,CAAC;AACtD,WAAO;AAAA,EACX;AACJ;;;;;;;;;;;;;;;;;;ACjS0C;AACN;AACV;AAEX,MAAM,kBAAkB,kDAAS,CAAC;AAAA,EAAjD;AAAA;AACI,qBAAY;AAKZ,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AAC/E,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AAC3D,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,UAAU,MAAM,kBAAkB;AACvC,WAAK,UAAU,MAAM,cAAc;AAAA,IACvC;AACA,iBAAQ,MAAM;AACV,YAAM,EAAE,UAAU,YAAY,WAAW,WAAW,UAAU,cAAc,IAAI,KAAK,MAAM;AAC3F,YAAM,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,MAAM,IAAI,KAAK;AACrD,YAAM,MAAM,KAAK;AACjB,YAAM,SAAS,KAAK;AACpB,YAAM,QAAQ,OAAO,oBAAoB;AACzC,UAAI,EAAE,OAAO,OAAO,IAAI,KAAK,UAAU,sBAAsB;AAC7D,cAAQ,KAAK,MAAM,KAAK;AACxB,eAAS,KAAK,MAAM,MAAM;AAC1B,YAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,YAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,aAAO,QAAQ;AACf,aAAO,SAAS;AAGhB,UAAI,MAAM,OAAO,KAAK;AAEtB,YAAM,YAAY,QAAQ;AAC1B,YAAM,aAAa,YAAY,KAAK,IAAI,SAAS,GAAG,YAAY,IAAI;AACpE,YAAM,OAAO,QAAQ;AACrB,YAAM,OAAO,SAAS,cAAc;AACpC,WAAK,aAAa;AAClB,YAAM,aAAa,KAAK;AACxB,UAAI,aAAa,KAAK,UAAU;AAC5B,aAAK,WAAW;AAChB,YAAI,KAAK;AAAU,iBAAO,aAAa,KAAK,QAAQ;AACpD,aAAK,WAAW,OAAO,WAAW,MAAM;AACpC,eAAK,WAAW,KAAK;AACrB,eAAK,WAAW;AAChB,eAAK,SAAS,KAAK,KAAK;AAAA,QAC5B,GAAG,GAAI;AAAA,MACX;AACA,UAAI,aAAa,KAAK,YAAY,OAAO,KAAK,aAAa,aAAa;AACpE,aAAK,WAAW,OAAO,WAAW,MAAM;AACpC,eAAK,WAAW,KAAK;AACrB,eAAK,WAAW;AAChB,eAAK,SAAS,KAAK,KAAK;AAAA,QAC5B,GAAG,GAAI;AAAA,MACX;AACA,YAAM,WAAW,KAAK;AACtB,YAAM,YAAY,MAAM,QAAQ,MAAM;AACtC,YAAM,YAAY,KAAK,QAAQ,MAAM;AACrC,YAAM,WAAW,KAAK,QAAQ,MAAM;AACpC,YAAM,eAAe,KAAK,IAAI,GAAG,CAAC,OAAO,MAAM,IAAI;AACnD,YAAM,WAAW,IAAI,qBAAqB,MAAM,GAAG,WAAW,CAAC;AAC/D,UAAI,YAAY,KAAK,YAAY;AAAG,iBAAS,aAAa,UAAU,SAAS;AAAA,eACpE,WAAW;AAAG,iBAAS,aAAa,GAAG,SAAS;AACzD,UAAI,YAAY,KAAK,YAAY;AAAG,iBAAS,aAAa,UAAU,SAAS;AAC7E,UAAI,WAAW,KAAK,WAAW;AAAG,iBAAS,aAAa,SAAS,QAAQ;AACzE,UAAI,gBAAgB,KAAK,gBAAgB;AAAG,iBAAS,aAAa,cAAc,aAAa;AAAA,eACpF,eAAe;AAAG,iBAAS,aAAa,GAAG,SAAS;AAE7D,UAAI,YAAY;AAChB,UAAI,aAAa;AAAG,YAAI,SAAS,MAAM,KAAK,YAAY,cAAc,UAAU;AAChF,UAAI,aAAa;AAAK,YAAI,SAAS,OAAO,YAAY,eAAe,GAAG,KAAK,aAAa,IAAI,gBAAgB,GAAG,UAAU;AAC3H,UAAI,YAAY;AAChB,UAAI,aAAa,KAAK;AAClB,cAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,GAAG,UAAU,EAAE,CAAC,CAAC;AACvH,YAAI,SAAS,MAAM,KAAK,WAAW,WAAW,UAAU;AAAA,MAC5D;AACA,UAAI,aAAa,GAAG;AAChB,cAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,KAAK,UAAU,EAAE,CAAC,IAAI,YAAY;AACxI,YAAI,SAAS,OAAO,eAAe,YAAY,GAAG,KAAK,WAAW,YAAY,GAAG,UAAU;AAAA,MAC/F;AACA,UAAI,WAAW,YAAY;AACvB,YAAI,YAAY,GAAG;AACf,gBAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,GAAG,QAAQ,EAAE,CAAC,CAAC;AACrH,cAAI,SAAS,OAAO,WAAW,YAAY,GAAG,KAAK,GAAG,UAAU;AAAA,QACpE;AACA,YAAI,WAAW,GAAG;AACd,gBAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,KAAK,QAAQ,EAAE,CAAC,IAAI,YAAY;AACtI,cAAI,SAAS,OAAO,KAAK,IAAI,YAAY,IAAI,eAAe,YAAY,SAAS,GAAG,KAAK,GAAG,UAAU;AAAA,QAC1G;AAAA,MACJ;AAAA,IACJ;AAAA;AAAA,EApFA,aAAa;AACT,WAAO,MAAM,WAAW,MAAM;AAAA,EAClC;AAmFJ;;;;;;;;;;;;;;;;;;AC5F0C;AACV;AACR;AAET,MAAM,gBAAgB,gDAAO,CAAC;AAAA,EAA7C;AAAA;AACI,qBAAY;AAKZ,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AAC/E,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AAC3D,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,UAAU,MAAM,kBAAkB;AACvC,WAAK,UAAU,MAAM,cAAc;AAAA,IACvC;AACA,iBAAQ,MAAM;AACV,YAAM,EAAE,aAAa,eAAe,iBAAiB,YAAY,IAAI,KAAK,MAAM;AAChF,YAAM,MAAM,KAAK;AACjB,YAAM,SAAS,KAAK;AACpB,YAAM,WAAW,KAAK;AACtB,YAAM,QAAQ,OAAO,oBAAoB;AACzC,UAAI,EAAE,OAAO,OAAO,IAAI,KAAK,UAAU,sBAAsB;AAC7D,cAAQ,KAAK,MAAM,KAAK;AACxB,eAAS,KAAK,MAAM,MAAM;AAC1B,YAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,YAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,aAAO,QAAQ;AACf,aAAO,SAAS;AAGhB,UAAI,MAAM,OAAO,KAAK;AAEtB,YAAM,YAAY,QAAQ;AAC1B,YAAM,aAAa,eAAe,KAAK,IAAI,SAAS,GAAG,YAAY,IAAI;AACvE,YAAM,OAAO,QAAQ;AACrB,YAAM,OAAO,SAAS,cAAc;AACpC,YAAM,eAAe,aAAa;AAClC,WAAK,kBAAkB,CAAC,MAAM,GAAG,WAAW,MAAM;AAClD,YAAM,MAAM,IAAI,qBAAqB,MAAM,GAAG,OAAO,WAAW,CAAC;AACjE,UAAI,aAAa,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,QAAQ,CAAC,GAAG,eAAe;AACpE,UAAI,aAAa,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,QAAQ,CAAC,GAAG,aAAa;AAClE,UAAI,YAAY;AAChB,6DAAe,CAAC,KAAK,MAAM,KAAK,WAAW,YAAY,YAAY;AAEnE,UAAI,YAAY;AAChB,6DAAe,CAAC,KAAK,OAAO,YAAY,WAAW,YAAY,MAAM,YAAY,aAAa,GAAG,aAAa,GAAG,YAAY;AAAA,IACjI;AAAA;AAAA,EAzCA,aAAa;AACT,WAAO,MAAM,WAAW,MAAM;AAAA,EAClC;AAwCJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACjD0C;AACgC;AAGrD;AAQN,MAAM,aAAa,qDAAY,CAAmB;AAAA,EAAjE;AAAA;AAqBI,qBAAY;AAwBZ,wBAAe,CAAC,MAAa;AACzB,YAAM,QAAQ,WAAY,EAAE,cAAmC,KAAK;AACpE,UAAI,SAAS,KAAK,GAAG;AACjB,cAAM,UAAU,KAAK,SAAS,CAAC,KAAK,YAAY,KAAK;AACrD,YAAI;AAAS;AAAA,MACjB;AACA,WAAK,MAAM,QAAQ,KAAK,YAAY,SAAS,KAAK,MAAM,QAAQ;AAAA,IACpE;AACA,oBAAW,MAAM;AACb,YAAM,EAAE,UAAU,QAAQ,MAAM,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AAC/E,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AAC3D,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,UAAU,MAAM,kBAAkB;AACvC,WAAK,UAAU,MAAM,cAAc;AAAA,IACvC;AA2CA,iBAAQ,MAAM;AACV,YAAM,EAAE,WAAW,WAAW,aAAa,YAAY,IAAI,KAAK,MAAM;AACtE,YAAM,MAAM,KAAK;AACjB,YAAM,SAAS,KAAK;AACpB,YAAM,WAAW,KAAK;AACtB,YAAM,QAAQ,OAAO,oBAAoB;AACzC,UAAI,EAAE,OAAO,OAAO,IAAI,KAAK,OAAO,sBAAsB;AAC1D,cAAQ,KAAK,MAAM,KAAK;AACxB,eAAS,KAAK,MAAM,MAAM;AAC1B,YAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,YAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,aAAO,QAAQ;AACf,aAAO,SAAS;AAGhB,UAAI,MAAM,OAAO,KAAK;AAEtB,YAAM,QAAQ,IAAI,IAAI,KAAK;AAC3B,YAAM,MAAM,KAAK,IAAI,KAAK;AAC1B,YAAM,SAAS,QAAQ,6CAAK,CAAC,WAAW,GAAG;AAC3C,YAAM,aAAa,KAAK,IAAI,OAAO,MAAM,IAAI;AAC7C,YAAM,aAAa,aAAa;AAChC,YAAM,cAAc,QAAQ;AAC5B,YAAM,cAAc,SAAS;AAK7B,YAAM,YAAY,cAAe,aAAa,MAAM,KAAK,IAAI,MAAM;AACnE,YAAM,YAAY,cAAe,aAAa,MAAM,KAAK,IAAI,MAAM;AACnE,YAAM,YAAY,aAAa,aAAa;AAE5C,UAAI,cAAc;AAClB,UAAI,YAAY;AAChB,UAAI,UAAU;AAEd,UAAI,UAAU;AACd,UAAI,IAAI,aAAa,aAAa,YAAY,QAAQ,GAAG;AACzD,UAAI,OAAO;AAEX,UAAI,UAAU;AACV,YAAI,cAAc;AAClB,YAAI,UAAU;AACd,YAAI,IAAI,aAAa,aAAa,YAAY,OAAO,MAAM;AAC3D,YAAI,OAAO;AAAA,MACf;AAEA,UAAI,cAAc;AAClB,UAAI,UAAU;AACd,UAAI,OAAO,aAAa,WAAW;AACnC,UAAI,OAAO,WAAW,SAAS;AAC/B,UAAI,OAAO;AAAA,IACf;AAiBA,6BAAoB,CAAC,MAAwB;AACzC,YAAM,WAAW,KAAK,kBAAkB,CAAC;AACzC,UAAI,aAAa,KAAK,MAAM;AAAO,aAAK,SAAS,QAAQ;AAAA,IAC7D;AAAA;AAAA,EA7KA,WAAW,eAAmD;AAC1D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,QACX,WAAW;AAAA,QACX,WAAW;AAAA,QACX,aAAa;AAAA,QACb,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,EACJ;AAAA,EAOA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,SAAS,SAAS,cAAc,QAAQ;AAC7C,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,SAAS;AACrB,SAAK,MAAM,KAAK,OAAO,WAAW,IAAI;AACtC,SAAK,cAAc,SAAS,cAAc,OAAO;AACjD,SAAK,YAAY,OAAO;AACxB,SAAK,YAAY,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS;AACjE,SAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AAC/C,SAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AAC/C,SAAK,YAAY,OAAO,KAAK,MAAM,KAAK,SAAS;AACjD,SAAK,QAAQ,SAAS,cAAc,OAAO;AAC3C,SAAK,MAAM,QAAQ,KAAK,YAAY,SAAS,KAAK,MAAM,QAAQ;AAChE,SAAK,MAAM,aAAa;AACxB,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAgBA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,MAAM,iBAAiB,UAAU,KAAK,YAAY;AACvD,SAAK,OAAO,iBAAiB,aAAa,KAAK,eAAe;AAC9D,SAAK,OAAO,iBAAiB,cAAc,KAAK,kBAAkB,EAAE,SAAS,MAAM,CAAC;AACpF,SAAK,GAAG,SAAS,MAAM;AACnB,WAAK,SAAS,KAAK,QAAQ;AAC3B,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,UAAM,cAAc,MAAM;AACtB,WAAK,YAAY,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS;AACjE,WAAK,MAAM,QAAQ,KAAK,YAAY,SAAS,KAAK,MAAM,QAAQ;AAAA,IACpE;AACA,SAAK,GAAG,SAAS,MAAM;AACnB,WAAK,SAAS,WAAW;AACzB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,UAAM,YAAY,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AACvE,SAAK,GAAG,OAAO,MAAM;AACjB,WAAK,SAAS,SAAS;AACvB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,UAAM,YAAY,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AACvE,SAAK,GAAG,OAAO,MAAM;AACjB,WAAK,SAAS,SAAS;AACvB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,UAAM,aAAa,MAAM,KAAK,YAAY,OAAO,KAAK,MAAM,KAAK,SAAS;AAC1E,SAAK,GAAG,QAAQ,MAAM;AAClB,WAAK,SAAS,UAAU;AACxB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,MAAM;AACtC,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,WAAO,MAAM,MAAM;AAAA,EACvB;AAAA,EAsDA,kBAAkB,GAAqB;AACnC,UAAM,EAAE,MAAM,KAAK,KAAK,OAAO,MAAM,IAAI,KAAK;AAC9C,UAAM,OAAO,SAAS,SAAS,IAAK,KAAK,MAAM,QAAQ;AACvD,UAAM,YAAY,KAAK;AACvB,UAAM,aAAa,KAAK;AACxB,UAAM,QAAQ;AACd,UAAM,eAAe,qDAAY,CAAC,YAAY,EAAE,OAAO,EAAE,WAAW,MAAM,KAAK,KAAK,OAAO,MAAM,CAAC,IAAI;AACtG,UAAM,WAAW,eAAe,EAAE,QAAQ,EAAE;AAC5C,UAAM,eAAe,mDAAW,CAAC,WAAW,OAAO,KAAK,GAAG;AAC3D,UAAM,IAAI,UAAU,QAAQ,+CAAO,CAAC,cAAc,KAAK,GAAG,IAAI,UAAU,QAAQ,+CAAO,CAAC,cAAc,KAAK,GAAG,IAAI;AAClH,QAAI,QAAQ,KAAK,MAAM,iDAAS,CAAC,GAAG,KAAK,GAAG,IAAI,QAAQ,SAAS;AACjE,YAAQ,KAAK,IAAI,YAAY,KAAK,IAAI,GAAG,KAAK,CAAC;AAC/C,QAAI,SAAS;AAAQ,aAAO;AAC5B,QAAI,SAAS;AAAO,aAAO,KAAK,MAAM,QAAQ,OAAO,GAAG;AACxD,WAAO,QAAQ,OAAO;AAAA,EAC1B;AAKJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3L0C;AAGtB;AAUL,MAAM,YAAY,qDAAY,CAAkB;AAAA,EAA/D;AAAA;AAuBI,qBAAY;AAsBZ,oBAAW,MAAM;AACb,YAAM,EAAE,SAAS,YAAY,IAAI,KAAK,MAAM;AAC5C,WAAK,UAAU,MAAM,kBAAkB;AACvC,WAAK,UAAU,MAAM,cAAc;AAAA,IACvC;AAoBA,iBAAQ,MAAM;AACV,YAAM,EAAE,OAAO,YAAY,WAAW,WAAW,UAAU,cAAc,IAAI,KAAK,MAAM;AACxF,YAAM,EAAE,KAAK,IAAI,IAAI,KAAK;AAC1B,YAAM,EAAE,QAAQ,KAAK,YAAY,SAAS,SAAS,IAAI;AACvD,YAAM,QAAQ,OAAO,oBAAoB;AACzC,UAAI,EAAE,OAAO,OAAO,IAAI,OAAO,sBAAsB;AACrD,cAAQ,KAAK,MAAM,KAAK;AACxB,eAAS,KAAK,MAAM,MAAM;AAC1B,YAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,YAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,aAAO,QAAQ;AACf,aAAO,SAAS;AAGhB,UAAI,MAAM,OAAO,KAAK;AAEtB,YAAM,aAAa,KAAK,IAAI,QAAQ,KAAK,IAAI;AAC7C,YAAM,YAAY;AAClB,YAAM,QAAQ,QAAQ,aAAa;AACnC,YAAM,OAAO,SAAS,cAAc;AACpC,YAAM,YAAY,MAAM,QAAQ,MAAM;AACtC,YAAM,YAAY,KAAK,QAAQ,MAAM;AACrC,YAAM,WAAW,KAAK,QAAQ,MAAM;AACpC,YAAM,eAAe,CAAC,OAAO,MAAM;AACnC,YAAM,WAAW,QAAQ,qBAAqB,GAAG,GAAG,WAAW,OAAO,CAAC;AACvE,UAAI,YAAY,KAAK,YAAY;AAAG,iBAAS,aAAa,UAAU,SAAS;AAAA,eACpE,WAAW;AAAG,iBAAS,aAAa,GAAG,SAAS;AACzD,UAAI,YAAY,KAAK,YAAY;AAAG,iBAAS,aAAa,UAAU,SAAS;AAC7E,UAAI,WAAW,KAAK,WAAW;AAAG,iBAAS,aAAa,SAAS,QAAQ;AACzE,UAAI,gBAAgB,KAAK,gBAAgB;AAAG,iBAAS,aAAa,cAAc,aAAa;AAAA,eACpF,eAAe;AAAG,iBAAS,aAAa,GAAG,SAAS;AAC7D,cAAQ,YAAY;AACpB,cAAQ,SAAS,GAAG,GAAG,WAAW,OAAO,EAAE;AAC3C,YAAM,IAAI,QAAQ,aAAa,KAAK,IAAI,WAAW,QAAQ,GAAG,WAAW,WAAW,KAAK,GAAG,GAAG,GAAG,CAAC,EAAE;AACrG,UAAI;AAAU,YAAI,YAAY,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC;AAAA;AACrD,YAAI,YAAY;AACrB,UAAI,UAAU;AAAU,YAAI,IAAI,QAAQ,GAAG,SAAS,GAAG,QAAQ,IAAI,MAAM,GAAG,IAAI,KAAK,EAAE;AAAA;AAClF,YAAI,KAAK,MAAM,KAAK,WAAW,UAAU;AAC9C,UAAI,KAAK;AAAA,IACb;AAAA;AAAA,EA3GA,WAAW,eAAkD;AACzD,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,QACX,OAAO;AAAA,QACP,YAAY;AAAA,QACZ,WAAW;AAAA,QACX,WAAW;AAAA,QACX,UAAU;AAAA,QACV,eAAe;AAAA,MACnB;AAAA,IACJ;AAAA,EACJ;AAAA,EAQA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,YAAY,SAAS,cAAc,KAAK;AAC7C,SAAK,UAAU,YAAY,sBAAsB,KAAK;AACtD,SAAK,SAAS,SAAS,cAAc,QAAQ;AAC7C,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,SAAS;AACrB,SAAK,MAAM,KAAK,OAAO,WAAW,IAAI;AACtC,SAAK,aAAa,SAAS,cAAc,QAAQ;AACjD,SAAK,UAAU,KAAK,WAAW,WAAW,IAAI;AAC9C,SAAK,WAAW,QAAQ;AACxB,SAAK,WAAW,SAAS;AACzB,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAMA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,OAAO,iBAAiB,aAAa,KAAK,eAAe;AAC9D,SAAK,OAAO,iBAAiB,cAAc,KAAK,kBAAkB,EAAE,SAAS,MAAM,CAAC;AACpF,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,KAAK,CAAC;AAChD,SAAK,GAAG,OAAO,MAAM,KAAK,SAAS,KAAK,KAAK,CAAC;AAC9C,SAAK,GAAG,OAAO,MAAM,KAAK,SAAS,KAAK,KAAK,CAAC;AAC9C,SAAK,GAAG,QAAQ,MAAM,KAAK,SAAS,KAAK,KAAK,CAAC;AAC/C,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,MAAM;AACtC,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,SAAS;AACzC,WAAO,MAAM,MAAM;AAAA,EACvB;AAyCJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC1H0C;AAErB;AAWN,MAAM,aAAa,qDAAY,CAAmB;AAAA,EAAjE;AAAA;AAiBI,qBAAY;AAyBZ,wBAAe,CAAC,MAAa;AACzB,WAAK,SAAS,CAAE,EAAE,cAAmC,KAAK;AAAA,IAC9D;AACA,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AAC/E,WAAK,OAAO,MAAM,kBAAkB;AACpC,WAAK,OAAO,MAAM,cAAc;AAChC,WAAK,OAAO,MAAM,QAAQ;AAC1B,WAAK,OAAO,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AAAA,IAChE;AAAA;AAAA,EAlDA,WAAW,eAAmD;AAC1D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,MACf;AAAA,IACJ;AAAA,EACJ;AAAA,EAIA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,SAAS,SAAS,cAAc,QAAQ;AAC7C,SAAK,WAAW;AAChB,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EACA,aAAa;AACT,UAAM,EAAE,MAAM,IAAI,KAAK;AACvB,SAAK,OAAO,YAAY;AACxB,QAAI,OAAO;AACP,UAAI,IAAI;AACR,iBAAW,OAAO,OAAO;AACrB,cAAM,SAAS,SAAS,cAAc,QAAQ;AAC9C,eAAO,QAAQ,MAAM,GAAG,EAAE,SAAS;AACnC,eAAO,OAAO;AACd,YAAI,MAAM;AAAG,iBAAO,WAAW;AAC/B,aAAK,OAAO,YAAY,MAAM;AAC9B;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAAA,EAWA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,OAAO,iBAAiB,UAAU,KAAK,YAAY;AACxD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,UAAM,cAAc,MAAM;AACtB,eAAS,IAAI,KAAK,OAAO,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;AACvD,cAAM,SAAS,KAAK,OAAO,SAAS,CAAC;AACrC,YAAI,CAAC,OAAO,UAAU,KAAK,MAAM;AAAO,eAAK,OAAO,gBAAgB;AAAA,MACxE;AAAA,IACJ;AACA,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,gBAAY;AACZ,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,MAAM;AACtC,WAAO,MAAM,MAAM;AAAA,EACvB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtF0C;AAEnB;AAWR,MAAM,eAAe,qDAAY,CAAqB;AAAA,EAArE;AAAA;AAiBI,qBAAY;AAcZ,wBAAe,CAAC,MAAa;AACzB,WAAK,SAAS,CAAE,EAAE,cAAmC,KAAK;AAAA,IAC9D;AACA,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AAC/E,WAAK,MAAM,MAAM,kBAAkB;AACnC,WAAK,MAAM,MAAM,cAAc;AAC/B,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AAAA,IAC/D;AAAA;AAAA,EAvCA,WAAW,eAAqD;AAC5D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,MACf;AAAA,IACJ;AAAA,EACJ;AAAA,EAIA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,QAAQ,SAAS,cAAc,OAAO;AAC3C,SAAK,MAAM,OAAO;AAClB,SAAK,MAAM,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS;AAC3D,SAAK,MAAM,MAAM,KAAK,MAAM,IAAI,SAAS;AACzC,SAAK,MAAM,MAAM,KAAK,MAAM,IAAI,SAAS;AACzC,SAAK,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS;AAC3C,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAWA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,MAAM,iBAAiB,UAAU,KAAK,YAAY;AACvD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,UAAM,cAAc,MAAM,KAAK,MAAM,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS;AACrF,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,UAAM,YAAY,MAAM,KAAK,MAAM,MAAM,KAAK,MAAM,IAAI,SAAS;AACjE,SAAK,GAAG,OAAO,MAAM,KAAK,SAAS,SAAS,CAAC;AAC7C,UAAM,YAAY,MAAM,KAAK,MAAM,MAAM,KAAK,MAAM,IAAI,SAAS;AACjE,SAAK,GAAG,OAAO,MAAM,KAAK,SAAS,SAAS,CAAC;AAC7C,UAAM,aAAa,MAAM,KAAK,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS;AACpE,SAAK,GAAG,QAAQ,MAAM,KAAK,SAAS,UAAU,CAAC;AAC/C,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,WAAO,MAAM,MAAM;AAAA,EACvB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC1E0C;AAGhB;AAEX,MAAM,kBAAkB,qDAAY,CAAqB;AAAA,EAAxE;AAAA;AAiBI,qBAAY;AAWZ,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AAC/E,WAAK,MAAM,MAAM,kBAAkB;AACnC,WAAK,MAAM,MAAM,cAAc;AAC/B,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AAAA,IAC/D;AAAA;AAAA,EAjCA,WAAW,eAAqD;AAC5D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,MACf;AAAA,IACJ;AAAA,EACJ;AAAA,EAIA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,QAAQ,SAAS,cAAc,OAAO;AAC3C,SAAK,MAAM,WAAW;AACtB,SAAK,MAAM,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS,KAAK,KAAK,MAAM,QAAQ;AACnF,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAQA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,UAAM,cAAc,MAAM,KAAK,MAAM,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS,KAAK,KAAK,MAAM,QAAQ;AAC7G,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,WAAO,MAAM,MAAM;AAAA,EACvB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrD0C;AAEpB;AAWP,MAAM,cAAc,qDAAY,CAAoB;AAAA,EAAnE;AAAA;AAiBI,qBAAY;AAWZ,sBAAa,MAAM;AACf,YAAM,EAAE,OAAO,QAAQ,IAAI,KAAK;AAChC,WAAK,MAAM,YAAY;AACvB,UAAI,OAAO;AACP,YAAI,IAAI;AACR,mBAAW,OAAO,OAAO;AACrB,gBAAM,QAAQ,SAAS,cAAc,OAAO;AAC5C,gBAAM,MAAM,SAAS,cAAc,KAAK;AACxC,gBAAM,QAAQ,MAAM,GAAG,EAAE,SAAS;AAClC,gBAAM,OAAO;AACb,gBAAM,OAAO;AACb,cAAI,MAAM;AAAG,kBAAM,UAAU;AAC7B,gBAAM,iBAAiB,UAAU,MAAM;AACnC,gBAAI,MAAM;AAAS,mBAAK,SAAS,MAAM,GAAG,CAAC;AAAA,UAC/C,CAAC;AACD,cAAI,YAAY,KAAK;AACrB,cAAI,OAAO,GAAG;AACd,eAAK,MAAM,YAAY,GAAG;AAC1B;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AACA,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,OAAO,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AACtF,YAAM,WAAW,KAAK,IAAI,SAAS,OAAO,KAAK,QAAQ,OAAO,GAAG;AACjE,WAAK,MAAM,MAAM,kBAAkB;AACnC,WAAK,MAAM,MAAM,cAAc;AAC/B,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY;AAAA,IAC/C;AAAA;AAAA,EAxDA,WAAW,eAAoD;AAC3D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,MACf;AAAA,IACJ;AAAA,EACJ;AAAA,EAIA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,QAAQ,SAAS,cAAc,KAAK;AACzC,SAAK,MAAM,YAAY;AACvB,SAAK,WAAW;AAChB,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EA+BA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,UAAM,cAAc,MAAM;AACtB,eAAS,IAAI,KAAK,MAAM,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;AACtD,cAAM,QAAQ,KAAK,MAAM,SAAS,CAAC,EAAE,cAAc,OAAO;AAC1D,YAAI,CAAC,MAAM,UAAU,KAAK,MAAM;AAAO,gBAAM,UAAU;AAAA,MAC3D;AAAA,IACJ;AACA,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,gBAAY;AACZ,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,WAAO,MAAM,MAAM;AAAA,EACvB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3F0C;AAEhB;AAaX,MAAM,kBAAkB,qDAAY,CAAwB;AAAA,EAA3E;AAAA;AAmBI,qBAAY;AAYZ,oBAAW,MAAM;AACb,YAAM,EAAE,OAAO,MAAM,IAAI,KAAK;AAC9B,YAAM,EAAE,QAAQ,MAAM,UAAU,UAAU,UAAU,WAAW,aAAa,WAAW,SAAS,aAAa,cAAc,IAAI;AAC/H,WAAK,IAAI,MAAM,kBAAkB,QAAQ,YAAY;AACrD,WAAK,IAAI,MAAM,cAAc,QAAQ,gBAAgB;AACrD,WAAK,IAAI,MAAM,QAAQ,QAAQ,cAAc;AAC7C,WAAK,IAAI,MAAM,WAAW,GAAG,YAAY,SAAS,OAAO;AACzD,WAAK,IAAI,MAAM,aAAa,GAAG;AAC/B,WAAK,IAAI,MAAM,YAAY;AAAA,IAC/B;AAgBA,6BAAoB,MAAM;AAAA,IAE1B;AACA,2BAAkB,MAAM;AAAA,IAExB;AAAA;AAAA,EA5DA,WAAW,eAAwD;AAC/D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,WAAW;AAAA,QACX,aAAa;AAAA,QACb,eAAe;AAAA,QACf,WAAW;AAAA,QACX,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,EACJ;AAAA,EAKA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,MAAM,SAAS,cAAc,KAAK;AACvC,SAAK,OAAO,SAAS,cAAc,MAAM;AACzC,SAAK,KAAK,YAAY,KAAK,MAAM;AACjC,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAWA,QAAQ;AACJ,SAAK,IAAI,YAAY,KAAK,IAAI;AAC9B,SAAK,UAAU,YAAY,KAAK,GAAG;AACnC,WAAO,MAAM,MAAM;AAAA,EACvB;AAAA,EACA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,IAAI,iBAAiB,aAAa,KAAK,eAAe;AAC3D,SAAK,IAAI,iBAAiB,cAAc,KAAK,gBAAgB;AAC7D,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,UAAM,cAAc,MAAM,KAAK,KAAK,YAAY,KAAK,MAAM;AAC3D,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,WAAW,CAAC;AACjD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;AACnD,WAAO;AAAA,EACX;AAOJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7E0C;AAGhB;AAUX,MAAM,kBAAkB,qDAAY,CAAuB;AAAA,EAA1E;AAAA;AAuBI,qBAAY;AAuBZ,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,OAAO,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AACtF,YAAM,WAAW,KAAK,IAAI,SAAS,OAAO,MAAM,QAAQ,OAAO,GAAG;AAClE,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY;AAC3C,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,UAAU,MAAM,kBAAkB;AACvC,WAAK,UAAU,MAAM,cAAc;AAAA,IACvC;AA6BA,sBAAa;AACb,oBAAW;AAEX,iBAAQ,MAAM;AACV,YAAM,EAAE,UAAU,YAAY,WAAW,WAAW,UAAU,cAAc,IAAI,KAAK,MAAM;AAC3F,YAAM,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,MAAM,IAAI,KAAK;AACrD,YAAM,MAAM,KAAK;AACjB,YAAM,SAAS,KAAK;AACpB,YAAM,QAAQ,OAAO,oBAAoB;AACzC,UAAI,EAAE,OAAO,OAAO,IAAI,KAAK,UAAU,sBAAsB;AAC7D,cAAQ,KAAK,MAAM,KAAK;AACxB,eAAS,KAAK,MAAM,MAAM;AAC1B,YAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,YAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,aAAO,QAAQ;AACf,aAAO,SAAS;AAGhB,UAAI,MAAM,OAAO,KAAK;AAEtB,YAAM,aAAa,SAAS;AAC5B,YAAM,YAAY,YAAY,KAAK,IAAI,QAAQ,GAAG,aAAa,IAAI;AACnE,YAAM,QAAQ,QAAQ,aAAa;AACnC,YAAM,MAAM,SAAS;AACrB,WAAK,aAAa;AAClB,YAAM,aAAa,KAAK;AACxB,UAAI,aAAa,KAAK,UAAU;AAC5B,aAAK,WAAW;AAChB,YAAI,KAAK;AAAU,iBAAO,aAAa,KAAK,QAAQ;AACpD,aAAK,WAAW,OAAO,WAAW,MAAM;AACpC,eAAK,WAAW,KAAK;AACrB,eAAK,WAAW;AAChB,eAAK,SAAS,KAAK,KAAK;AAAA,QAC5B,GAAG,GAAI;AAAA,MACX;AACA,UAAI,aAAa,KAAK,YAAY,OAAO,KAAK,aAAa,aAAa;AACpE,aAAK,WAAW,OAAO,WAAW,MAAM;AACpC,eAAK,WAAW,KAAK;AACrB,eAAK,WAAW;AAChB,eAAK,SAAS,KAAK,KAAK;AAAA,QAC5B,GAAG,GAAI;AAAA,MACX;AACA,YAAM,WAAW,KAAK;AACtB,YAAM,YAAY,MAAM,QAAQ,MAAM;AACtC,YAAM,YAAY,KAAK,QAAQ,MAAM;AACrC,YAAM,WAAW,KAAK,QAAQ,MAAM;AACpC,YAAM,eAAe,KAAK,IAAI,GAAG,CAAC,OAAO,MAAM,IAAI;AACnD,YAAM,WAAW,IAAI,qBAAqB,GAAG,YAAY,GAAG,GAAG;AAC/D,UAAI,YAAY,KAAK,YAAY;AAAG,iBAAS,aAAa,UAAU,SAAS;AAAA,eACpE,WAAW;AAAG,iBAAS,aAAa,GAAG,SAAS;AACzD,UAAI,YAAY,KAAK,YAAY;AAAG,iBAAS,aAAa,UAAU,SAAS;AAC7E,UAAI,WAAW,KAAK,WAAW;AAAG,iBAAS,aAAa,SAAS,QAAQ;AACzE,UAAI,gBAAgB,KAAK,gBAAgB;AAAG,iBAAS,aAAa,cAAc,aAAa;AAAA,eACpF,eAAe;AAAG,iBAAS,aAAa,GAAG,SAAS;AAE7D,UAAI,YAAY;AAChB,UAAI,aAAa;AAAG,YAAI,SAAS,MAAM,OAAO,IAAI,gBAAgB,YAAY,WAAW,aAAa,YAAY;AAClH,UAAI,aAAa;AAAK,YAAI,SAAS,MAAM,KAAK,YAAY,IAAI,gBAAgB,aAAa,CAAC;AAC5F,UAAI,YAAY;AAChB,UAAI,aAAa,KAAK;AAClB,cAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,GAAG,UAAU,EAAE,CAAC,CAAC;AACvH,YAAI,SAAS,MAAM,OAAO,IAAI,YAAY,YAAY,WAAW,aAAa,QAAQ;AAAA,MAC1F;AACA,UAAI,aAAa,GAAG;AAChB,cAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,KAAK,UAAU,EAAE,CAAC,IAAI,YAAY;AACxI,YAAI,SAAS,MAAM,OAAO,IAAI,eAAe,YAAY,YAAY,WAAW,aAAa,WAAW,CAAC;AAAA,MAC7G;AACA,UAAI,WAAW,YAAY;AACvB,YAAI,YAAY,GAAG;AACf,gBAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,GAAG,QAAQ,EAAE,CAAC,CAAC;AACrH,cAAI,SAAS,MAAM,OAAO,IAAI,YAAY,YAAY,WAAW,CAAC;AAAA,QACtE;AACA,YAAI,WAAW,GAAG;AACd,gBAAM,WAAW,KAAK,IAAI,GAAG,qDAAY,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,OAAO,OAAO,OAAO,KAAK,IAAI,KAAK,QAAQ,EAAE,CAAC,IAAI,YAAY;AACtI,cAAI,SAAS,MAAM,KAAK,IAAI,KAAK,OAAO,IAAI,eAAe,YAAY,aAAa,CAAC,GAAG,WAAW,CAAC;AAAA,QACxG;AAAA,MACJ;AAAA,IACJ;AAAA;AAAA,EA9JA,WAAW,eAAuD;AAC9D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,QACX,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,WAAW;AAAA,QACX,WAAW;AAAA,QACX,UAAU;AAAA,QACV,eAAe;AAAA,MACnB;AAAA,IACJ;AAAA,EACJ;AAAA,EAQA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,UAAU,SAAS,cAAc,KAAK;AAC3C,SAAK,QAAQ,YAAY,sBAAsB,KAAK;AACpD,SAAK,YAAY,SAAS,cAAc,KAAK;AAC7C,SAAK,UAAU,YAAY,sBAAsB,KAAK;AACtD,SAAK,SAAS,SAAS,cAAc,QAAQ;AAC7C,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,SAAS;AACrB,SAAK,MAAM,KAAK,OAAO,WAAW,IAAI;AACtC,SAAK,QAAQ,SAAS,cAAc,OAAO;AAC3C,SAAK,MAAM,WAAW;AACtB,SAAK,MAAM,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS,KAAK,KAAK,MAAM,QAAQ;AACnF,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EASA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,OAAO,iBAAiB,aAAa,KAAK,eAAe;AAC9D,SAAK,OAAO,iBAAiB,cAAc,KAAK,kBAAkB,EAAE,SAAS,MAAM,CAAC;AACpF,SAAK,GAAG,SAAS,MAAM;AACnB,WAAK,SAAS,KAAK,QAAQ;AAC3B,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,UAAM,cAAc,MAAM,KAAK,MAAM,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS,KAAK,KAAK,MAAM,QAAQ;AAC7G,SAAK,GAAG,SAAS,MAAM;AACnB,WAAK,SAAS,WAAW;AACzB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,SAAK,GAAG,OAAO,MAAM,KAAK,SAAS,KAAK,KAAK,CAAC;AAC9C,SAAK,GAAG,OAAO,MAAM,KAAK,SAAS,KAAK,KAAK,CAAC;AAC9C,SAAK,GAAG,QAAQ,MAAM,KAAK,SAAS,KAAK,KAAK,CAAC;AAC/C,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,MAAM;AACtC,SAAK,QAAQ,YAAY,KAAK,SAAS;AACvC,SAAK,QAAQ,YAAY,KAAK,KAAK;AACnC,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,OAAO;AACvC,WAAO,MAAM,MAAM;AAAA,EACvB;AA+EJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7K0C;AAC0C;AAG5D;AAQT,MAAM,gBAAgB,qDAAY,CAAqB;AAAA,EAAtE;AAAA;AAqBI,qBAAY;AAQZ,2BAA4B,CAAC,GAAG,GAAG,GAAG,CAAC;AAuBvC,wBAAe,CAAC,MAAa;AACzB,YAAM,QAAQ,WAAY,EAAE,cAAmC,KAAK;AACpE,UAAI,SAAS,KAAK,GAAG;AACjB,cAAM,UAAU,KAAK,SAAS,CAAC,KAAK;AACpC,YAAI;AAAS;AAAA,MACjB;AACA,WAAK,MAAM,QAAQ,KAAK,YAAY,SAAS,KAAK,MAAM,QAAQ;AAAA,IACpE;AACA,oBAAW,MAAM;AACb,YAAM,EAAE,QAAQ,OAAO,MAAM,UAAU,WAAW,SAAS,YAAY,IAAI,KAAK,MAAM;AACtF,YAAM,WAAW,KAAK,IAAI,SAAS,OAAO,MAAM,QAAQ,OAAO,GAAG;AAClE,WAAK,MAAM,MAAM,WAAW,GAAG,YAAY;AAC3C,WAAK,MAAM,MAAM,QAAQ;AACzB,WAAK,UAAU,MAAM,kBAAkB;AACvC,WAAK,UAAU,MAAM,cAAc;AAAA,IACvC;AA6CA,iBAAQ,MAAM;AACV,YAAM,EAAE,aAAa,eAAe,iBAAiB,YAAY,IAAI,KAAK,MAAM;AAChF,YAAM,MAAM,KAAK;AACjB,YAAM,SAAS,KAAK;AACpB,YAAM,WAAW,KAAK;AACtB,YAAM,QAAQ,OAAO,oBAAoB;AACzC,UAAI,EAAE,OAAO,OAAO,IAAI,KAAK,UAAU,sBAAsB;AAC7D,cAAQ,KAAK,MAAM,KAAK;AACxB,eAAS,KAAK,MAAM,MAAM;AAC1B,YAAM,cAAc,KAAK,MAAM,QAAQ,KAAK;AAC5C,YAAM,eAAe,KAAK,MAAM,SAAS,KAAK;AAC9C,aAAO,QAAQ;AACf,aAAO,SAAS;AAGhB,UAAI,MAAM,OAAO,KAAK;AAEtB,YAAM,aAAa,SAAS;AAC5B,YAAM,YAAY,eAAe,KAAK,IAAI,QAAQ,GAAG,aAAa,IAAI;AACtE,YAAM,QAAQ,QAAQ,aAAa;AACnC,YAAM,MAAM,SAAS;AACrB,YAAM,eAAe,YAAY;AACjC,WAAK,kBAAkB,CAAC,GAAG,KAAK,OAAO,UAAU;AACjD,YAAM,MAAM,IAAI,qBAAqB,GAAG,KAAK,GAAG,MAAM,UAAU;AAChE,UAAI,aAAa,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,aAAa;AACtE,UAAI,aAAa,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,eAAe;AACxE,UAAI,YAAY;AAChB,6DAAe,CAAC,KAAK,MAAM,KAAK,WAAW,YAAY,YAAY;AAEnE,UAAI,YAAY;AAChB,6DAAe,CAAC,KAAK,OAAO,WAAW,MAAM,cAAc,IAAI,YAAY,WAAW,YAAY,GAAG,YAAY,GAAG,YAAY;AAAA,IACpI;AA+BA,6BAAoB,CAAC,MAAwB;AACzC,YAAM,EAAE,MAAM,IAAI,KAAK;AACvB,UACI,EAAE,IAAI,KAAK,gBAAgB,CAAC,KACzB,EAAE,IAAI,KAAK,gBAAgB,CAAC,IAAI,KAAK,gBAAgB,CAAC,KACtD,EAAE,IAAI,KAAK,gBAAgB,CAAC,KAC5B,EAAE,IAAI,KAAK,gBAAgB,CAAC,IAAI,KAAK,gBAAgB,CAAC;AAC3D;AACF,YAAM,WAAW,KAAK,gBAAgB,CAAC;AACvC,UAAI,aAAa;AAAO,aAAK,SAAS,KAAK,gBAAgB,CAAC,CAAC;AAAA,IACjE;AACA,6BAAoB,CAAC,MAAwB;AACzC,YAAM,WAAW,KAAK,gBAAgB,CAAC;AACvC,UAAI,aAAa,KAAK,MAAM;AAAO,aAAK,SAAS,QAAQ;AAAA,IAC7D;AAAA;AAAA,EA3LA,WAAW,eAAqD;AAC5D,UAAM,YAAY,MAAM;AACxB,WAAO,iCACA,YADA;AAAA,MAEH,OAAO,iCACA,UAAU,QADV;AAAA,QAEH,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,SAAS;AAAA,QACT,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,WAAW;AAAA,QACX,aAAa;AAAA,QACb,eAAe;AAAA,QACf,iBAAiB;AAAA,QACjB,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,EACJ;AAAA,EAUA,qBAAqB;AACjB,UAAM,mBAAmB;AACzB,SAAK,UAAU,SAAS,cAAc,KAAK;AAC3C,SAAK,QAAQ,YAAY,sBAAsB,KAAK;AACpD,SAAK,YAAY,SAAS,cAAc,KAAK;AAC7C,SAAK,UAAU,YAAY,sBAAsB,KAAK;AACtD,SAAK,SAAS,SAAS,cAAc,QAAQ;AAC7C,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,SAAS;AACrB,SAAK,MAAM,KAAK,OAAO,WAAW,IAAI;AACtC,SAAK,cAAc,SAAS,cAAc,OAAO;AACjD,SAAK,YAAY,OAAO;AACxB,SAAK,YAAY,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS;AACjE,SAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AAC/C,SAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AAC/C,SAAK,YAAY,OAAO,KAAK,MAAM,KAAK,SAAS;AACjD,SAAK,QAAQ,SAAS,cAAc,OAAO;AAC3C,SAAK,MAAM,QAAQ,KAAK,YAAY,SAAS,KAAK,MAAM,QAAQ;AAChE,SAAK,MAAM,aAAa;AACxB,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAiBA,oBAAoB;AAChB,UAAM,kBAAkB;AACxB,SAAK,MAAM,iBAAiB,UAAU,KAAK,YAAY;AACvD,SAAK,OAAO,iBAAiB,aAAa,KAAK,eAAe;AAC9D,SAAK,OAAO,iBAAiB,cAAc,KAAK,kBAAkB,EAAE,SAAS,MAAM,CAAC;AACpF,SAAK,GAAG,SAAS,MAAM;AACnB,WAAK,SAAS,KAAK,QAAQ;AAC3B,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,SAAK,GAAG,SAAS,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC;AACrD,UAAM,cAAc,MAAM;AACtB,WAAK,YAAY,SAAS,CAAC,KAAK,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS;AACjE,WAAK,MAAM,QAAQ,KAAK,YAAY,SAAS,KAAK,MAAM,QAAQ;AAAA,IACpE;AACA,SAAK,GAAG,SAAS,MAAM;AACnB,WAAK,SAAS,WAAW;AACzB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,UAAM,YAAY,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AACvE,SAAK,GAAG,OAAO,MAAM;AACjB,WAAK,SAAS,SAAS;AACvB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,UAAM,YAAY,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,IAAI,SAAS;AACvE,SAAK,GAAG,OAAO,MAAM;AACjB,WAAK,SAAS,SAAS;AACvB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,UAAM,aAAa,MAAM,KAAK,YAAY,OAAO,KAAK,MAAM,KAAK,SAAS;AAC1E,SAAK,GAAG,QAAQ,MAAM;AAClB,WAAK,SAAS,UAAU;AACxB,WAAK,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AACD,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,YAAY,KAAK,MAAM;AACtC,SAAK,QAAQ,YAAY,KAAK,SAAS;AACvC,SAAK,QAAQ,YAAY,KAAK,KAAK;AACnC,SAAK,UAAU,YAAY,KAAK,KAAK;AACrC,SAAK,UAAU,YAAY,KAAK,OAAO;AACvC,WAAO,MAAM,MAAM;AAAA,EACvB;AAAA,EAiCA,IAAI,aAAa;AACb,UAAM,EAAE,MAAM,KAAK,KAAK,MAAM,MAAM,IAAI,KAAK;AAC7C,UAAM,WAAW,SAAS,SAAS,MAAM,SAAS,SAAS,QAAQ,MAAM,OAAO,MAAM,OAAO;AAC7F,QAAI,MAAM;AACN,UAAI,SAAS;AAAQ,eAAO,MAAM;AAClC,UAAI,SAAS;AAAO,eAAO,KAAK,IAAI,KAAK,OAAO,MAAM,QAAQ,KAAK,MAAM,IAAI,KAAK,EAAE,GAAG,QAAQ;AAC/F,aAAO,KAAK,OAAO,MAAM,OAAO,IAAI;AAAA,IACxC;AACA,WAAO;AAAA,EACX;AAAA,EACA,IAAI,YAAY;AACZ,UAAM,OAAO,KAAK,gBAAgB,KAAK,cAAc,YAAY,IAAI,CAAC;AACtE,UAAM,aAAa,KAAK;AACxB,WAAO,OAAO;AAAA,EAClB;AAAA,EACA,gBAAgB,GAA6B;AACzC,UAAM,EAAE,MAAM,KAAK,KAAK,MAAM,IAAI,KAAK;AACvC,UAAM,OAAO,SAAS,SAAS,IAAK,KAAK,MAAM,QAAQ;AACvD,UAAM,YAAY,KAAK;AACvB,UAAM,aAAa,KAAK;AACxB,UAAM,WAAY,KAAK,cAAc,YAAY,KAAK,gBAAgB,CAAC,KAAK,EAAE,IAAI,KAAK,gBAAgB,CAAC,KAAK,EAAE,IAAI,KAAK,gBAAgB,CAAC;AACzI,UAAM,QAAQ,KAAK,cAAc,YAAY,KAAK,gBAAgB,CAAC,IAAI,KAAK,gBAAgB,CAAC;AAC7F,UAAM,eAAe,mDAAW,CAAC,WAAW,OAAO,KAAK,GAAG;AAC3D,UAAM,IAAI,UAAU,QAAQ,+CAAO,CAAC,cAAc,KAAK,GAAG,IAAI,UAAU,QAAQ,+CAAO,CAAC,cAAc,KAAK,GAAG,IAAI;AAClH,QAAI,QAAQ,KAAK,MAAM,iDAAS,CAAC,GAAG,KAAK,GAAG,IAAI,QAAQ,SAAS;AACjE,YAAQ,KAAK,IAAI,YAAY,KAAK,IAAI,GAAG,KAAK,CAAC;AAC/C,QAAI,SAAS;AAAQ,aAAO;AAC5B,QAAI,SAAS;AAAO,aAAO,KAAK,MAAM,QAAQ,OAAO,GAAG;AACxD,WAAO,QAAQ,OAAO;AAAA,EAC1B;AAgBJ;;;;;;;;;;;;;;;;;;;;;;;;;;ACzMO,MAAM,SAAS,CAAC,MAAc,CAAC,KAAK,MAAM,KAAK,MAAM,KAAK,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,GAAG,GAAG,IAAI,KAAK,MAAM,EAAE,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC;AAC3I,MAAM,QAAQ,CAAC,YAAoB,UAAU,KAAK,KAAK;AACvD,MAAM,QAAQ,CAAC,MAAc,KAAK,KAAK,MAAM,CAAC;AAC9C,MAAM,QAAQ,CAAC,OAAe,OAAO,KAAK;AAC1C,MAAM,cAAc,CAAC,GAAW,KAAa,QAAgB,OAAO,MAAM,OAAO;AACjF,MAAM,YAAY,CAAC,GAAW,KAAa,SAAiB,IAAI,QAAQ,MAAM,QAAQ;AACtF,MAAM,UAAU,CAAC,GAAW,KAAa,QAAgB;AAC5D,QAAM,aAAa,UAAU,GAAG,KAAK,GAAG;AACxC,QAAM,SAAS,KAAK,IAAI,KAAK,IAAI,OAAO,SAAS,GAAG,CAAC;AACrD,QAAM,SAAS,KAAK,IAAI,KAAK,IAAI,OAAO,SAAS,GAAG,CAAC;AACrD,QAAM,OAAO,YAAY,YAAY,QAAQ,MAAM;AACnD,QAAM,IAAI,KAAK,IAAI,IAAI;AACvB,SAAO,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,CAAC;AACzC;AACO,MAAM,WAAW,CAAC,KAAa,KAAa,QAAgB;AAC/D,QAAM,IAAI,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC;AAC1C,QAAM,OAAO,KAAK,IAAI,KAAK,IAAI,OAAO,SAAS,CAAC,CAAC;AACjD,QAAM,SAAS,KAAK,IAAI,KAAK,IAAI,OAAO,SAAS,GAAG,CAAC;AACrD,QAAM,SAAS,KAAK,IAAI,KAAK,IAAI,OAAO,SAAS,GAAG,CAAC;AACrD,QAAM,aAAa,UAAU,MAAM,QAAQ,MAAM;AACjD,SAAO,YAAY,YAAY,KAAK,GAAG;AAC3C;AACO,MAAM,UAAU;AAChB,MAAM,WAAW;AACjB,MAAM,cAAc,CAAC,KAA+B,GAAW,GAAW,OAAe,QAAgB,WAA8B;AAC1I,QAAM,QAAQ,CAAC,GAAG,GAAG,GAAG,CAAC;AACzB,MAAI,OAAO,WAAW;AAAU,UAAM,KAAK,MAAM;AAAA;AAC5C,WAAO,QAAQ,CAAC,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC;AAC1C,MAAI,UAAU;AACd,MAAI,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC;AAC1B,MAAI,OAAO,IAAI,QAAQ,MAAM,CAAC,GAAG,CAAC;AAClC,MAAI,iBAAiB,IAAI,OAAO,GAAG,IAAI,OAAO,IAAI,MAAM,CAAC,CAAC;AAC1D,MAAI,OAAO,IAAI,OAAO,IAAI,SAAS,MAAM,CAAC,CAAC;AAC3C,MAAI,iBAAiB,IAAI,OAAO,IAAI,QAAQ,IAAI,QAAQ,MAAM,CAAC,GAAG,IAAI,MAAM;AAC5E,MAAI,OAAO,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM;AACnC,MAAI,iBAAiB,GAAG,IAAI,QAAQ,GAAG,IAAI,SAAS,MAAM,CAAC,CAAC;AAC5D,MAAI,OAAO,GAAG,IAAI,MAAM,CAAC,CAAC;AAC1B,MAAI,iBAAiB,GAAG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC;AAC1C,MAAI,UAAU;AACd,MAAI,OAAO;AACf;AACO,MAAM,kBAAkB,CAAC,KAA+B,GAAW,GAAW,OAAe,QAAgB,WAA8B;AAC9I,QAAM,QAAQ,CAAC,GAAG,GAAG,GAAG,CAAC;AACzB,MAAI,OAAO,WAAW;AAAU,UAAM,KAAK,MAAM;AAAA;AAC5C,WAAO,QAAQ,CAAC,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC;AAC1C,MAAI,UAAU;AACd,MAAI,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC;AAC1B,MAAI,OAAO,IAAI,QAAQ,MAAM,CAAC,GAAG,CAAC;AAClC,MAAI,iBAAiB,IAAI,OAAO,GAAG,IAAI,OAAO,IAAI,MAAM,CAAC,CAAC;AAC1D,MAAI,OAAO,IAAI,OAAO,IAAI,SAAS,MAAM,CAAC,CAAC;AAC3C,MAAI,iBAAiB,IAAI,OAAO,IAAI,QAAQ,IAAI,QAAQ,MAAM,CAAC,GAAG,IAAI,MAAM;AAC5E,MAAI,OAAO,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM;AACnC,MAAI,iBAAiB,GAAG,IAAI,QAAQ,GAAG,IAAI,SAAS,MAAM,CAAC,CAAC;AAC5D,MAAI,OAAO,GAAG,IAAI,MAAM,CAAC,CAAC;AAC1B,MAAI,iBAAiB,GAAG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC;AAC1C,MAAI,UAAU;AACd,MAAI,KAAK;AACb;;;;;;;;;;;;;;;;ACzDgC;AAEhC,MAAM,cAAc,MAAM;AACtB,QAAM,UAAU,IAAI,gDAAO,CAAC;AAAA,IACxB,MAAM,SAAS,eAAe,MAAM;AAAA,IACpC,oBAAoB;AAAA,IACpB,qBAAqB;AAAA,EACzB,CAAC;AACD,MAAI;AACJ,SAAO,iBAAiB,WAAW,CAAC,MAAM;AACtC,UAAM,EAAE,OAAO,IAAI;AACnB,WAAO;AAAA,EACX,CAAC;AAED,SAAO,iBAAiB,WAAW,CAAC,MAAM;AACtC,QAAI;AAAM,WAAK,YAAY,EAAE,MAAM,WAAW,KAAK,EAAE,IAAI,GAAG,GAAG;AAAA,EACnE,CAAC;AACD,SAAO,iBAAiB,SAAS,CAAC,MAAM;AACpC,QAAI;AAAM,WAAK,YAAY,EAAE,MAAM,SAAS,KAAK,EAAE,IAAI,GAAG,GAAG;AAAA,EACjE,CAAC;AACD,EAAC,OAAe,UAAU;AAC9B;AAEA,iEAAe,WAAW,EAAC;;;;;;;;;;;;;;;AClB3B,MAA8B,iBAA9B,MAA6D;AAAA,EAUzD,YAAY,OAA2F,QAAkB;AACrH,SAAK,SAAS,CAAC,CAAC;AAChB,WAAO,OAAO,MAAM,KAAK;AACzB,UAAM,EAAE,gBAAgB,eAAe,IAAI;AAC3C,UAAM,SAAS,kBAAkB,iBAAiB,SAAS,iBAAiB,eAAe,iBAAiB,aAAa;AACzH,SAAK,SAAS;AAAA,MACV,MAAM,MAAM;AAAA,MACZ,OAAO,eAAc,UAAU;AAAA,MAC/B,QAAQ,eAAc,UAAU,KAAK,KAAK,SAAS,IAAI,eAAc;AAAA,MACrE;AAAA,IACJ;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,iBAA0B;AAC1B,WAAO,CAAC,CAAC,KAAK,MAAM,KAAK,CAAC,SAAS;AAC/B,UAAI,gBAAgB;AAAe,eAAO,KAAK;AAC/C,aAAO,KAAK,OAAO,WAAW,gBAAgB,KAAK,OAAO,WAAW;AAAA,IACzE,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,iBAA0B;AAC1B,WAAO,CAAC,CAAC,KAAK,MAAM,KAAK,CAAC,SAAS;AAC/B,UAAI,gBAAgB;AAAe,eAAO,KAAK;AAC/C,aAAO,KAAK,OAAO,WAAW,cAAc,KAAK,OAAO,WAAW;AAAA,IACvE,CAAC;AAAA,EACL;AAAA,EACA,SAAS;AACL,WAAO;AAAA,EACX;AAAA,EACA,OAAO,IAAY,IAAY;AAC3B,WAAO;AAAA,EACX;AAAA,EACA,SAAS;AACL,WAAO;AAAA,EACX;AACJ;AAlDA,IAA8B,gBAA9B;AAA8B,cACnB,UAAU;AADS,cAEnB,cAAc;AAFK,cAGnB,eAAe;AAR1B;;;;;;;;;;;;;;;;ACC0C;AAE3B,MAAe,0BAA0B,qDAAY,CAAC;AAAA,EAGjE,YAAY,MAAwB;AAChC,UAAM,IAAI;AACV,SAAK,OAAO,CAAC,KAAK,QAAQ;AAC1B,SAAK,OAAO,CAAC,KAAK,QAAQ;AAAA,EAC9B;AACJ;;;;;;;;;;;;;;;ACPe,MAAe,aAA8B;AAAA,EAWxD,YAAY,MAAmB;AAC3B,WAAO,OAAO,MAAM,IAAI;AACxB,SAAK,MAAM,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,MAAM;AAC7C,SAAK,MAAM,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,MAAM;AAAA,EACjD;AAAA,EAEA,SAAe;AACX,WAAO;AAAA,EACX;AAAA,EACA,OAAO,IAAY,IAAkB;AACjC,WAAO;AAAA,EACX;AAAA,EACA,SAAe;AACX,WAAO;AAAA,EACX;AACJ;;;;;;;;;;;;;;;;AC9B0C;AAE3B,MAAe,2BAA2B,qDAAY,CAAC;AACtE;;;;;;;;;;;;;;;;ACHoD;AAGrC,MAAM,eAAe,0DAAiB,CAAC;AAAA,EAAtD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVoD;AAGrC,MAAM,iBAAiB,0DAAiB,CAAC;AAAA,EAAxD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVsD;AAGvC,MAAM,kBAAkB,2DAAkB,CAAC;AAAA,EAA1D;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACV4C;AAE7B,MAAM,eAAe,sDAAa,CAAC;AAAA,EAC9C,SAAS;AACL,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,WAAK,OAAO;AACZ,WAAK,OAAO,SAAS,KAAK,OAAO;AACjC,WAAK,OAAO,SAAS,KAAK,IAAI,KAAK,OAAO,QAAQ,KAAK,OAAO,SAAS,IAAI,sDAAa,CAAC,WAAW,KAAK,SAAS,IAAI,sDAAa,CAAC,YAAY;AAAA,IACpJ,CAAC;AACD,SAAK,OAAO,SAAS,sDAAa,CAAC,gBAAgB,KAAK,MAAM,SAAS;AACvE,QAAI,KAAK,OAAO,QAAQ;AAAG,WAAK,OAAO,SAAS;AAChD,WAAO;AAAA,EACX;AAAA,EACA,OAAO,IAAY;AACf,QAAI,eAAe;AACnB,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW;AAAc;AAAA,IAC9E,CAAC;AACD,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,UAAI,MAAM;AACV,UAAI,MAAM;AACV,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW,cAAc;AACtE,cAAM,eAAe,KAAK,eAAe;AACzC,aAAK,OAAO,SAAS;AAAA,MACzB;AACA,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW,YAAY;AACpE,cAAM,KAAK,OAAO,SAAS,IAAI,sDAAa,CAAC,WAAW,KAAK,SAAS,IAAI,sDAAa,CAAC,eAAe,KAAK,OAAO;AACnH,aAAK,OAAO,UAAU;AAAA,MAC1B;AACA,WAAK,OAAO,KAAK,GAAG;AAAA,IACxB,CAAC;AAED,WAAO;AAAA,EACX;AAAA,EACA,SAAS;AACL,UAAM,EAAE,aAAa,SAAS,aAAa,IAAI,sDAAa;AAC5D,QAAI,QAAQ;AACZ,UAAM,OAAO,WAAW,KAAK,SAAS,IAAI;AAC1C,UAAM,EAAE,OAAO,IAAI,KAAK;AACxB,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,WAAK,OAAO,aAAa;AACzB,WAAK,OAAO,YAAY;AAExB,WAAK,OAAO,cAAc,UAAU,KAAK,SAAS,IAAI,eAAe,KAAK,OAAO,UAAU,IAAI;AAC/F,WAAK,OAAO,QAAQ,KAAK,OAAO,QAAQ,KAAK,KAAK,OAAO;AACzD,WAAK,OAAO,OAAO,KAAK,OAAO,OAAO,KAAK,KAAK,OAAO;AACvD,WAAK,OAAO;AACZ,eAAS,KAAK,OAAO,QAAQ;AAAA,IACjC,CAAC;AACD,WAAO;AAAA,EACX;AACJ;;;;;;;;;;;;;;;;ACnDoD;AAGrC,MAAM,gBAAgB,0DAAiB,CAAC;AAAA,EAAvD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVoD;AAGrC,MAAM,aAAa,0DAAiB,CAAC;AAAA,EAApD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACTgC;AACA;AACF;AACM;AACN;AACI;AACR;AACA;AACE;AACJ;AACY;AACA;AACA;AACN;AACA;AACA;AAKf,MAAM,OAAO;AAAA;AAAA;AAAA;AAAA,EAIxB,OAAO,YAAY,MAAgC;AAC/C,QAAI,KAAK,SAAS,YACX,KAAK,SAAS,YACd,KAAK,SAAS,YACd,KAAK,SAAS,YACd,KAAK,SAAS,cACd,KAAK,SAAS;AACnB,aAAO,KAAK;AACd,QAAI,KAAK,SAAS,eAAe,KAAK,SAAS,aAAa;AACxD,UAAI,KAAK,QAAQ,KAAK,KAAK,KAAK,UAAQ,KAAK,SAAS,KAAK,MAAM,WAAW,KAAK,CAAC;AAAG,eAAO;AAC5F,UAAI,KAAK,QAAQ,KAAK,KAAK,KAAK,UAAQ,KAAK,SAAS,KAAK,MAAM,WAAW,WAAW,CAAC;AAAG,eAAO;AAClG,aAAO,KAAK;AAAA,IAChB;AACA,QAAI,KAAK,SAAS,aAAa,KAAK,SAAS,YAAY,KAAK,SAAS,WAAW;AAC9E,UAAI,KAAK,QAAQ,KAAK,KAAK,KAAK,UAAQ,KAAK,SAAS,KAAK,MAAM,WAAW,MAAM,CAAC;AAAG,eAAO;AAC7F,UAAI,KAAK,QAAQ,KAAK,KAAK,KAAK,UAAQ,KAAK,SAAS,KAAK,MAAM,WAAW,MAAM,CAAC;AAAG,eAAO;AAC7F,UAAI,KAAK,QAAQ,KAAK,KAAK,KAAK,UAAQ,KAAK,SAAS,KAAK,MAAM,WAAW,OAAO,CAAC;AAAG,eAAO;AAAA,IAClG;AACA,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAIA,OAAO,QAAQ,MAAiD;AAC5D,UAAM,OAAO;AAAA,MACT,SAAS,gDAAO;AAAP,MACT,SAAS,gDAAO;AAAP,MACT,QAAQ,+CAAM;AAAN,MACR,WAAW,kDAAS;AAAT,MACX,QAAQ,+CAAM;AAAN,MACR,UAAU,iDAAQ;AAAR,MACV,MAAM,6CAAI;AAAJ,MACN,MAAM,6CAAI;AAAJ,MACN,OAAO,8CAAK;AAAL,MACP,KAAK,4CAAG;AAAH,MACL,WAAW,mDAAS;AAAT,MACX,WAAW,mDAAS;AAAT,MACX,WAAW,mDAAS;AAAT,MACX,QAAQ,gDAAM;AAAN,MACR,QAAQ,gDAAM;AAAN,MACR,QAAQ,gDAAM;AAAN,IACZ;AACA,UAAM,aAAa,KAAK,YAAY,IAAI;AACxC,WAAO,IAAI,KAAK,UAAU,EAAE,IAAW;AAAA,EAC3C;AAAA,EACA,OAAO,SAAS,OAAsB;AAClC,WAAO,MAAM,IAAI,CAAC,SAAS;AACvB,UAAI,WAAW;AAAM,aAAK,QAAQ,KAAK,SAAS,KAAK,KAAK;AAC1D,aAAO,KAAK,QAAQ,IAAI;AAAA,IAC5B,CAAC;AAAA,EACL;AAAA,EACA,OAAO,KAAK,IAAmB;AAC3B,UAAM,YAAY,IAAI,gDAAM,CAAC,EAAE,OAAO,KAAK,SAAS,EAAE,GAAG,MAAM,UAAU,OAAO,GAAG,GAAG,IAAI;AAC1F,cAAU,OAAO;AACjB,cAAU,OAAO,GAAG,CAAC;AACrB,cAAU,OAAO;AACjB,WAAO;AAAA,EACX;AACJ;;;;;;;;;;;;;;;;ACnFsD;AAGvC,MAAM,YAAY,2DAAkB,CAAC;AAAA,EAApD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVoD;AAGrC,MAAM,aAAa,0DAAiB,CAAC;AAAA,EAApD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVoD;AAGrC,MAAM,eAAe,0DAAiB,CAAC;AAAA,EAAtD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVsD;AAGvC,MAAM,kBAAkB,2DAAkB,CAAC;AAAA,EAA1D;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVoD;AAGrC,MAAM,cAAc,0DAAiB,CAAC;AAAA,EAArD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACVoD;AAGrC,MAAM,kBAAkB,0DAAiB,CAAC;AAAA,EAAzD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACV4C;AAE5C,MAAqB,UAArB,cAAoC,sDAAa,CAAC;AAAA,EAK9C,SAAS;AACL,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,WAAK,OAAO;AACZ,WAAK,OAAO,QAAQ,KAAK,IAAI,KAAK,OAAO,OAAO,KAAK,OAAO,QAAQ,IAAI,sDAAa,CAAC,OAAO;AAC7F,WAAK,OAAO,SAAS,KAAK,IAAI,KAAK,OAAO,QAAQ,KAAK,OAAO,SAAS,IAAI,sDAAa,CAAC,UAAU,QAAO,WAAW;AAAA,IACzH,CAAC;AACD,UAAM,YAAY,KAAK,MAAM;AAC7B,SAAK,OAAO,QAAQ,KAAK,IAAI,KAAK,OAAO,OAAO,YAAY,QAAO,UAAU,KAAK;AAClF,SAAK,OAAO,UAAU,QAAO,UAAU;AACvC,QAAI,KAAK,OAAO,QAAQ;AAAG,WAAK,OAAO,SAAS;AAChD,WAAO;AAAA,EACX;AAAA,EACA,SAAS;AACL,UAAM,YAAY,KAAK,MAAM;AAC7B,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,UAAI,MAAM;AACV,UAAI,MAAM;AACV,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW;AAAc,cAAM,KAAK,OAAO,QAAQ,IAAI,sDAAa,CAAC,UAAU,KAAK,OAAO;AAC5I,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW;AAAY,cAAM,KAAK,OAAO,SAAS,IAAI,sDAAa,CAAC,WAAW,KAAK,SAAS,IAAI,sDAAa,CAAC,gBAAgB,YAAY,QAAO,UAAU,SAAS,KAAK,KAAK,OAAO;AACvO,WAAK,OAAO,KAAK,GAAG;AAAA,IACxB,CAAC;AACD,WAAO;AAAA,EACX;AAAA,EACA,SAAS;AACL,UAAM,EAAE,aAAa,QAAQ,IAAI,sDAAa;AAC9C,UAAM,QAAQ;AACd,UAAM,OAAO,WAAW,KAAK,SAAS,IAAI,eAAe,QAAO,UAAU;AAC1E,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,WAAK,OAAO,aAAa;AACzB,WAAK,OAAO,YAAY;AACxB,WAAK,OAAO,QAAQ,KAAK,OAAO,QAAQ,KAAK,KAAK,OAAO;AACzD,WAAK,OAAO,OAAO,KAAK,OAAO,OAAO,KAAK,KAAK,OAAO;AACvD,WAAK,OAAO;AAAA,IAChB,CAAC;AACD,WAAO;AAAA,EACX;AACJ;AAzCA,IAAqB,SAArB;AAAqB,OACV,YAAY;AAAA,EACf,OAAO;AAAA,EACP,QAAQ;AACZ;AANJ;;;;;;;;;;;;;;;;ACAsD;AAGvC,MAAM,kBAAkB,2DAAkB,CAAC;AAAA,EAA1D;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;ACV4C;AAE7B,MAAM,eAAe,sDAAa,CAAC;AAAA,EAC9C,SAAS;AACL,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,WAAK,OAAO;AACZ,WAAK,OAAO,QAAQ,KAAK,IAAI,KAAK,OAAO,OAAO,KAAK,OAAO,QAAQ,IAAI,sDAAa,CAAC,OAAO;AAC7F,WAAK,OAAO,UAAU,KAAK,OAAO;AAAA,IACtC,CAAC;AACD,SAAK,OAAO,UAAU,sDAAa,CAAC,gBAAgB,KAAK,MAAM,SAAS;AACxE,QAAI,KAAK,OAAO,QAAQ;AAAG,WAAK,OAAO,SAAS;AAChD,WAAO;AAAA,EACX;AAAA,EACA,OAAO,IAAY,IAAY;AAC3B,QAAI,eAAe;AACnB,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW;AAAY;AAAA,IAC5E,CAAC;AACD,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,UAAI,MAAM;AACV,UAAI,MAAM;AACV,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW,cAAc;AACtE,cAAM,KAAK,OAAO,QAAQ,IAAI,sDAAa,CAAC,UAAU,KAAK,OAAO;AAClE,aAAK,OAAO,SAAS;AAAA,MACzB;AACA,UAAI,KAAK,OAAO,WAAW,UAAU,KAAK,OAAO,WAAW,YAAY;AACpE,cAAM,eAAe,KAAK,eAAe;AACzC,aAAK,OAAO,UAAU;AAAA,MAC1B;AACA,WAAK,OAAO,KAAK,GAAG;AAAA,IACxB,CAAC;AAED,WAAO;AAAA,EACX;AAAA,EACA,SAAS;AACL,UAAM,EAAE,aAAa,SAAS,aAAa,IAAI,sDAAa;AAC5D,UAAM,QAAQ;AACd,QAAI,OAAO,WAAW,KAAK,SAAS,IAAI;AACxC,UAAM,EAAE,MAAM,IAAI,KAAK;AACvB,SAAK,MAAM,QAAQ,CAAC,SAAS;AACzB,WAAK,OAAO,aAAa;AACzB,WAAK,OAAO,YAAY;AAExB,WAAK,OAAO,eAAe,QAAQ,KAAK,OAAO,SAAS,IAAI;AAC5D,WAAK,OAAO,QAAQ,KAAK,OAAO,QAAQ,KAAK,KAAK,OAAO;AACzD,WAAK,OAAO,OAAO,KAAK,OAAO,OAAO,KAAK,KAAK,OAAO;AACvD,WAAK,OAAO;AACZ,cAAQ,KAAK,OAAO,SAAS;AAAA,IACjC,CAAC;AACD,WAAO;AAAA,EACX;AACJ;;;;;;;;;;;;;;;;ACnDoD;AAGrC,MAAM,gBAAgB,0DAAiB,CAAC;AAAA,EAAvD;AAAA;AACI,kBAAsB;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACZ;AAAA;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACTA,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAiJ;AACjJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,2HAAO;;;;AAI2F;AACnH,OAAO,iEAAe,2HAAO,IAAI,2HAAO,UAAU,2HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAmJ;AACnJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,6HAAO;;;;AAI6F;AACrH,OAAO,iEAAe,6HAAO,IAAI,6HAAO,UAAU,6HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAqJ;AACrJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,+HAAO;;;;AAI+F;AACvH,OAAO,iEAAe,+HAAO,IAAI,+HAAO,UAAU,+HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAkJ;AAClJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,4HAAO;;;;AAI4F;AACpH,OAAO,iEAAe,4HAAO,IAAI,4HAAO,UAAU,4HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAsJ;AACtJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,gIAAO;;;;AAIgG;AACxH,OAAO,iEAAe,gIAAO,IAAI,gIAAO,UAAU,gIAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAoJ;AACpJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,8HAAO;;;;AAI8F;AACtH,OAAO,iEAAe,8HAAO,IAAI,8HAAO,UAAU,8HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAiJ;AACjJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,2HAAO;;;;AAI2F;AACnH,OAAO,iEAAe,2HAAO,IAAI,2HAAO,UAAU,2HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAgJ;AAChJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,0HAAO;;;;AAI0F;AAClH,OAAO,iEAAe,0HAAO,IAAI,0HAAO,UAAU,0HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAiJ;AACjJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,2HAAO;;;;AAI2F;AACnH,OAAO,iEAAe,2HAAO,IAAI,2HAAO,UAAU,2HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAmJ;AACnJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,6HAAO;;;;AAI6F;AACrH,OAAO,iEAAe,6HAAO,IAAI,6HAAO,UAAU,6HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAsJ;AACtJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,gIAAO;;;;AAIgG;AACxH,OAAO,iEAAe,gIAAO,IAAI,gIAAO,UAAU,gIAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAkJ;AAClJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,4HAAO;;;;AAI4F;AACpH,OAAO,iEAAe,4HAAO,IAAI,4HAAO,UAAU,4HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAsJ;AACtJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,gIAAO;;;;AAIgG;AACxH,OAAO,iEAAe,gIAAO,IAAI,gIAAO,UAAU,gIAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAsJ;AACtJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,gIAAO;;;;AAIgG;AACxH,OAAO,iEAAe,gIAAO,IAAI,gIAAO,UAAU,gIAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAkG;AAClG,MAAwF;AACxF,MAA+F;AAC/F,MAAkH;AAClH,MAA2G;AAC3G,MAA2G;AAC3G,MAAoJ;AACpJ;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,8HAAO;;;;AAI8F;AACtH,OAAO,iEAAe,8HAAO,IAAI,8HAAO,UAAU,8HAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAA+F;AAC/F,MAAqF;AACrF,MAA4F;AAC5F,MAA+G;AAC/G,MAAwG;AACxG,MAAwG;AACxG,MAA4I;AAC5I;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,4HAAO;;;;AAIsF;AAC9G,OAAO,iEAAe,4HAAO,IAAI,4HAAO,UAAU,4HAAO,mBAAmB,EAAC;;;;;;;;;;;AC1BhE;;AAEb;AACA;AACA;AACA,kBAAkB,wBAAwB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,4BAA4B;AAChD;AACA;AACA;AACA;AACA;AACA,qBAAqB,6BAA6B;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACnFa;;AAEb;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACjCa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACTa;;AAEb;AACA;AACA,cAAc,KAAwC,GAAG,sBAAiB,GAAG,CAAI;AACjF;AACA;AACA;AACA;AACA;;;;;;;;;;ACTa;;AAEb;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA,iFAAiF;AACjF;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,yDAAyD;AACzD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AC5Da;;AAEb;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;UCbA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCtBA;WACA;WACA;WACA;WACA;WACA,iCAAiC,WAAW;WAC5C;WACA;;;;;WCPA;WACA;WACA;WACA;WACA,yCAAyC,wCAAwC;WACjF;WACA;WACA;;;;;WCPA;;;;;WCAA;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;WCNA;;;;;;;;;;;;;;;;;ACA+C;AACQ","sources":["webpack://FaustUI/webpack/universalModuleDefinition","webpack://FaustUI/./node_modules/@shren/typed-event-emitter/dist/index.js","webpack://FaustUI/./src/components/Base.scss","webpack://FaustUI/./src/components/Button.scss","webpack://FaustUI/./src/components/Checkbox.scss","webpack://FaustUI/./src/components/Group.scss","webpack://FaustUI/./src/components/HBargraph.scss","webpack://FaustUI/./src/components/HSlider.scss","webpack://FaustUI/./src/components/Knob.scss","webpack://FaustUI/./src/components/Led.scss","webpack://FaustUI/./src/components/Menu.scss","webpack://FaustUI/./src/components/Nentry.scss","webpack://FaustUI/./src/components/Numerical.scss","webpack://FaustUI/./src/components/Radio.scss","webpack://FaustUI/./src/components/Soundfile.scss","webpack://FaustUI/./src/components/VBargraph.scss","webpack://FaustUI/./src/components/VSlider.scss","webpack://FaustUI/./src/index.scss","webpack://FaustUI/./node_modules/css-loader/dist/runtime/api.js","webpack://FaustUI/./node_modules/css-loader/dist/runtime/sourceMaps.js","webpack://FaustUI/./src/FaustUI.ts","webpack://FaustUI/./src/components/AbstractComponent.ts","webpack://FaustUI/./src/components/AbstractItem.ts","webpack://FaustUI/./src/components/Button.ts","webpack://FaustUI/./src/components/Checkbox.ts","webpack://FaustUI/./src/components/Group.ts","webpack://FaustUI/./src/components/HBargraph.ts","webpack://FaustUI/./src/components/HSlider.ts","webpack://FaustUI/./src/components/Knob.ts","webpack://FaustUI/./src/components/Led.ts","webpack://FaustUI/./src/components/Menu.ts","webpack://FaustUI/./src/components/Nentry.ts","webpack://FaustUI/./src/components/Numerical.ts","webpack://FaustUI/./src/components/Radio.ts","webpack://FaustUI/./src/components/Soundfile.ts","webpack://FaustUI/./src/components/VBargraph.ts","webpack://FaustUI/./src/components/VSlider.ts","webpack://FaustUI/./src/components/utils.ts","webpack://FaustUI/./src/instantiate.ts","webpack://FaustUI/./src/layout/AbstractGroup.ts","webpack://FaustUI/./src/layout/AbstractInputItem.ts","webpack://FaustUI/./src/layout/AbstractItem.ts","webpack://FaustUI/./src/layout/AbstractOutputItem.ts","webpack://FaustUI/./src/layout/Button.ts","webpack://FaustUI/./src/layout/Checkbox.ts","webpack://FaustUI/./src/layout/HBargraph.ts","webpack://FaustUI/./src/layout/HGroup.ts","webpack://FaustUI/./src/layout/HSlider.ts","webpack://FaustUI/./src/layout/Knob.ts","webpack://FaustUI/./src/layout/Layout.ts","webpack://FaustUI/./src/layout/Led.ts","webpack://FaustUI/./src/layout/Menu.ts","webpack://FaustUI/./src/layout/Nentry.ts","webpack://FaustUI/./src/layout/Numerical.ts","webpack://FaustUI/./src/layout/Radio.ts","webpack://FaustUI/./src/layout/Soundfile.ts","webpack://FaustUI/./src/layout/TGroup.ts","webpack://FaustUI/./src/layout/VBargraph.ts","webpack://FaustUI/./src/layout/VGroup.ts","webpack://FaustUI/./src/layout/VSlider.ts","webpack://FaustUI/./src/components/Base.scss?36b0","webpack://FaustUI/./src/components/Button.scss?dd49","webpack://FaustUI/./src/components/Checkbox.scss?0df7","webpack://FaustUI/./src/components/Group.scss?fa6e","webpack://FaustUI/./src/components/HBargraph.scss?cc52","webpack://FaustUI/./src/components/HSlider.scss?9cc5","webpack://FaustUI/./src/components/Knob.scss?4f65","webpack://FaustUI/./src/components/Led.scss?bd9b","webpack://FaustUI/./src/components/Menu.scss?bf9b","webpack://FaustUI/./src/components/Nentry.scss?7280","webpack://FaustUI/./src/components/Numerical.scss?6fd6","webpack://FaustUI/./src/components/Radio.scss?2535","webpack://FaustUI/./src/components/Soundfile.scss?7769","webpack://FaustUI/./src/components/VBargraph.scss?5683","webpack://FaustUI/./src/components/VSlider.scss?b9c9","webpack://FaustUI/./src/index.scss?7223","webpack://FaustUI/./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://FaustUI/./node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://FaustUI/./node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://FaustUI/./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://FaustUI/./node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://FaustUI/./node_modules/style-loader/dist/runtime/styleTagTransform.js","webpack://FaustUI/webpack/bootstrap","webpack://FaustUI/webpack/runtime/compat get default export","webpack://FaustUI/webpack/runtime/define property getters","webpack://FaustUI/webpack/runtime/hasOwnProperty shorthand","webpack://FaustUI/webpack/runtime/make namespace object","webpack://FaustUI/webpack/runtime/nonce","webpack://FaustUI/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"FaustUI\"] = factory();\n\telse\n\t\troot[\"FaustUI\"] = factory();\n})(self, () => {\nreturn ","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TypedEventEmitter = exports.$AnyEventType = void 0;\nexports.$AnyEventType = Symbol(\"__TypedEventListener_AnyEventType\");\nclass TypedEventEmitter {\n constructor() {\n this._listeners = { [exports.$AnyEventType]: [] };\n }\n get listeners() {\n return this._listeners;\n }\n getListeners(eventName) {\n if (!(eventName in this._listeners))\n this._listeners[eventName] = [];\n return this._listeners[eventName];\n }\n on(eventName, listener) {\n if (this.getListeners(eventName).indexOf(listener) === -1)\n this.getListeners(eventName).push(listener);\n }\n once(eventName, listener) {\n const listenerWithOff = (arg, emitter) => {\n const returnValue = listener(arg, emitter);\n this.off(eventName, listenerWithOff);\n return returnValue;\n };\n this.on(eventName, listenerWithOff);\n }\n onAny(listener) {\n this._listeners[exports.$AnyEventType].push(listener);\n }\n off(eventName, listener) {\n const i = this.getListeners(eventName).indexOf(listener);\n if (i !== -1)\n this.getListeners(eventName).splice(i, 1);\n }\n offAny(listener) {\n const i = this._listeners[exports.$AnyEventType].indexOf(listener);\n if (i !== -1)\n this._listeners[exports.$AnyEventType].splice(i, 1);\n }\n async emit(eventName, eventData, options) {\n var _a;\n let listeners = this.getListeners(eventName);\n let anyListeners = (options === null || options === void 0 ? void 0 : options.excludeAny) ? [] : this._listeners[exports.$AnyEventType];\n if (!listeners.length && !anyListeners.length)\n return [];\n if ((_a = options === null || options === void 0 ? void 0 : options.exclude) === null || _a === void 0 ? void 0 : _a.length) {\n const { exclude } = options;\n listeners = listeners.filter(l => exclude.indexOf(l) === -1);\n anyListeners = anyListeners.filter(l => exclude.indexOf(l) === -1);\n }\n return Promise.all([...listeners.map(f => f(eventData, this)), ...anyListeners.map(f => f(eventName, eventData, this))]);\n }\n async emitSerial(eventName, eventData, options) {\n var _a;\n let listeners = this.getListeners(eventName);\n let anyListeners = (options === null || options === void 0 ? void 0 : options.excludeAny) ? [] : this._listeners[exports.$AnyEventType];\n if (!listeners.length && !anyListeners.length)\n return [];\n if ((_a = options === null || options === void 0 ? void 0 : options.exclude) === null || _a === void 0 ? void 0 : _a.length) {\n const { exclude } = options;\n listeners = listeners.filter(l => exclude.indexOf(l) === -1);\n anyListeners = anyListeners.filter(l => exclude.indexOf(l) === -1);\n }\n const returnValues = [];\n for (let i = 0; i < listeners.length; i++) {\n const listener = listeners[i];\n returnValues[i] = await listener(eventData, this);\n }\n for (let i = 0; i < anyListeners.length; i++) {\n const listener = anyListeners[i];\n returnValues[listeners.length + i] = await listener(eventName, eventData, this);\n }\n return returnValues;\n }\n emitSync(eventName, eventData, options) {\n var _a;\n let listeners = this.getListeners(eventName);\n let anyListeners = (options === null || options === void 0 ? void 0 : options.excludeAny) ? [] : this._listeners[exports.$AnyEventType];\n if (!listeners.length && !anyListeners.length)\n return [];\n if ((_a = options === null || options === void 0 ? void 0 : options.exclude) === null || _a === void 0 ? void 0 : _a.length) {\n const { exclude } = options;\n listeners = listeners.filter(l => exclude.indexOf(l) === -1);\n anyListeners = anyListeners.filter(l => exclude.indexOf(l) === -1);\n }\n return [...listeners.map(f => f(eventData, this)), ...anyListeners.map(f => f(eventName, eventData, this))];\n }\n offAll(eventName) {\n if (eventName) {\n this._listeners[eventName] = [];\n }\n else {\n this._listeners = { [exports.$AnyEventType]: [] };\n }\n }\n listenerCount(eventName) {\n const anyListenerCount = this._listeners[exports.$AnyEventType].length;\n if (!(eventName in this._listeners))\n return anyListenerCount;\n return this._listeners[eventName].length + anyListenerCount;\n }\n}\nexports.TypedEventEmitter = TypedEventEmitter;\nexports.default = TypedEventEmitter;\n//# sourceMappingURL=index.js.map","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component {\n display: flex;\n position: absolute;\n flex-direction: column;\n overflow: hidden;\n}\n.faust-ui-component:focus {\n outline: none;\n}\n.faust-ui-component > .faust-ui-component-label {\n position: relative;\n margin-top: 4px;\n width: 100%;\n user-select: none;\n}\n.faust-ui-component > .faust-ui-component-label > canvas {\n position: relative;\n display: block;\n max-width: 100%;\n max-height: 100%;\n}\n.faust-ui-component input {\n box-shadow: none;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Base.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,aAAA;EACA,kBAAA;EACA,sBAAA;EACA,gBAAA;AACJ;AAAI;EACI,aAAA;AAER;AAAI;EACI,kBAAA;EACA,eAAA;EACA,WAAA;EACA,iBAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,eAAA;EACA,gBAAA;AAGZ;AAAI;EACI,gBAAA;AAER\",\"sourcesContent\":[\".faust-ui-component {\\n display: flex;\\n position: absolute;\\n flex-direction: column;\\n overflow: hidden;\\n &:focus {\\n outline: none;\\n }\\n & > .faust-ui-component-label {\\n position: relative;\\n margin-top: 4px;\\n width: 100%;\\n user-select: none;\\n & > canvas {\\n position: relative;\\n display: block;\\n max-width: 100%;\\n max-height: 100%;\\n }\\n }\\n & input {\\n box-shadow: none;\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-button > div {\n display: flex;\n position: relative;\n cursor: pointer;\n border-width: 1px;\n text-align: center;\n border-radius: 4px;\n flex: 1 0 auto;\n border-style: solid;\n}\n.faust-ui-component.faust-ui-component-button > div > span {\n user-select: none;\n margin: auto;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Button.scss\"],\"names\":[],\"mappings\":\"AACI;EACI,aAAA;EACA,kBAAA;EACA,eAAA;EACA,iBAAA;EACA,kBAAA;EACA,kBAAA;EACA,cAAA;EACA,mBAAA;AAAR;AACQ;EACI,iBAAA;EACA,YAAA;AACZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-button {\\n & > div {\\n display: flex;\\n position: relative;\\n cursor: pointer;\\n border-width: 1px;\\n text-align: center;\\n border-radius: 4px;\\n flex: 1 0 auto;\\n border-style: solid;\\n & > span {\\n user-select: none;\\n margin: auto;\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-checkbox > div {\n display: flex;\n position: relative;\n cursor: pointer;\n border-width: 1px;\n text-align: center;\n border-radius: 1px;\n flex: 1 0 auto;\n border-style: solid;\n}\n.faust-ui-component.faust-ui-component-checkbox > div > span {\n margin: auto;\n user-select: none;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Checkbox.scss\"],\"names\":[],\"mappings\":\"AACI;EACI,aAAA;EACA,kBAAA;EACA,eAAA;EACA,iBAAA;EACA,kBAAA;EACA,kBAAA;EACA,cAAA;EACA,mBAAA;AAAR;AACQ;EACI,YAAA;EACA,iBAAA;AACZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-checkbox {\\n & > div {\\n display: flex;\\n position: relative;\\n cursor: pointer;\\n border-width: 1px;\\n text-align: center;\\n border-radius: 1px;\\n flex: 1 0 auto;\\n border-style: solid;\\n & > span {\\n margin: auto;\\n user-select: none;\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-group {\n position: absolute;\n display: block;\n background-color: rgba(80, 80, 80, 0.75);\n border-radius: 4px;\n border: 1px rgba(255, 255, 255, 0.25) solid;\n}\n.faust-ui-group > .faust-ui-group-label {\n position: relative;\n margin: 4px;\n width: calc(100% - 8px);\n user-select: none;\n}\n.faust-ui-group > .faust-ui-group-label > canvas {\n position: relative;\n display: block;\n max-width: 100%;\n max-height: 100%;\n}\n.faust-ui-group .faust-ui-tgroup-tabs {\n position: absolute;\n display: inline-block;\n white-space: nowrap;\n left: 0px;\n}\n.faust-ui-group .faust-ui-tgroup-tabs .faust-ui-tgroup-tab {\n position: relative;\n display: inline-block;\n border-radius: 5px;\n cursor: pointer;\n text-overflow: ellipsis;\n white-space: nowrap;\n user-select: none;\n margin: 10px;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.5);\n}\n.faust-ui-group .faust-ui-tgroup-tabs .faust-ui-tgroup-tab:hover {\n background-color: rgb(255, 255, 255);\n}\n.faust-ui-group .faust-ui-tgroup-tabs .faust-ui-tgroup-tab.active {\n background-color: rgb(40, 40, 40);\n color: white;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Group.scss\"],\"names\":[],\"mappings\":\"AACA;EACI,kBAAA;EACA,cAAA;EACA,wCAAA;EACA,kBAAA;EACA,2CAAA;AAAJ;AACI;EACI,kBAAA;EACA,WAAA;EACA,uBAAA;EACA,iBAAA;AACR;AAAQ;EACI,kBAAA;EACA,cAAA;EACA,eAAA;EACA,gBAAA;AAEZ;AACI;EACI,kBAAA;EACA,qBAAA;EACA,mBAAA;EACA,SAAA;AACR;AAAQ;EACI,kBAAA;EACA,qBAAA;EACA,kBAAA;EACA,eAAA;EACA,uBAAA;EACA,mBAAA;EACA,iBAAA;EACA,YAAA;EACA,kBAAA;EACA,0CAAA;AAEZ;AADY;EACI,oCAAA;AAGhB;AADY;EACI,iCAAA;EACA,YAAA;AAGhB\",\"sourcesContent\":[\"\\n.faust-ui-group {\\n position: absolute;\\n display: block;\\n background-color: rgba(80, 80, 80, 0.75);\\n border-radius: 4px;\\n border: 1px rgba(255, 255, 255, 0.25) solid;\\n & > .faust-ui-group-label {\\n position: relative;\\n margin: 4px;\\n width: calc(100% - 8px);\\n user-select: none;\\n & > canvas {\\n position: relative;\\n display: block;\\n max-width: 100%;\\n max-height: 100%;\\n }\\n }\\n & .faust-ui-tgroup-tabs {\\n position: absolute;\\n display: inline-block;\\n white-space: nowrap;\\n left: 0px;\\n & .faust-ui-tgroup-tab {\\n position: relative;\\n display: inline-block;\\n border-radius: 5px;\\n cursor: pointer;\\n text-overflow: ellipsis;\\n white-space: nowrap;\\n user-select: none;\\n margin: 10px;\\n text-align: center;\\n background-color: rgba(255, 255, 255, 0.5);\\n &:hover {\\n background-color: rgba(255, 255, 255, 1);\\n }\\n &.active {\\n background-color: rgba(40, 40, 40, 1);\\n color: white;\\n }\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-label {\n flex: 0 0 auto;\n}\n.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv {\n position: relative;\n display: flex;\n flex-direction: row-reverse;\n flex: 1 1 auto;\n width: 100%;\n height: auto;\n}\n.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv > .faust-ui-component-hbargraph-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n height: 100%;\n margin: auto;\n}\n.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv > .faust-ui-component-hbargraph-canvasdiv > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-hbargraph > .faust-ui-component-hbargraph-flexdiv > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: auto 5px auto auto;\n border-width: 0px;\n border-radius: 4px;\n width: calc(20% - 13px);\n padding: 2px 4px;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/HBargraph.scss\"],\"names\":[],\"mappings\":\"AACI;EACI,cAAA;AAAR;AAEI;EACI,kBAAA;EACA,aAAA;EACA,2BAAA;EACA,cAAA;EACA,WAAA;EACA,YAAA;AAAR;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,YAAA;EACA,YAAA;AACZ;AAAY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAEhB;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,uBAAA;EACA,gBAAA;AACZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-hbargraph {\\n & > .faust-ui-component-label {\\n flex: 0 0 auto;\\n }\\n & > .faust-ui-component-hbargraph-flexdiv {\\n position: relative;\\n display: flex;\\n flex-direction: row-reverse;\\n flex: 1 1 auto;\\n width: 100%;\\n height: auto;\\n & > .faust-ui-component-hbargraph-canvasdiv {\\n position: relative;\\n display: block;\\n flex: 1 1 auto;\\n height: 100%;\\n margin: auto;\\n & > canvas {\\n position: absolute;\\n display: block;\\n height: 100%;\\n width: 100%;\\n }\\n }\\n & > input {\\n position: relative;\\n display: block;\\n flex: 0 1 auto;\\n text-align: center;\\n background-color: rgba(255, 255, 255, 0.25);\\n margin: auto 5px auto auto;\\n border-width: 0px;\\n border-radius: 4px;\\n width: calc(20% - 13px);\\n padding: 2px 4px;\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-label {\n flex: 0 0 auto;\n}\n.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv {\n position: relative;\n display: flex;\n flex-direction: row-reverse;\n flex: 1 1 auto;\n width: 100%;\n height: auto;\n}\n.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > .faust-ui-component-hslider-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n height: 100%;\n margin: auto;\n}\n.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > .faust-ui-component-hslider-canvasdiv > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: auto 5px auto auto;\n border-width: 0px;\n border-radius: 4px;\n width: calc(20% - 13px);\n padding: 2px 4px;\n -moz-appearance: textfield;\n}\n.faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-hslider > .faust-ui-component-hslider-flexdiv > input::-webkit-outer-spin-button {\n -webkit-appearance: none;\n margin: 0;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/HSlider.scss\"],\"names\":[],\"mappings\":\"AACI;EACI,cAAA;AAAR;AAEI;EACI,kBAAA;EACA,aAAA;EACA,2BAAA;EACA,cAAA;EACA,WAAA;EACA,YAAA;AAAR;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,YAAA;EACA,YAAA;AACZ;AAAY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAEhB;AACQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,uBAAA;EACA,gBAAA;EACA,0BAAA;AACZ;AAAY;EAEI,wBAAA;EACA,SAAA;AAChB\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-hslider {\\n & > .faust-ui-component-label {\\n flex: 0 0 auto;\\n }\\n & > .faust-ui-component-hslider-flexdiv {\\n position: relative;\\n display: flex;\\n flex-direction: row-reverse;\\n flex: 1 1 auto;\\n width: 100%;\\n height: auto;\\n & > .faust-ui-component-hslider-canvasdiv {\\n position: relative;\\n display: block;\\n flex: 1 1 auto;\\n height: 100%;\\n margin: auto;\\n & > canvas {\\n position: absolute;\\n display: block;\\n height: 100%;\\n width: 100%;\\n }\\n }\\n & > input {\\n position: relative;\\n display: block;\\n flex: 0 1 auto;\\n text-align: center;\\n background-color: rgba(255, 255, 255, 0.25);\\n margin: auto 5px auto auto;\\n border-width: 0px;\\n border-radius: 4px;\\n width: calc(20% - 13px);\\n padding: 2px 4px;\\n -moz-appearance:textfield;\\n &::-webkit-inner-spin-button, \\n &::-webkit-outer-spin-button {\\n -webkit-appearance: none;\\n margin: 0;\\n }\\n }\\n }\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-knob {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-knob > canvas {\n position: relative;\n display: block;\n flex: 1 1 auto;\n min-height: 50%;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-knob > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: 0px;\n border-width: 0px;\n border-radius: 4px;\n max-width: calc(100% - 8px);\n padding: 2px 4px;\n -moz-appearance: textfield;\n}\n.faust-ui-component.faust-ui-component-knob > input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-knob > input::-webkit-outer-spin-button {\n -webkit-appearance: none;\n margin: 0;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Knob.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,eAAA;EACA,WAAA;AAER;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,WAAA;EACA,iBAAA;EACA,kBAAA;EACA,2BAAA;EACA,gBAAA;EACA,0BAAA;AAER;AADQ;EAEI,wBAAA;EACA,SAAA;AAEZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-knob {\\n align-items: center;\\n & > canvas {\\n position: relative;\\n display: block;\\n flex: 1 1 auto;\\n min-height: 50%;\\n width: 100%;\\n }\\n & > input {\\n position: relative;\\n display: block;\\n flex: 0 1 auto;\\n text-align: center;\\n background-color: rgba(255, 255, 255, 0.25);\\n margin: 0px;\\n border-width: 0px;\\n border-radius: 4px;\\n max-width: calc(100% - 8px);\\n padding: 2px 4px;\\n -moz-appearance:textfield;\\n &::-webkit-inner-spin-button, \\n &::-webkit-outer-spin-button {\\n -webkit-appearance: none;\\n margin: 0;\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-led {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-led > .faust-ui-component-label {\n flex: 0 0 auto;\n}\n.faust-ui-component.faust-ui-component-led > .faust-ui-component-led-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-led > .faust-ui-component-led-canvasdiv > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Led.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;AAER;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,WAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAGZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-led {\\n align-items: center;\\n & > .faust-ui-component-label {\\n flex: 0 0 auto;\\n }\\n & > .faust-ui-component-led-canvasdiv {\\n position: relative;\\n display: block;\\n flex: 1 1 auto;\\n width: 100%;\\n & > canvas {\\n position: absolute;\\n display: block;\\n height: 100%;\\n width: 100%;\\n }\\n }\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-menu {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-menu > select {\n margin: 0px;\n text-align: center;\n border-width: 1px;\n border-radius: 4px;\n padding: 2px 4px;\n width: calc(100% - 8px);\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Menu.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,WAAA;EACA,kBAAA;EACA,iBAAA;EACA,kBAAA;EACA,gBAAA;EACA,uBAAA;AAER\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-menu {\\n align-items: center;\\n & > select {\\n margin: 0px;\\n text-align: center;\\n border-width: 1px;\\n border-radius: 4px;\\n padding: 2px 4px;\\n width: calc(100% - 8px);\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-nentry {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-nentry input {\n margin: 0px;\n text-align: center;\n border-width: 1px;\n border-radius: 4px;\n padding: 2px 4px;\n width: calc(100% - 8px);\n}\n.faust-ui-component.faust-ui-component-nentry input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-nentry input::-webkit-outer-spin-button {\n opacity: 1;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Nentry.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,WAAA;EACA,kBAAA;EACA,iBAAA;EACA,kBAAA;EACA,gBAAA;EACA,uBAAA;AAER;AADQ;EAEI,UAAA;AAEZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-nentry {\\n align-items: center;\\n & input {\\n margin: 0px;\\n text-align: center;\\n border-width: 1px;\\n border-radius: 4px;\\n padding: 2px 4px;\\n width: calc(100% - 8px);\\n &::-webkit-inner-spin-button, \\n &::-webkit-outer-spin-button {\\n opacity: 1;\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-numerical {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-numerical > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: auto;\n border-width: 0px;\n border-radius: 4px;\n width: calc(100% - 8px);\n padding: 2px 4px;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Numerical.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,YAAA;EACA,iBAAA;EACA,kBAAA;EACA,uBAAA;EACA,gBAAA;AAER\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-numerical {\\n align-items: center;\\n & > input {\\n position: relative;\\n display: block;\\n flex: 0 1 auto;\\n text-align: center;\\n background-color: rgba(255, 255, 255, 0.25);\\n margin: auto;\\n border-width: 0px;\\n border-radius: 4px;\\n width: calc(100% - 8px);\\n padding: 2px 4px;\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-radio {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-radio > .faust-ui-component-label {\n flex: 0 0 auto;\n margin-top: auto;\n}\n.faust-ui-component.faust-ui-component-radio > .faust-ui-component-radio-group {\n flex: 0 0 auto;\n margin-bottom: auto;\n border-width: 1px;\n border-radius: 4px;\n padding: 2px 4px;\n width: calc(100% - 8px);\n}\n.faust-ui-component.faust-ui-component-radio > .faust-ui-component-radio-group > div {\n text-overflow: ellipsis;\n white-space: nowrap;\n overflow: hidden;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Radio.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;EACA,gBAAA;AAER;AAAI;EACI,cAAA;EACA,mBAAA;EACA,iBAAA;EACA,kBAAA;EACA,gBAAA;EACA,uBAAA;AAER;AADQ;EACI,uBAAA;EACA,mBAAA;EACA,gBAAA;AAGZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-radio {\\n align-items: center;\\n & > .faust-ui-component-label {\\n flex: 0 0 auto;\\n margin-top: auto;\\n }\\n & > .faust-ui-component-radio-group {\\n flex: 0 0 auto;\\n margin-bottom: auto;\\n border-width: 1px;\\n border-radius: 4px;\\n padding: 2px 4px;\\n width: calc(100% - 8px);\\n & > div {\\n text-overflow: ellipsis;\\n white-space: nowrap;\\n overflow: hidden;\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-soundfile > div {\n display: flex;\n position: relative;\n cursor: pointer;\n border-width: 1px;\n text-align: center;\n border-radius: 4px;\n flex: 1 0 auto;\n border-style: solid;\n}\n.faust-ui-component.faust-ui-component-soundfile > div > span {\n user-select: none;\n margin: auto;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/Soundfile.scss\"],\"names\":[],\"mappings\":\"AACI;EACI,aAAA;EACA,kBAAA;EACA,eAAA;EACA,iBAAA;EACA,kBAAA;EACA,kBAAA;EACA,cAAA;EACA,mBAAA;AAAR;AACQ;EACI,iBAAA;EACA,YAAA;AACZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-soundfile {\\n & > div {\\n display: flex;\\n position: relative;\\n cursor: pointer;\\n border-width: 1px;\\n text-align: center;\\n border-radius: 4px;\\n flex: 1 0 auto;\\n border-style: solid;\\n & > span {\\n user-select: none;\\n margin: auto;\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-vbargraph {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-label {\n flex: 0 0 auto;\n}\n.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv {\n position: relative;\n display: flex;\n flex-direction: column;\n flex: 1 1 auto;\n width: 100%;\n height: inherit;\n}\n.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv > .faust-ui-component-vbargraph-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv > .faust-ui-component-vbargraph-canvasdiv > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-vbargraph > .faust-ui-component-vbargraph-flexdiv > input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: 5px auto auto auto;\n border-width: 0px;\n border-radius: 4px;\n height: 5%;\n width: calc(100% - 8px);\n padding: 2px 4px;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/VBargraph.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;AAER;AAAI;EACI,kBAAA;EACA,aAAA;EACA,sBAAA;EACA,cAAA;EACA,WAAA;EACA,eAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,WAAA;AAGZ;AAFY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAIhB;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,UAAA;EACA,uBAAA;EACA,gBAAA;AAGZ\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-vbargraph {\\n align-items: center;\\n & > .faust-ui-component-label {\\n flex: 0 0 auto;\\n }\\n & > .faust-ui-component-vbargraph-flexdiv {\\n position: relative;\\n display: flex;\\n flex-direction: column;\\n flex: 1 1 auto;\\n width: 100%;\\n height: inherit;\\n & > .faust-ui-component-vbargraph-canvasdiv {\\n position: relative;\\n display: block;\\n flex: 1 1 auto;\\n width: 100%;\\n & > canvas {\\n position: absolute;\\n display: block;\\n height: 100%;\\n width: 100%;\\n }\\n }\\n & > input {\\n position: relative;\\n display: block;\\n flex: 0 1 auto;\\n text-align: center;\\n background-color: rgba(255, 255, 255, 0.25);\\n margin: 5px auto auto auto;\\n border-width: 0px;\\n border-radius: 4px;\\n height: 5%;\\n width: calc(100% - 8px);\\n padding: 2px 4px;\\n }\\n }\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-component.faust-ui-component-vslider {\n align-items: center;\n}\n.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-label {\n flex: 0 0 auto;\n}\n.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv {\n position: relative;\n display: flex;\n flex-direction: column;\n flex: 1 1 auto;\n width: 100%;\n height: auto;\n}\n.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv > .faust-ui-component-vslider-canvasdiv {\n position: relative;\n display: block;\n flex: 1 1 auto;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv > .faust-ui-component-vslider-canvasdiv > canvas {\n position: absolute;\n display: block;\n height: 100%;\n width: 100%;\n}\n.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv input {\n position: relative;\n display: block;\n flex: 0 1 auto;\n text-align: center;\n background-color: rgba(255, 255, 255, 0.25);\n margin: 5px auto auto auto;\n border-width: 0px;\n border-radius: 4px;\n height: 5%;\n max-width: calc(100% - 8px);\n padding: 2px 4px;\n -moz-appearance: textfield;\n}\n.faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv input::-webkit-inner-spin-button, .faust-ui-component.faust-ui-component-vslider > .faust-ui-component-vslider-flexdiv input::-webkit-outer-spin-button {\n -webkit-appearance: none;\n margin: 0;\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/components/VSlider.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,mBAAA;AACJ;AAAI;EACI,cAAA;AAER;AAAI;EACI,kBAAA;EACA,aAAA;EACA,sBAAA;EACA,cAAA;EACA,WAAA;EACA,YAAA;AAER;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,WAAA;AAGZ;AAFY;EACI,kBAAA;EACA,cAAA;EACA,YAAA;EACA,WAAA;AAIhB;AADQ;EACI,kBAAA;EACA,cAAA;EACA,cAAA;EACA,kBAAA;EACA,2CAAA;EACA,0BAAA;EACA,iBAAA;EACA,kBAAA;EACA,UAAA;EACA,2BAAA;EACA,gBAAA;EACA,0BAAA;AAGZ;AAFY;EAEI,wBAAA;EACA,SAAA;AAGhB\",\"sourcesContent\":[\".faust-ui-component.faust-ui-component-vslider {\\n align-items: center;\\n & > .faust-ui-component-label {\\n flex: 0 0 auto;\\n }\\n & > .faust-ui-component-vslider-flexdiv {\\n position: relative;\\n display: flex;\\n flex-direction: column;\\n flex: 1 1 auto;\\n width: 100%;\\n height: auto;\\n & > .faust-ui-component-vslider-canvasdiv {\\n position: relative;\\n display: block;\\n flex: 1 1 auto;\\n width: 100%;\\n & > canvas {\\n position: absolute;\\n display: block;\\n height: 100%;\\n width: 100%;\\n }\\n }\\n & input {\\n position: relative;\\n display: block;\\n flex: 0 1 auto;\\n text-align: center;\\n background-color: rgba(255, 255, 255, 0.25);\\n margin: 5px auto auto auto;\\n border-width: 0px;\\n border-radius: 4px;\\n height: 5%;\\n max-width: calc(100% - 8px);\\n padding: 2px 4px;\\n -moz-appearance:textfield;\\n &::-webkit-inner-spin-button, \\n &::-webkit-outer-spin-button {\\n -webkit-appearance: none;\\n margin: 0;\\n }\\n }\\n }\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.faust-ui-root {\n margin: 0px auto;\n flex: 1 0 auto;\n position: relative !important;\n background-color: transparent !important;\n border: none !important;\n font-family: -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, \"Noto Sans\", sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\", \"Noto Color Emoji\";\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/index.scss\"],\"names\":[],\"mappings\":\"AAAA;EACI,gBAAA;EACA,cAAA;EACA,6BAAA;EACA,wCAAA;EACA,uBAAA;EACA,kMAAA;AACJ\",\"sourcesContent\":[\".faust-ui-root {\\n margin: 0px auto;\\n flex: 1 0 auto;\\n position: relative !important;\\n background-color: transparent !important;\\n border: none !important;\\n font-family: -apple-system, BlinkMacSystemFont, \\\"Segoe UI\\\", Roboto, \\\"Helvetica Neue\\\", Arial, \\\"Noto Sans\\\", sans-serif, \\\"Apple Color Emoji\\\", \\\"Segoe UI Emoji\\\", \\\"Segoe UI Symbol\\\", \\\"Noto Color Emoji\\\";\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","\"use strict\";\n\n/*\n MIT License http://www.opensource.org/licenses/mit-license.php\n Author Tobias Koppers @sokra\n*/\nmodule.exports = function (cssWithMappingToString) {\n var list = [];\n\n // return the list of modules as css string\n list.toString = function toString() {\n return this.map(function (item) {\n var content = \"\";\n var needLayer = typeof item[5] !== \"undefined\";\n if (item[4]) {\n content += \"@supports (\".concat(item[4], \") {\");\n }\n if (item[2]) {\n content += \"@media \".concat(item[2], \" {\");\n }\n if (needLayer) {\n content += \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\");\n }\n content += cssWithMappingToString(item);\n if (needLayer) {\n content += \"}\";\n }\n if (item[2]) {\n content += \"}\";\n }\n if (item[4]) {\n content += \"}\";\n }\n return content;\n }).join(\"\");\n };\n\n // import a list of modules into the list\n list.i = function i(modules, media, dedupe, supports, layer) {\n if (typeof modules === \"string\") {\n modules = [[null, modules, undefined]];\n }\n var alreadyImportedModules = {};\n if (dedupe) {\n for (var k = 0; k < this.length; k++) {\n var id = this[k][0];\n if (id != null) {\n alreadyImportedModules[id] = true;\n }\n }\n }\n for (var _k = 0; _k < modules.length; _k++) {\n var item = [].concat(modules[_k]);\n if (dedupe && alreadyImportedModules[item[0]]) {\n continue;\n }\n if (typeof layer !== \"undefined\") {\n if (typeof item[5] === \"undefined\") {\n item[5] = layer;\n } else {\n item[1] = \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\").concat(item[1], \"}\");\n item[5] = layer;\n }\n }\n if (media) {\n if (!item[2]) {\n item[2] = media;\n } else {\n item[1] = \"@media \".concat(item[2], \" {\").concat(item[1], \"}\");\n item[2] = media;\n }\n }\n if (supports) {\n if (!item[4]) {\n item[4] = \"\".concat(supports);\n } else {\n item[1] = \"@supports (\".concat(item[4], \") {\").concat(item[1], \"}\");\n item[4] = supports;\n }\n }\n list.push(item);\n }\n };\n return list;\n};","\"use strict\";\n\nmodule.exports = function (item) {\n var content = item[1];\n var cssMapping = item[3];\n if (!cssMapping) {\n return content;\n }\n if (typeof btoa === \"function\") {\n var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));\n var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n var sourceMapping = \"/*# \".concat(data, \" */\");\n return [content].concat([sourceMapping]).join(\"\\n\");\n }\n return [content].join(\"\\n\");\n};","import type { FaustUIDescriptor, FaustUIItem } from \"@grame/faustwasm\";\nimport Layout from \"./layout/Layout\";\nimport AbstractItem from \"./components/AbstractItem\";\nimport Group from \"./components/Group\";\nimport type { FaustUIGroupProps } from \"./components/types\";\nimport type { LayoutProps } from \"./types\";\nimport \"./index.scss\";\n\ninterface IOptions {\n root: HTMLDivElement;\n ui?: FaustUIDescriptor;\n listenWindowResize?: boolean;\n listenWindowMessage?: boolean;\n}\n\n/**\n * The main class of UI constructor,\n * listening to `resize` window event to resize component,\n * listening to `message` window event to change UI or param value.\n * See readme.\n */\nexport default class FaustUI {\n componentMap: { [path: string]: AbstractItem[] } = {};\n DOMroot: HTMLDivElement;\n faustUIRoot: Group;\n hostWindow: Window;\n grid: number;\n private _ui: FaustUIItem[];\n private _layout: LayoutProps;\n /**\n * Calculate incoming UI's layout, bind window events\n */\n constructor(options: IOptions) {\n const { root, ui: uiIn, listenWindowResize, listenWindowMessage } = options;\n this.DOMroot = root;\n this.ui = uiIn || [];\n if (typeof listenWindowResize === \"undefined\" || listenWindowResize === true) {\n window.addEventListener(\"resize\", () => {\n this.resize();\n });\n }\n if (typeof listenWindowMessage === \"undefined\" || listenWindowMessage === true) {\n window.addEventListener(\"message\", (e) => {\n const { data, source } = e;\n this.hostWindow = source as Window;\n const { type } = data;\n if (!type) return;\n if (type === \"ui\") {\n this.ui = data.ui;\n } else if (type === \"param\") {\n const { path, value } = data;\n this.paramChangeByDSP(path, value);\n }\n });\n }\n }\n /**\n * Render the UI to DOM root\n */\n mount() {\n this.componentMap = {};\n this.DOMroot.innerHTML = \"\";\n const props: FaustUIGroupProps = {\n label: \"\",\n type: \"vgroup\",\n items: this.ui,\n style: {\n grid: this.grid,\n width: this.layout.width,\n height: this.layout.height,\n left: this.layout.offsetLeft,\n top: this.layout.offsetTop\n },\n isRoot: true,\n emitter: this\n };\n this.faustUIRoot = new Group(props);\n this.faustUIRoot.componentWillMount();\n this.faustUIRoot.mount();\n this.DOMroot.appendChild(this.faustUIRoot.container);\n this.faustUIRoot.componentDidMount();\n }\n /**\n * This method should be called by components to register itself to map.\n */\n register(path: string, item: AbstractItem) {\n if (this.componentMap[path]) this.componentMap[path].push(item);\n else this.componentMap[path] = [item];\n }\n /**\n * Notify the component to change its value.\n */\n paramChangeByDSP(path: string, value: number) {\n if (this.componentMap[path]) this.componentMap[path].forEach(item => item.setState({ value }));\n }\n /**\n * Can be overriden, called by components when its value is changed by user.\n */\n paramChangeByUI = (path: string, value: number) => {\n if (!this.hostWindow) return;\n this.hostWindow.postMessage({ path, value, type: \"param\" }, \"*\");\n };\n /**\n * Calculate UI layout in grid then calculate grid size.\n */\n calc() {\n const { items, layout } = Layout.calc(this.ui);\n this._ui = items;\n this._layout = layout;\n this.calcGrid();\n }\n /**\n * Calculate grid size by DOM root size and layout size in grids.\n */\n calcGrid() {\n const { width, height } = this.DOMroot.getBoundingClientRect();\n const grid = Math.max(40, Math.min(width / this._layout.width, height / this._layout.height));\n this.grid = grid;\n return grid;\n }\n /**\n * Force recalculate grid size and resize UI\n */\n resize() {\n if (!this.faustUIRoot) return;\n this.calcGrid();\n this.faustUIRoot.setState({ style: { grid: this.grid } });\n }\n get ui() {\n return this._ui;\n }\n set ui(uiIn) {\n this._ui = uiIn;\n this.calc();\n this.mount();\n }\n get layout() {\n return this._layout;\n }\n get minWidth() {\n return this._layout.width * 40 + 1;\n }\n get minHeight() {\n return this._layout.height * 40 + 1;\n }\n}\n","import TypedEventEmitter from \"@shren/typed-event-emitter\";\n\nexport default abstract class AbstractComponent extends TypedEventEmitter {\n /**\n * The default state of the component.\n */\n static defaultProps: Record = {};\n get defaultProps() {\n return (this.constructor as typeof AbstractComponent).defaultProps as T;\n }\n /**\n * Here stores corrent state of component\n * change the state with `setState` method to fire state events\n * then UI parts will get notified and rerender\n */\n state: T;\n /**\n * Frame count in order to reduce frame rate\n */\n private $frame = 0;\n /**\n * Frame reducing factor, 1 = render at every browser rendering tick, 2 will skip one every two ticks.\n */\n frameReduce = 1;\n /**\n * Here stores current `requestAnimationFrame` reference\n * if we have a new state to render, we cancel the old one\n */\n private $raf: number;\n /**\n * `requestAnimationFrame` callback\n */\n private raf = () => {\n this.$frame++;\n if (this.$frame % this.frameReduce !== 0) {\n this.$raf = window.requestAnimationFrame(this.raf);\n return;\n }\n this.$raf = undefined;\n this.tasks.forEach(f => f());\n this.tasks = [];\n };\n /**\n * tasks to execute in next redering tick\n */\n private tasks: (() => any)[] = [];\n /**\n * Initiate default state with incoming state.\n */\n constructor(props?: T) {\n super();\n this.state = { ...this.defaultProps, ...props };\n }\n /**\n * set internal state and fire events for UI parts subscribed\n */\n setState(newState: Partial) {\n let shouldUpdate = false;\n for (const stateKey in newState) {\n const stateValue = newState[stateKey];\n if (stateKey in this.state && this.state[stateKey] !== stateValue) {\n this.state[stateKey] = stateValue;\n shouldUpdate = true;\n } else return;\n if (shouldUpdate) this.emit(stateKey, this.state[stateKey]);\n }\n }\n /**\n * Use this method to request a new rendering\n * schedule what you need to do in next render tick in `raf` callback\n */\n schedule(func: () => any) {\n if (this.tasks.indexOf(func) === -1) this.tasks.push(func);\n if (this.$raf) return;\n this.$raf = window.requestAnimationFrame(this.raf);\n }\n}\n","import AbstractComponent from \"./AbstractComponent\";\nimport { normalize, normExp, normLog } from \"./utils\";\nimport type { FaustUIItemStyle, FaustUIItemProps, PointerDownEvent, PointerDragEvent, PointerUpEvent } from \"./types\";\nimport \"./Base.scss\";\n\n/**\n * Abstract class that describes a FaustUI Component\n * this is an event emitter that emits every state change to inform UI renderer parts\n * Each UI parts could subscribe to a specific state such as `value`, `min`, `max` or `style`\n * when the event subscribed is fired, this part of ui updated using its own handler without updating the rest of UI parts\n * the types of events is restricted to the same as keys of `state` object:\n * `state` object is a `FaustUIItemProps` with a `style` object that contains `T` defined by child class.\n * Child class can override life cycle methods\n * `componentWillMount` prepare data before DOM get loads to page\n * `mount` get DOMs append to page\n * `componentDidMount` Now draw canvas etc.\n */\nexport default abstract class AbstractItem extends AbstractComponent> {\n /**\n * The default state of the component.\n */\n static defaultProps: FaustUIItemProps = {\n value: 0,\n active: true,\n focus: false,\n label: \"\",\n address: \"\",\n min: 0,\n max: 1,\n enums: {},\n type: \"float\",\n unit: \"\",\n scale: \"linear\",\n step: 0.01,\n style: { width: 45, height: 15, left: 0, top: 0, labelcolor: \"rgba(226, 222, 255, 0.5)\" }\n };\n /**\n * DOM Div container of the component\n */\n container: HTMLDivElement;\n /**\n * DOM Div container of label canvas\n */\n label: HTMLDivElement;\n /**\n * Use canvas as label to fit full text in.\n */\n labelCanvas: HTMLCanvasElement;\n labelCtx: CanvasRenderingContext2D;\n /**\n * Override this to get css work\n */\n className: string;\n frameReduce = 3;\n /**\n * Default DOM event listeners, unify mousedown and touchstart events\n * For mouse or touch events, please use `handlePointerDown` `handlePointerUp` `handlePointerDrag` callbacks\n */\n handleKeyDown = (e: KeyboardEvent) => {};\n handleKeyUp = (e: KeyboardEvent) => {};\n handleTouchStart = (e: TouchEvent) => {\n e.preventDefault();\n const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();\n let prevX = e.touches[0].clientX;\n let prevY = e.touches[0].clientY;\n const fromX = prevX - rect.left;\n const fromY = prevY - rect.top;\n const prevValue = this.state.value;\n this.handlePointerDown({ x: fromX, y: fromY, originalEvent: e });\n const handleTouchMove = (e: TouchEvent) => {\n e.preventDefault();\n const clientX = e.changedTouches[0].clientX;\n const clientY = e.changedTouches[0].clientY;\n const movementX = clientX - prevX;\n const movementY = clientY - prevY;\n prevX = clientX;\n prevY = clientY;\n const x = clientX - rect.left;\n const y = clientY - rect.top;\n this.handlePointerDrag({ prevValue, x, y, fromX, fromY, movementX, movementY, originalEvent: e });\n };\n const handleTouchEnd = (e: TouchEvent) => {\n e.preventDefault();\n const x = e.changedTouches[0].clientX - rect.left;\n const y = e.changedTouches[0].clientY - rect.top;\n this.handlePointerUp({ x, y, originalEvent: e });\n document.removeEventListener(\"touchmove\", handleTouchMove);\n document.removeEventListener(\"touchend\", handleTouchEnd);\n };\n document.addEventListener(\"touchmove\", handleTouchMove, { passive: false });\n document.addEventListener(\"touchend\", handleTouchEnd, { passive: false });\n };\n handleWheel = (e: WheelEvent) => {};\n handleClick = (e: MouseEvent) => {};\n handleMouseDown = (e: MouseEvent) => {\n e.preventDefault();\n (e.currentTarget as HTMLElement).focus();\n const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();\n const fromX = e.clientX - rect.left;\n const fromY = e.clientY - rect.top;\n const prevValue = this.state.value;\n this.handlePointerDown({ x: fromX, y: fromY, originalEvent: e });\n const handleMouseMove = (e: MouseEvent) => {\n e.preventDefault();\n const x = e.clientX - rect.left;\n const y = e.clientY - rect.top;\n this.handlePointerDrag({ prevValue, x, y, fromX, fromY, movementX: e.movementX, movementY: e.movementY, originalEvent: e });\n };\n const handleMouseUp = (e: MouseEvent) => {\n e.preventDefault();\n const x = e.clientX - rect.left;\n const y = e.clientY - rect.top;\n this.handlePointerUp({ x, y, originalEvent: e });\n document.removeEventListener(\"mousemove\", handleMouseMove);\n document.removeEventListener(\"mouseup\", handleMouseUp);\n };\n document.addEventListener(\"mousemove\", handleMouseMove);\n document.addEventListener(\"mouseup\", handleMouseUp);\n };\n handleMouseOver = (e: MouseEvent) => {};\n handleMouseOut = (e: MouseEvent) => {};\n handleContextMenu = (e: MouseEvent) => {};\n handlePointerDown = (e: PointerDownEvent) => {};\n handlePointerDrag = (e: PointerDragEvent) => {};\n handlePointerUp = (e: PointerUpEvent) => {};\n handleFocusIn = (e: FocusEvent) => this.setState({ focus: true });\n handleFocusOut = (e: FocusEvent) => this.setState({ focus: false });\n\n /**\n * Initiate default state with incoming state.\n */\n constructor(props?: FaustUIItemProps) {\n super(props);\n this.state.style = { ...this.defaultProps.style, ...props.style };\n if (this.state.emitter) this.state.emitter.register(this.state.address, this);\n }\n /**\n * Get a nearest valid number\n */\n toValidNumber(value: number) {\n const { min, max, step } = this.state;\n if (typeof min !== \"number\" || typeof max !== \"number\") return value;\n const v = Math.min(max, Math.max(min, value));\n if (!step) return v;\n return min + Math.floor((v - min) / step) * step;\n }\n /**\n * Use this method if you want the emitter to send value to DSP\n */\n setValue(valueIn: number) {\n const value = this.toValidNumber(valueIn);\n const changed = this.setState({ value });\n if (changed) this.change(value);\n return changed;\n }\n /**\n * Send value to DSP\n */\n change(valueIn?: number) {\n if (this.state.emitter) this.state.emitter.paramChangeByUI(this.state.address, typeof valueIn === \"number\" ? valueIn : this.state.value);\n }\n /**\n * set internal state and fire events for UI parts subscribed\n * This will not send anything to DSP\n * @returns is state updated\n */\n setState(newState: { [key in keyof FaustUIItemProps]?: FaustUIItemProps[key] }) {\n let shouldUpdate = false;\n for (const key in newState) {\n const stateKey = key as keyof FaustUIItemProps;\n const stateValue = newState[stateKey];\n if (stateKey === \"style\") {\n for (const styleKey in newState.style) {\n if (styleKey in this.state.style /* Fix hidden -> canvas not rendered bug && this.state.style[styleKey] !== newState.style[styleKey] */) {\n this.state.style[styleKey] = newState.style[styleKey];\n shouldUpdate = true;\n }\n }\n } else if (stateKey in this.state && this.state[stateKey] !== stateValue) {\n (this.state as any)[stateKey] = stateValue;\n shouldUpdate = true;\n } else return false;\n if (shouldUpdate) this.emit(stateKey, this.state[stateKey]);\n }\n return shouldUpdate;\n }\n /**\n * Create container with class name\n * override it with `super.componentWillMount();`\n */\n componentWillMount() {\n this.container = document.createElement(\"div\");\n this.container.className = [\"faust-ui-component\", \"faust-ui-component-\" + this.className].join(\" \");\n this.container.tabIndex = 1;\n this.container.id = this.state.address;\n if (this.state.tooltip) this.container.title = this.state.tooltip;\n this.label = document.createElement(\"div\");\n this.label.className = \"faust-ui-component-label\";\n this.labelCanvas = document.createElement(\"canvas\");\n this.labelCtx = this.labelCanvas.getContext(\"2d\");\n return this;\n }\n /**\n * Here append all child DOM to container\n */\n mount() {\n this.label.appendChild(this.labelCanvas);\n return this;\n }\n paintLabel(align?: CanvasTextAlign) {\n const label = this.state.label;\n const color = this.state.style.labelcolor;\n const ctx = this.labelCtx;\n const canvas = this.labelCanvas;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = this.label.getBoundingClientRect();\n if (!width || !height) return this;\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n ctx.clearRect(0, 0, width, height);\n ctx.fillStyle = color;\n ctx.textBaseline = \"middle\";\n ctx.textAlign = align || \"center\";\n ctx.font = `bold ${height * 0.9}px -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, \"Noto Sans\", sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\", \"Noto Color Emoji\"`;\n ctx.fillText(label, align === \"left\" ? 0 : align === \"right\" ? width : width / 2, height / 2, width);\n return this;\n }\n /**\n * will call this method when mounted\n */\n componentDidMount() {\n const handleResize = () => {\n const { grid, left, top, width, height } = this.state.style;\n this.container.style.width = `${width * grid}px`;\n this.container.style.height = `${height * grid}px`;\n this.container.style.left = `${left * grid}px`;\n this.container.style.top = `${top * grid}px`;\n this.label.style.height = `${grid * 0.25}px`;\n this.paintLabel();\n };\n this.on(\"style\", () => this.schedule(handleResize));\n handleResize();\n return this;\n }\n /**\n * Count steps in range min-max with step\n */\n get stepsCount() {\n const { type, max, min, step, enums } = this.state;\n const maxSteps = type === \"enum\" ? enums.length : type === \"int\" ? max - min : (max - min) / step;\n if (step) {\n if (type === \"enum\") return enums.length;\n if (type === \"int\") return Math.min(Math.floor((max - min) / (Math.round(step) || 1)), maxSteps);\n return Math.floor((max - min) / step);\n }\n return maxSteps;\n }\n /**\n * Normalized value between 0 - 1.\n */\n get distance() {\n const { type, max, min, value, enums, scale } = this.state;\n return AbstractItem.getDistance({ type, max, min, value, enums, scale });\n }\n static getDistance(state: { value: number; min: number; max: number; enums?: { [key: string]: number }; type: \"enum\" | \"int\" | \"float\"; scale: \"linear\" | \"exp\" | \"log\" }) {\n const { type, max, min, value, enums, scale } = state;\n if (type === \"enum\") return value / (enums.length - 1);\n const v = scale === \"exp\" ? normLog(value, min, max) : scale === \"log\" ? normExp(value, min, max) : value;\n return normalize(v, min, max);\n }\n /**\n * Mousemove pixels for each step\n */\n get stepRange() {\n const full = 100;\n const stepsCount = this.stepsCount;\n return full / stepsCount;\n }\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemStyle, FaustUIItemProps } from \"./types\";\nimport \"./Button.scss\";\n\nexport interface FaustUIButtonStyle extends FaustUIItemStyle {\n fontname?: string;\n fontsize?: number;\n fontface?: \"normal\" | \"bold\" | \"italic\" | \"bold italic\";\n bgcolor?: string;\n bgoncolor?: string;\n bordercolor?: string;\n borderoncolor?: string;\n textcolor?: string;\n textoncolor?: string;\n}\nexport default class Button extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"normal\",\n bgcolor: \"rgba(40, 40, 40, 1)\",\n bgoncolor: \"rgba(18, 18, 18, 1)\",\n bordercolor: \"rgba(80, 80, 80, 1)\",\n borderoncolor: \"rgba(255, 165, 0, 1)\",\n textcolor: \"rgba(226, 222, 255, 0.5)\",\n textoncolor: \"rgba(255, 165, 0, 1)\"\n }\n };\n }\n className = \"button\";\n\n btn: HTMLDivElement;\n span: HTMLSpanElement;\n componentWillMount() {\n super.componentWillMount();\n this.btn = document.createElement(\"div\");\n this.span = document.createElement(\"span\");\n this.span.innerText = this.state.label;\n this.setStyle();\n return this;\n }\n setStyle = () => {\n const { value, style } = this.state;\n const { height, grid, fontsize, fontname, fontface, textcolor, textoncolor, bgoncolor, bgcolor, bordercolor, borderoncolor } = style;\n this.btn.style.backgroundColor = value ? bgoncolor : bgcolor;\n this.btn.style.borderColor = value ? borderoncolor : bordercolor;\n this.btn.style.color = value ? textoncolor : textcolor;\n this.btn.style.fontSize = `${fontsize || height * grid / 4}px`;\n this.btn.style.fontFamily = `${fontname}, sans-serif`;\n this.btn.style.fontStyle = fontface;\n };\n mount() {\n this.btn.appendChild(this.span);\n this.container.appendChild(this.btn);\n return super.mount();\n }\n componentDidMount() {\n super.componentDidMount();\n this.btn.addEventListener(\"mousedown\", this.handleMouseDown);\n this.btn.addEventListener(\"touchstart\", this.handleTouchStart);\n this.on(\"style\", () => this.schedule(this.setStyle));\n const labelChange = () => this.span.innerText = this.state.label;\n this.on(\"label\", () => this.schedule(labelChange));\n this.on(\"value\", () => this.schedule(this.setStyle));\n return this;\n }\n handlePointerDown = () => {\n this.setValue(1);\n };\n handlePointerUp = () => {\n this.setValue(0);\n };\n}\n","import Button from \"./Button\";\nimport \"./Checkbox.scss\";\n\nexport default class Checkbox extends Button {\n className = \"checkbox\";\n\n handlePointerDown = () => {\n this.setValue(1 - this.state.value);\n };\n handlePointerUp = () => {\n };\n}\n","import type { FaustUIMeta } from \"@grame/faustwasm\";\nimport AbstractComponent from \"./AbstractComponent\";\nimport AbstractItem from \"./AbstractItem\";\nimport HSlider from \"./HSlider\";\nimport VSlider from \"./VSlider\";\nimport Nentry from \"./Nentry\";\nimport Soundfile from \"./Soundfile\";\nimport Button from \"./Button\";\nimport Checkbox from \"./Checkbox\";\nimport Knob from \"./Knob\";\nimport Menu from \"./Menu\";\nimport Radio from \"./Radio\";\nimport Led from \"./Led\";\nimport Numerical from \"./Numerical\";\nimport HBargraph from \"./HBargraph\";\nimport VBargraph from \"./VBargraph\";\nimport Layout from \"../layout/Layout\";\nimport type FaustUI from \"../FaustUI\";\nimport type LayoutAbstractGroup from \"../layout/AbstractGroup\";\nimport type LayoutAbstractInputItem from \"../layout/AbstractInputItem\";\nimport type LayoutAbstractOutputItem from \"../layout/AbstractOutputItem\";\nimport type { FaustUIItemProps, FaustUIItemStyle, FaustUIGroupProps } from \"./types\";\nimport type { LayoutProps } from \"../types\";\nimport \"./Group.scss\";\n\nexport interface GroupProps extends FaustUIGroupProps {\n items?: (LayoutAbstractGroup | LayoutAbstractInputItem | LayoutAbstractOutputItem)[];\n}\nexport default class Group extends AbstractComponent {\n static parseMeta(metaIn: FaustUIMeta[]): { metaObject: FaustUIMeta; enums?: { [key: string]: number } } {\n const metaObject: FaustUIMeta = {};\n if (!metaIn) return { metaObject };\n metaIn.forEach(m => Object.assign(metaObject, m));\n if (metaObject.style) {\n const enumsRegex = /\\{(?:(?:'|_|-)(.+?)(?:'|_|-):([-+]?[0-9]*\\.?[0-9]+?);)+(?:(?:'|_|-)(.+?)(?:'|_|-):([-+]?[0-9]*\\.?[0-9]+?))\\}/;\n const matched = metaObject.style.match(enumsRegex);\n if (matched) {\n const itemsRegex = /(?:(?:'|_|-)(.+?)(?:'|_|-):([-+]?[0-9]*\\.?[0-9]+?))/g;\n const enums: { [key: string]: number } = {};\n let item;\n // eslint-disable-next-line no-cond-assign\n while (item = itemsRegex.exec(matched[0])) {\n enums[item[1]] = +item[2];\n }\n return { metaObject, enums };\n }\n }\n return { metaObject };\n }\n static getComponent(item: LayoutAbstractGroup | LayoutAbstractInputItem | LayoutAbstractOutputItem, emitter: FaustUI, grid: number) {\n const type = Layout.predictType(item);\n if (type.endsWith(\"group\")) {\n const { label, items, type, layout } = item as LayoutAbstractGroup;\n const props: GroupProps = {\n label,\n type,\n items,\n style: {\n grid,\n width: layout.width,\n height: layout.height,\n left: layout.offsetLeft,\n top: layout.offsetTop,\n labelcolor: \"rgba(255, 255, 255, 0.7)\"\n },\n emitter\n };\n return new Group(props);\n }\n const ioItem = item as LayoutAbstractInputItem | LayoutAbstractOutputItem;\n const { metaObject, enums } = this.parseMeta(ioItem.meta);\n const { tooltip, unit, scale } = metaObject;\n const { label, min, max, address, layout } = ioItem;\n const props: FaustUIItemProps = {\n label,\n address,\n tooltip,\n unit,\n scale: scale || \"linear\",\n emitter,\n enums,\n style: {\n grid,\n width: layout.width,\n height: layout.height,\n left: layout.offsetLeft,\n top: layout.offsetTop\n },\n type: \"float\",\n min: isFinite(min) ? min : 0,\n max: isFinite(max) ? max : 1,\n step: \"step\" in item ? +item.step : 1,\n value: \"init\" in item ? +item.init || 0 : 0\n };\n if (type === \"button\") return new Button(props);\n if (type === \"checkbox\") return new Checkbox(props);\n if (type === \"nentry\") return new Nentry(props);\n if (type === \"soundfile\") return new Soundfile(props);\n if (type === \"knob\") return new Knob(props);\n if (type === \"menu\") return new Menu(props);\n if (type === \"radio\") return new Radio(props);\n if (type === \"hslider\") return new HSlider(props);\n if (type === \"vslider\") return new VSlider(props);\n if (type === \"hbargraph\") return new HBargraph(props);\n if (type === \"vbargraph\") return new VBargraph(props);\n if (type === \"numerical\") return new Numerical(props);\n if (type === \"led\") return new Led(props);\n return null;\n }\n /**\n * DOM Div container of the group\n */\n container: HTMLDivElement;\n /**\n * DOM Div container of label canvas\n */\n label: HTMLDivElement;\n /**\n * Use canvas as label to fit full text in.\n */\n labelCanvas: HTMLCanvasElement;\n labelCtx: CanvasRenderingContext2D;\n tabs: HTMLDivElement;\n children: (AbstractItem | Group)[];\n layout: LayoutProps;\n setState(newState: { [key in keyof FaustUIGroupProps]?: FaustUIGroupProps[key] }) {\n let shouldUpdate = false;\n for (const key in newState) {\n const stateKey = key as keyof FaustUIGroupProps;\n const stateValue = newState[stateKey];\n if (stateKey === \"style\") {\n for (const key in newState.style) {\n const styleKey = key as keyof FaustUIItemStyle;\n if (styleKey in this.state.style /* Fix hidden -> canvas not rendered bug && this.state.style[styleKey] !== newState.style[styleKey] */) {\n (this.state.style as any)[styleKey] = newState.style[styleKey];\n shouldUpdate = true;\n }\n }\n } else if (stateKey in this.state && this.state[stateKey] !== stateValue) {\n (this.state as any)[stateKey] = stateValue;\n shouldUpdate = true;\n } else return;\n if (shouldUpdate) this.emit(stateKey, this.state[stateKey]);\n }\n }\n componentWillMount() {\n this.container = document.createElement(\"div\");\n this.tabs = document.createElement(\"div\");\n this.tabs.className = \"faust-ui-tgroup-tabs\";\n if (!this.state.isRoot) {\n this.label = document.createElement(\"div\");\n this.label.className = \"faust-ui-group-label\";\n this.labelCanvas = document.createElement(\"canvas\");\n this.labelCtx = this.labelCanvas.getContext(\"2d\");\n }\n this.updateUI();\n this.children.forEach(item => item.componentWillMount());\n return this;\n }\n paintLabel() {\n if (this.state.isRoot) return this;\n const label = this.state.label;\n const color = this.state.style.labelcolor;\n const ctx = this.labelCtx;\n const canvas = this.labelCanvas;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = this.label.getBoundingClientRect();\n if (!width || !height) return this;\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n ctx.clearRect(0, 0, width, height);\n ctx.fillStyle = color;\n ctx.textBaseline = \"middle\";\n ctx.textAlign = \"left\";\n ctx.font = `bold ${height * 0.9}px -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, \"Noto Sans\", sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\", \"Noto Color Emoji\"`;\n ctx.fillText(label, 0, height / 2, width);\n return this;\n }\n updateUI = () => {\n this.children = [];\n const { style, type, items, emitter, isRoot } = this.state as GroupProps;\n const { grid, left, top, width, height } = style;\n if (!this.state.isRoot) this.label.style.height = `${grid * 0.3}px`;\n this.container.style.left = `${left * grid}px`;\n this.container.style.top = `${top * grid}px`;\n this.container.style.width = `${width * grid}px`;\n this.container.style.height = `${height * grid}px`;\n this.container.className = [\"faust-ui-group\", `faust-ui-${type}`, `${isRoot ? \"faust-ui-root\" : \"\"}`].join(\" \");\n items.forEach((item) => {\n if (item.type.endsWith(\"group\")) {\n const component = Group.getComponent(item, emitter, grid);\n if (component) this.children.push(component);\n } else {\n const ioItem = item as LayoutAbstractInputItem | LayoutAbstractOutputItem;\n const itemComponent = Group.getComponent(ioItem, this.state.emitter, grid);\n if (itemComponent) this.children.push(itemComponent);\n }\n });\n if (type === \"tgroup\") {\n this.tabs.innerHTML = \"\";\n this.tabs.style.height = `${grid}px`;\n this.tabs.style.top = `${0.25 * grid}px`;\n this.state.items.forEach((item, i) => {\n const label = item.label;\n const tab = document.createElement(\"span\");\n tab.innerText = label;\n tab.className = \"faust-ui-tgroup-tab\";\n tab.style.fontSize = `${0.25 * grid}px`;\n tab.style.width = `${2 * grid - 20}px`;\n tab.style.height = `${grid - 20}px`;\n tab.style.lineHeight = `${grid - 20}px`;\n tab.addEventListener(\"click\", () => {\n const groups: HTMLDivElement[] = [];\n for (let j = 0; j < this.container.children.length; j++) {\n const element = this.container.children[j] as HTMLDivElement;\n if (j > 1) groups.push(element);\n }\n for (let j = 0; j < groups.length; j++) {\n const element = groups[j] as HTMLDivElement;\n element.style.visibility = i === j ? \"visible\" : \"hidden\";\n }\n for (let j = 0; j < this.tabs.children.length; j++) {\n const e = this.tabs.children[j];\n if (i !== j) {\n if (e.classList.contains(\"active\")) e.classList.remove(\"active\");\n } else e.classList.add(\"active\");\n }\n });\n this.tabs.appendChild(tab);\n });\n }\n };\n mount() {\n if (!this.state.isRoot) {\n this.label.appendChild(this.labelCanvas);\n this.container.appendChild(this.label);\n }\n if (this.tabs.children.length) this.container.appendChild(this.tabs);\n this.children.forEach((item) => {\n item.mount();\n this.container.appendChild(item.container);\n });\n return this;\n }\n componentDidMount() {\n const handleResize = () => {\n const { grid, left, top, width, height } = this.state.style;\n if (!this.state.isRoot) this.label.style.height = `${grid * 0.3}px`;\n this.container.style.width = `${width * grid}px`;\n this.container.style.height = `${height * grid}px`;\n this.container.style.left = `${left * grid}px`;\n this.container.style.top = `${top * grid}px`;\n if (this.state.type === \"tgroup\") {\n this.tabs.style.height = `${grid}px`;\n this.tabs.style.top = `${0.25 * grid}px`;\n for (let i = 0; i < this.tabs.children.length; i++) {\n const tab = this.tabs.children[i] as HTMLSpanElement;\n tab.style.fontSize = `${0.25 * grid}px`;\n tab.style.width = `${2 * grid - 20}px`;\n tab.style.height = `${grid - 20}px`;\n tab.style.lineHeight = `${grid - 20}px`;\n }\n }\n this.paintLabel();\n this.children.forEach(item => item.setState({ style: { grid } }));\n };\n this.on(\"style\", () => this.schedule(handleResize));\n const itemsChange = () => {\n this.updateUI();\n this.children.forEach(item => item.componentWillMount());\n };\n this.on(\"items\", () => this.schedule(itemsChange));\n const labelChange = () => {\n this.paintLabel();\n this.label.title = this.state.label;\n };\n this.on(\"label\", () => this.schedule(labelChange));\n this.paintLabel();\n if (this.tabs && this.tabs.children.length) (this.tabs.children[0] as HTMLSpanElement).click();\n this.children.forEach(item => item.componentDidMount());\n return this;\n }\n}\n","import AbstractItem from \"./AbstractItem\";\nimport VBargraph from \"./VBargraph\";\nimport \"./HBargraph.scss\";\n\nexport default class HBargraph extends VBargraph {\n className = \"hbargraph\";\n\n paintLabel() {\n return super.paintLabel(\"left\");\n }\n setStyle = () => {\n const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n this.input.style.fontSize = `${fontsize || height * grid * 0.2}px`;\n this.input.style.color = textcolor;\n this.container.style.backgroundColor = bgcolor;\n this.container.style.borderColor = bordercolor;\n };\n paint = () => {\n const { barwidth, barbgcolor, coldcolor, warmcolor, hotcolor, overloadcolor } = this.state.style;\n const { type, max, min, enums, scale, value } = this.state;\n const ctx = this.ctx;\n const canvas = this.canvas;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = this.canvasDiv.getBoundingClientRect();\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n\n const drawWidth = width * 0.9;\n const drawHeight = barwidth || Math.min(height / 3, drawWidth * 0.05);\n const left = width * 0.05;\n const top = (height - drawHeight) * 0.5;\n this.paintValue = value;\n const paintValue = this.paintValue;\n if (paintValue > this.maxValue) {\n this.maxValue = paintValue;\n if (this.maxTimer) window.clearTimeout(this.maxTimer);\n this.maxTimer = window.setTimeout(() => {\n this.maxValue = this.paintValue;\n this.maxTimer = undefined;\n this.schedule(this.paint);\n }, 1000);\n }\n if (paintValue < this.maxValue && typeof this.maxTimer === \"undefined\") {\n this.maxTimer = window.setTimeout(() => {\n this.maxValue = this.paintValue;\n this.maxTimer = undefined;\n this.schedule(this.paint);\n }, 1000);\n }\n const maxValue = this.maxValue;\n const coldStop = (-18 - min) / (max - min);\n const warmStop = (-6 - min) / (max - min);\n const hotStop = (-3 - min) / (max - min);\n const overloadStop = Math.max(0, -min / (max - min));\n const gradient = ctx.createLinearGradient(left, 0, drawWidth, 0);\n if (coldStop <= 1 && coldStop >= 0) gradient.addColorStop(coldStop, coldcolor);\n else if (coldStop > 1) gradient.addColorStop(1, coldcolor);\n if (warmStop <= 1 && warmStop >= 0) gradient.addColorStop(warmStop, warmcolor);\n if (hotStop <= 1 && hotStop >= 0) gradient.addColorStop(hotStop, hotcolor);\n if (overloadStop <= 1 && overloadStop >= 0) gradient.addColorStop(overloadStop, overloadcolor);\n else if (overloadStop < 0) gradient.addColorStop(0, coldcolor);\n\n ctx.fillStyle = barbgcolor;\n if (paintValue < 0) ctx.fillRect(left, top, drawWidth * overloadStop, drawHeight);\n if (paintValue < max) ctx.fillRect(left + drawWidth * overloadStop + 1, top, drawWidth * (1 - overloadStop) - 1, drawHeight);\n ctx.fillStyle = gradient;\n if (paintValue > min) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(0, paintValue) }));\n ctx.fillRect(left, top, distance * drawWidth, drawHeight);\n }\n if (paintValue > 0) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(max, paintValue) }) - overloadStop);\n ctx.fillRect(left + overloadStop * drawWidth + 1, top, distance * drawWidth - 1, drawHeight);\n }\n if (maxValue > paintValue) {\n if (maxValue <= 0) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(0, maxValue) }));\n ctx.fillRect(left + distance * drawWidth - 1, top, 1, drawHeight);\n }\n if (maxValue > 0) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(max, maxValue) }) - overloadStop);\n ctx.fillRect(left + Math.min(drawWidth - 1, (overloadStop + distance) * drawWidth), top, 1, drawHeight);\n }\n }\n };\n}\n","import { fillRoundedRect } from \"./utils\";\nimport VSlider from \"./VSlider\";\nimport \"./HSlider.scss\";\n\nexport default class HSlider extends VSlider {\n className = \"hslider\";\n\n paintLabel() {\n return super.paintLabel(\"left\");\n }\n setStyle = () => {\n const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n this.input.style.fontSize = `${fontsize || height * grid * 0.2}px`;\n this.input.style.color = textcolor;\n this.container.style.backgroundColor = bgcolor;\n this.container.style.borderColor = bordercolor;\n };\n paint = () => {\n const { sliderwidth, sliderbgcolor, sliderbgoncolor, slidercolor } = this.state.style;\n const ctx = this.ctx;\n const canvas = this.canvas;\n const distance = this.distance;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = this.canvasDiv.getBoundingClientRect();\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n\n const drawWidth = width * 0.9;\n const drawHeight = sliderwidth || Math.min(height / 3, drawWidth * 0.05);\n const left = width * 0.05;\n const top = (height - drawHeight) * 0.5;\n const borderRadius = drawHeight * 0.25;\n this.interactionRect = [left, 0, drawWidth, height];\n const grd = ctx.createLinearGradient(left, 0, left + drawWidth, 0);\n grd.addColorStop(Math.max(0, Math.min(1, distance)), sliderbgoncolor);\n grd.addColorStop(Math.max(0, Math.min(1, distance)), sliderbgcolor);\n ctx.fillStyle = grd;\n fillRoundedRect(ctx, left, top, drawWidth, drawHeight, borderRadius);\n // draw slider\n ctx.fillStyle = slidercolor;\n fillRoundedRect(ctx, left + drawWidth * distance - drawHeight, top - drawHeight, drawHeight * 2, drawHeight * 3, borderRadius);\n };\n}\n","import AbstractItem from \"./AbstractItem\";\nimport { toRad, normLog, normExp, denormalize, normalize } from \"./utils\";\nimport type { FaustUIItemProps, PointerDragEvent } from \"./types\";\nimport type { FaustUINentryStyle } from \"./Nentry\";\nimport \"./Knob.scss\";\n\ninterface FaustUIKnobStyle extends FaustUINentryStyle {\n knobwidth?: number;\n knobcolor?: string;\n knoboncolor?: string;\n needlecolor?: string;\n}\nexport default class Knob extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(18, 18, 18, 0)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\",\n knobwidth: undefined,\n knobcolor: \"rgba(18, 18, 18, 1)\",\n knoboncolor: \"rgba(255, 165, 0, 1)\",\n needlecolor: \"rgba(200, 200, 200, 0.75)\"\n }\n };\n }\n className = \"knob\";\n\n canvas: HTMLCanvasElement;\n inputNumber: HTMLInputElement;\n input: HTMLInputElement;\n ctx: CanvasRenderingContext2D;\n componentWillMount() {\n super.componentWillMount();\n this.canvas = document.createElement(\"canvas\");\n this.canvas.width = 10;\n this.canvas.height = 10;\n this.ctx = this.canvas.getContext(\"2d\");\n this.inputNumber = document.createElement(\"input\");\n this.inputNumber.type = \"number\";\n this.inputNumber.value = (+this.state.value.toFixed(3)).toString();\n this.inputNumber.max = this.state.max.toString();\n this.inputNumber.min = this.state.min.toString();\n this.inputNumber.step = this.state.step.toString();\n this.input = document.createElement(\"input\");\n this.input.value = this.inputNumber.value + (this.state.unit || \"\");\n this.input.spellcheck = false;\n this.setStyle();\n return this;\n }\n handleChange = (e: Event) => {\n const value = parseFloat((e.currentTarget as HTMLInputElement).value);\n if (isFinite(value)) {\n const changed = this.setValue(+this.inputNumber.value);\n if (changed) return;\n }\n this.input.value = this.inputNumber.value + (this.state.unit || \"\");\n };\n setStyle = () => {\n const { fontsize, height, grid, textcolor, bgcolor, bordercolor } = this.state.style;\n this.input.style.fontSize = `${fontsize || height * grid * 0.1}px`;\n this.input.style.color = textcolor;\n this.container.style.backgroundColor = bgcolor;\n this.container.style.borderColor = bordercolor;\n };\n componentDidMount() {\n super.componentDidMount();\n this.input.addEventListener(\"change\", this.handleChange);\n this.canvas.addEventListener(\"mousedown\", this.handleMouseDown);\n this.canvas.addEventListener(\"touchstart\", this.handleTouchStart, { passive: false });\n this.on(\"style\", () => {\n this.schedule(this.setStyle);\n this.schedule(this.paint);\n });\n this.on(\"label\", () => this.schedule(this.paintLabel));\n const valueChange = () => {\n this.inputNumber.value = (+this.state.value.toFixed(3)).toString();\n this.input.value = this.inputNumber.value + (this.state.unit || \"\");\n };\n this.on(\"value\", () => {\n this.schedule(valueChange);\n this.schedule(this.paint);\n });\n const maxChange = () => this.inputNumber.max = this.state.max.toString();\n this.on(\"max\", () => {\n this.schedule(maxChange);\n this.schedule(this.paint);\n });\n const minChange = () => this.inputNumber.min = this.state.min.toString();\n this.on(\"min\", () => {\n this.schedule(minChange);\n this.schedule(this.paint);\n });\n const stepChange = () => this.inputNumber.step = this.state.step.toString();\n this.on(\"step\", () => {\n this.schedule(stepChange);\n this.schedule(this.paint);\n });\n this.schedule(this.paint);\n return this;\n }\n mount() {\n this.container.appendChild(this.label);\n this.container.appendChild(this.canvas);\n this.container.appendChild(this.input);\n return super.mount();\n }\n paint = () => {\n const { knobwidth, knobcolor, knoboncolor, needlecolor } = this.state.style;\n const ctx = this.ctx;\n const canvas = this.canvas;\n const distance = this.distance;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = this.canvas.getBoundingClientRect();\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n\n const start = 5 / 8 * Math.PI;\n const end = 19 / 8 * Math.PI;\n const valPos = start + toRad(distance * 315);\n const dialHeight = Math.min(width, height) * 0.75;\n const dialRadius = dialHeight * 0.5;\n const dialCenterX = width * 0.5;\n const dialCenterY = height * 0.5;\n // const arcStartX = dialCenterX + (dialHeight * 0.5 * Math.cos(start));\n // const arcStartY = dialCenterY + (dialHeight * 0.5 * Math.sin(start));\n // const arcEndX = dialCenterX + (dialHeight * 0.5 * Math.cos(end));\n // const arcEndY = dialCenterY + (dialHeight * 0.5 * Math.sin(end));\n const valuePosX = dialCenterX + (dialHeight * 0.5 * Math.cos(valPos));\n const valuePosY = dialCenterY + (dialHeight * 0.5 * Math.sin(valPos));\n const lineWidth = knobwidth || dialRadius * 0.2;\n\n ctx.strokeStyle = knobcolor;\n ctx.lineWidth = lineWidth;\n ctx.lineCap = \"round\";\n // draw background arc\n ctx.beginPath();\n ctx.arc(dialCenterX, dialCenterY, dialRadius, valPos, end);\n ctx.stroke();\n // draw value arc\n if (distance) {\n ctx.strokeStyle = knoboncolor;\n ctx.beginPath();\n ctx.arc(dialCenterX, dialCenterY, dialRadius, start, valPos);\n ctx.stroke();\n }\n // draw dial needle\n ctx.strokeStyle = needlecolor;\n ctx.beginPath();\n ctx.moveTo(dialCenterX, dialCenterY);\n ctx.lineTo(valuePosX, valuePosY);\n ctx.stroke();\n };\n getValueFromDelta(e: PointerDragEvent) {\n const { type, min, max, enums, scale } = this.state;\n const step = type === \"enum\" ? 1 : (this.state.step || 1);\n const stepRange = this.stepRange;\n const stepsCount = this.stepsCount;\n const range = 100;\n const prevDistance = AbstractItem.getDistance({ value: e.prevValue, type, min, max, enums, scale }) * range;\n const distance = prevDistance + e.fromY - e.y;\n const denormalized = denormalize(distance / range, min, max);\n const v = scale === \"exp\" ? normExp(denormalized, min, max) : scale === \"log\" ? normLog(denormalized, min, max) : denormalized;\n let steps = Math.round(normalize(v, min, max) * range / stepRange);\n steps = Math.min(stepsCount, Math.max(0, steps));\n if (type === \"enum\") return steps;\n if (type === \"int\") return Math.round(steps * step + min);\n return steps * step + min;\n }\n handlePointerDrag = (e: PointerDragEvent) => {\n const newValue = this.getValueFromDelta(e);\n if (newValue !== this.state.value) this.setValue(newValue);\n };\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemProps } from \"./types\";\nimport type { FaustUINentryStyle } from \"./Nentry\";\nimport \"./Led.scss\";\n\ninterface FaustUILedStyle extends FaustUINentryStyle {\n shape?: \"circle\" | \"square\";\n ledbgcolor?: string;\n coldcolor?: string;\n warmcolor?: string;\n hotcolor?: string;\n overloadcolor?: string;\n}\nexport default class Led extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(18, 18, 18, 0)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\",\n shape: \"circle\",\n ledbgcolor: \"rgba(18, 18, 18, 1)\",\n coldcolor: \"rgba(12, 248, 100, 1)\",\n warmcolor: \"rgba(195, 248, 100, 1)\",\n hotcolor: \"rgba(255, 193, 10, 1)\",\n overloadcolor: \"rgba(255, 10, 10, 1)\"\n }\n };\n }\n className = \"led\";\n\n canvasDiv: HTMLDivElement;\n canvas: HTMLCanvasElement;\n tempCanvas: HTMLCanvasElement;\n ctx: CanvasRenderingContext2D;\n tempCtx: CanvasRenderingContext2D;\n componentWillMount() {\n super.componentWillMount();\n this.canvasDiv = document.createElement(\"div\");\n this.canvasDiv.className = `faust-ui-component-${this.className}-canvasdiv`;\n this.canvas = document.createElement(\"canvas\");\n this.canvas.width = 10;\n this.canvas.height = 10;\n this.ctx = this.canvas.getContext(\"2d\");\n this.tempCanvas = document.createElement(\"canvas\");\n this.tempCtx = this.tempCanvas.getContext(\"2d\");\n this.tempCanvas.width = 128;\n this.tempCanvas.height = 1;\n this.setStyle();\n return this;\n }\n setStyle = () => {\n const { bgcolor, bordercolor } = this.state.style;\n this.container.style.backgroundColor = bgcolor;\n this.container.style.borderColor = bordercolor;\n };\n componentDidMount() {\n super.componentDidMount();\n this.canvas.addEventListener(\"mousedown\", this.handleMouseDown);\n this.canvas.addEventListener(\"touchstart\", this.handleTouchStart, { passive: false });\n this.on(\"style\", () => this.schedule(this.setStyle));\n this.on(\"label\", () => this.schedule(this.paintLabel));\n this.on(\"value\", () => this.schedule(this.paint));\n this.on(\"max\", () => this.schedule(this.paint));\n this.on(\"min\", () => this.schedule(this.paint));\n this.on(\"step\", () => this.schedule(this.paint));\n this.schedule(this.paint);\n return this;\n }\n mount() {\n this.canvasDiv.appendChild(this.canvas);\n this.container.appendChild(this.label);\n this.container.appendChild(this.canvasDiv);\n return super.mount();\n }\n paint = () => {\n const { shape, ledbgcolor, coldcolor, warmcolor, hotcolor, overloadcolor } = this.state.style;\n const { min, max } = this.state;\n const { canvas, ctx, tempCanvas, tempCtx, distance } = this;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = canvas.getBoundingClientRect();\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n\n const drawHeight = Math.min(height, width) * 0.75;\n const drawWidth = drawHeight;\n const left = (width - drawWidth) * 0.5;\n const top = (height - drawHeight) * 0.5;\n const coldStop = (-18 - min) / (max - min);\n const warmStop = (-6 - min) / (max - min);\n const hotStop = (-3 - min) / (max - min);\n const overloadStop = -min / (max - min);\n const gradient = tempCtx.createLinearGradient(0, 0, tempCanvas.width, 0);\n if (coldStop <= 1 && coldStop >= 0) gradient.addColorStop(coldStop, coldcolor);\n else if (coldStop > 1) gradient.addColorStop(1, coldcolor);\n if (warmStop <= 1 && warmStop >= 0) gradient.addColorStop(warmStop, warmcolor);\n if (hotStop <= 1 && hotStop >= 0) gradient.addColorStop(hotStop, hotcolor);\n if (overloadStop <= 1 && overloadStop >= 0) gradient.addColorStop(overloadStop, overloadcolor);\n else if (overloadStop < 0) gradient.addColorStop(0, coldcolor);\n tempCtx.fillStyle = gradient;\n tempCtx.fillRect(0, 0, tempCanvas.width, 10);\n const d = tempCtx.getImageData(Math.min(tempCanvas.width - 1, distance * tempCanvas.width), 0, 1, 1).data;\n if (distance) ctx.fillStyle = `rgb(${d[0]}, ${d[1]}, ${d[2]})`;\n else ctx.fillStyle = ledbgcolor;\n if (shape === \"circle\") ctx.arc(width / 2, height / 2, width / 2 - left, 0, 2 * Math.PI);\n else ctx.rect(left, top, drawWidth, drawHeight);\n ctx.fill();\n };\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemStyle, FaustUIItemProps } from \"./types\";\nimport \"./Menu.scss\";\n\nexport interface FaustUIMenuStyle extends FaustUIItemStyle {\n fontname?: string;\n fontsize?: number;\n fontface?: \"regular\" | \"bold\" | \"italic\" | \"bold italic\";\n bgcolor?: string;\n bordercolor?: string;\n labelcolor?: string;\n textcolor?: string;\n}\nexport default class Menu extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(255, 255, 255, 0.25)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\"\n }\n };\n }\n className = \"menu\";\n\n select: HTMLSelectElement;\n componentWillMount() {\n super.componentWillMount();\n this.select = document.createElement(\"select\");\n this.getOptions();\n this.setStyle();\n return this;\n }\n getOptions() {\n const { enums } = this.state;\n this.select.innerHTML = \"\";\n if (enums) {\n let i = 0;\n for (const key in enums) {\n const option = document.createElement(\"option\");\n option.value = enums[key].toString();\n option.text = key;\n if (i === 0) option.selected = true;\n this.select.appendChild(option);\n i++;\n }\n }\n }\n handleChange = (e: Event) => {\n this.setValue(+(e.currentTarget as HTMLInputElement).value);\n };\n setStyle = () => {\n const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n this.select.style.backgroundColor = bgcolor;\n this.select.style.borderColor = bordercolor;\n this.select.style.color = textcolor;\n this.select.style.fontSize = `${fontsize || height * grid / 4}px`;\n };\n componentDidMount() {\n super.componentDidMount();\n this.select.addEventListener(\"change\", this.handleChange);\n this.on(\"style\", () => this.schedule(this.setStyle));\n this.on(\"label\", () => this.schedule(this.paintLabel));\n this.on(\"enums\", () => this.schedule(this.getOptions));\n const valueChange = () => {\n for (let i = this.select.children.length - 1; i >= 0; i--) {\n const option = this.select.children[i] as HTMLOptionElement;\n if (+option.value === this.state.value) this.select.selectedIndex = i;\n }\n };\n this.on(\"value\", () => this.schedule(valueChange));\n valueChange();\n return this;\n }\n mount() {\n this.container.appendChild(this.label);\n this.container.appendChild(this.select);\n return super.mount();\n }\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemStyle, FaustUIItemProps } from \"./types\";\nimport \"./Nentry.scss\";\n\nexport interface FaustUINentryStyle extends FaustUIItemStyle {\n fontname?: string;\n fontsize?: number;\n fontface?: \"regular\" | \"bold\" | \"italic\" | \"bold italic\";\n bgcolor?: string;\n bordercolor?: string;\n labelcolor?: string;\n textcolor?: string;\n}\nexport default class Nentry extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(255, 255, 255, 0.25)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\"\n }\n };\n }\n className = \"nentry\";\n\n input: HTMLInputElement;\n componentWillMount() {\n super.componentWillMount();\n this.input = document.createElement(\"input\");\n this.input.type = \"number\";\n this.input.value = (+this.state.value.toFixed(3)).toString();\n this.input.max = this.state.max.toString();\n this.input.min = this.state.min.toString();\n this.input.step = this.state.step.toString();\n this.setStyle();\n return this;\n }\n handleChange = (e: Event) => {\n this.setValue(+(e.currentTarget as HTMLInputElement).value);\n };\n setStyle = () => {\n const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n this.input.style.backgroundColor = bgcolor;\n this.input.style.borderColor = bordercolor;\n this.input.style.color = textcolor;\n this.input.style.fontSize = `${fontsize || height * grid / 4}px`;\n };\n componentDidMount() {\n super.componentDidMount();\n this.input.addEventListener(\"change\", this.handleChange);\n this.on(\"style\", () => this.schedule(this.setStyle));\n this.on(\"label\", () => this.schedule(this.paintLabel));\n const valueChange = () => this.input.value = (+this.state.value.toFixed(3)).toString();\n this.on(\"value\", () => this.schedule(valueChange));\n const maxChange = () => this.input.max = this.state.max.toString();\n this.on(\"max\", () => this.schedule(maxChange));\n const minChange = () => this.input.min = this.state.min.toString();\n this.on(\"min\", () => this.schedule(minChange));\n const stepChange = () => this.input.step = this.state.step.toString();\n this.on(\"step\", () => this.schedule(stepChange));\n return this;\n }\n mount() {\n this.container.appendChild(this.label);\n this.container.appendChild(this.input);\n return super.mount();\n }\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemProps } from \"./types\";\nimport type { FaustUINentryStyle } from \"./Nentry\";\nimport \"./Numerical.scss\";\n\nexport default class Numerical extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(255, 255, 255, 0.25)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\"\n }\n };\n }\n className = \"numerical\";\n\n input: HTMLInputElement;\n componentWillMount() {\n super.componentWillMount();\n this.input = document.createElement(\"input\");\n this.input.disabled = true;\n this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || \"\");\n this.setStyle();\n return this;\n }\n setStyle = () => {\n const { height, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n this.input.style.backgroundColor = bgcolor;\n this.input.style.borderColor = bordercolor;\n this.input.style.color = textcolor;\n this.input.style.fontSize = `${fontsize || height * grid / 4}px`;\n };\n componentDidMount() {\n super.componentDidMount();\n this.on(\"style\", () => this.schedule(this.setStyle));\n this.on(\"label\", () => this.schedule(this.paintLabel));\n const valueChange = () => this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || \"\");\n this.on(\"value\", () => this.schedule(valueChange));\n return this;\n }\n mount() {\n this.container.appendChild(this.label);\n this.container.appendChild(this.input);\n return super.mount();\n }\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemStyle, FaustUIItemProps } from \"./types\";\nimport \"./Radio.scss\";\n\nexport interface FaustUIRadioStyle extends FaustUIItemStyle {\n fontname?: string;\n fontsize?: number;\n fontface?: \"regular\" | \"bold\" | \"italic\" | \"bold italic\";\n bgcolor?: string;\n bordercolor?: string;\n labelcolor?: string;\n textcolor?: string;\n}\nexport default class Radio extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(255, 255, 255, 0.25)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\"\n }\n };\n }\n className = \"radio\";\n\n group: HTMLDivElement;\n componentWillMount() {\n super.componentWillMount();\n this.group = document.createElement(\"div\");\n this.group.className = \"faust-ui-component-radio-group\";\n this.getOptions();\n this.setStyle();\n return this;\n }\n getOptions = () => {\n const { enums, address } = this.state;\n this.group.innerHTML = \"\";\n if (enums) {\n let i = 0;\n for (const key in enums) {\n const input = document.createElement(\"input\");\n const div = document.createElement(\"div\");\n input.value = enums[key].toString();\n input.name = address;\n input.type = \"radio\";\n if (i === 0) input.checked = true;\n input.addEventListener(\"change\", () => {\n if (input.checked) this.setValue(enums[key]);\n });\n div.appendChild(input);\n div.append(key);\n this.group.appendChild(div);\n i++;\n }\n }\n };\n setStyle = () => {\n const { height, width, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n const fontSize = Math.min(height * grid * 0.1, width * grid * 0.1);\n this.group.style.backgroundColor = bgcolor;\n this.group.style.borderColor = bordercolor;\n this.group.style.color = textcolor;\n this.group.style.fontSize = `${fontsize || fontSize}px`;\n };\n componentDidMount() {\n super.componentDidMount();\n this.on(\"style\", () => this.schedule(this.setStyle));\n this.on(\"label\", () => this.schedule(this.paintLabel));\n this.on(\"enums\", () => this.schedule(this.getOptions));\n const valueChange = () => {\n for (let i = this.group.children.length - 1; i >= 0; i--) {\n const input = this.group.children[i].querySelector(\"input\");\n if (+input.value === this.state.value) input.checked = true;\n }\n };\n this.on(\"value\", () => this.schedule(valueChange));\n valueChange();\n return this;\n }\n mount() {\n this.container.appendChild(this.label);\n this.container.appendChild(this.group);\n return super.mount();\n }\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemStyle, FaustUIItemProps } from \"./types\";\nimport \"./Soundfile.scss\";\n\nexport interface FaustUISoundfileStyle extends FaustUIItemStyle {\n fontname?: string;\n fontsize?: number;\n fontface?: \"normal\" | \"bold\" | \"italic\" | \"bold italic\";\n bgcolor?: string;\n bgoncolor?: string;\n bordercolor?: string;\n borderoncolor?: string;\n textcolor?: string;\n textoncolor?: string;\n}\nexport default class Soundfile extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"normal\",\n bgcolor: \"rgba(40, 40, 40, 1)\",\n bgoncolor: \"rgba(18, 18, 18, 1)\",\n bordercolor: \"rgba(80, 80, 80, 1)\",\n borderoncolor: \"rgba(255, 165, 0, 1)\",\n textcolor: \"rgba(226, 222, 255, 0.5)\",\n textoncolor: \"rgba(255, 165, 0, 1)\"\n }\n };\n }\n className = \"soundfile\";\n\n btn: HTMLDivElement;\n span: HTMLSpanElement;\n componentWillMount() {\n super.componentWillMount();\n this.btn = document.createElement(\"div\");\n this.span = document.createElement(\"span\");\n this.span.innerText = this.state.label;\n this.setStyle();\n return this;\n }\n setStyle = () => {\n const { value, style } = this.state;\n const { height, grid, fontsize, fontname, fontface, textcolor, textoncolor, bgoncolor, bgcolor, bordercolor, borderoncolor } = style;\n this.btn.style.backgroundColor = value ? bgoncolor : bgcolor;\n this.btn.style.borderColor = value ? borderoncolor : bordercolor;\n this.btn.style.color = value ? textoncolor : textcolor;\n this.btn.style.fontSize = `${fontsize || height * grid / 4}px`;\n this.btn.style.fontFamily = `${fontname}, sans-serif`;\n this.btn.style.fontStyle = fontface;\n };\n mount() {\n this.btn.appendChild(this.span);\n this.container.appendChild(this.btn);\n return super.mount();\n }\n componentDidMount() {\n super.componentDidMount();\n this.btn.addEventListener(\"mousedown\", this.handleMouseDown);\n this.btn.addEventListener(\"touchstart\", this.handleTouchStart);\n this.on(\"style\", () => this.schedule(this.setStyle));\n const labelChange = () => this.span.innerText = this.state.label;\n this.on(\"label\", () => this.schedule(labelChange));\n this.on(\"value\", () => this.schedule(this.setStyle));\n return this;\n }\n handlePointerDown = () => {\n //this.setValue(1);\n };\n handlePointerUp = () => {\n //this.setValue(0);\n };\n}\n","import AbstractItem from \"./AbstractItem\";\nimport type { FaustUIItemProps } from \"./types\";\nimport type { FaustUINentryStyle } from \"./Nentry\";\nimport \"./VBargraph.scss\";\n\ninterface FaustUIBargraphStyle extends FaustUINentryStyle {\n barwidth?: number;\n barbgcolor?: string;\n coldcolor?: string;\n warmcolor?: string;\n hotcolor?: string;\n overloadcolor?: string;\n}\nexport default class VBargraph extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(18, 18, 18, 0)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\",\n barwidth: undefined,\n barbgcolor: \"rgba(18, 18, 18, 1)\",\n coldcolor: \"rgba(12, 248, 100, 1)\",\n warmcolor: \"rgba(195, 248, 100, 1)\",\n hotcolor: \"rgba(255, 193, 10, 1)\",\n overloadcolor: \"rgba(255, 10, 10, 1)\"\n }\n };\n }\n className = \"vbargraph\";\n\n canvas: HTMLCanvasElement;\n input: HTMLInputElement;\n flexDiv: HTMLDivElement;\n canvasDiv: HTMLDivElement;\n ctx: CanvasRenderingContext2D;\n componentWillMount() {\n super.componentWillMount();\n this.flexDiv = document.createElement(\"div\");\n this.flexDiv.className = `faust-ui-component-${this.className}-flexdiv`;\n this.canvasDiv = document.createElement(\"div\");\n this.canvasDiv.className = `faust-ui-component-${this.className}-canvasdiv`;\n this.canvas = document.createElement(\"canvas\");\n this.canvas.width = 10;\n this.canvas.height = 10;\n this.ctx = this.canvas.getContext(\"2d\");\n this.input = document.createElement(\"input\");\n this.input.disabled = true;\n this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || \"\");\n this.setStyle();\n return this;\n }\n setStyle = () => {\n const { height, width, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n const fontSize = Math.min(height * grid * 0.05, width * grid * 0.2);\n this.input.style.fontSize = `${fontsize || fontSize}px`;\n this.input.style.color = textcolor;\n this.container.style.backgroundColor = bgcolor;\n this.container.style.borderColor = bordercolor;\n };\n componentDidMount() {\n super.componentDidMount();\n this.canvas.addEventListener(\"mousedown\", this.handleMouseDown);\n this.canvas.addEventListener(\"touchstart\", this.handleTouchStart, { passive: false });\n this.on(\"style\", () => {\n this.schedule(this.setStyle);\n this.schedule(this.paint);\n });\n this.on(\"label\", () => this.schedule(this.paintLabel));\n const valueChange = () => this.input.value = (+this.state.value.toFixed(3)).toString() + (this.state.unit || \"\");\n this.on(\"value\", () => {\n this.schedule(valueChange);\n this.schedule(this.paint);\n });\n this.on(\"max\", () => this.schedule(this.paint));\n this.on(\"min\", () => this.schedule(this.paint));\n this.on(\"step\", () => this.schedule(this.paint));\n this.schedule(this.paint);\n return this;\n }\n mount() {\n this.canvasDiv.appendChild(this.canvas);\n this.flexDiv.appendChild(this.canvasDiv);\n this.flexDiv.appendChild(this.input);\n this.container.appendChild(this.label);\n this.container.appendChild(this.flexDiv);\n return super.mount();\n }\n paintValue = 0;\n maxValue = -Infinity;\n maxTimer: number;\n paint = () => {\n const { barwidth, barbgcolor, coldcolor, warmcolor, hotcolor, overloadcolor } = this.state.style;\n const { type, max, min, enums, scale, value } = this.state;\n const ctx = this.ctx;\n const canvas = this.canvas;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = this.canvasDiv.getBoundingClientRect();\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n\n const drawHeight = height * 0.9;\n const drawWidth = barwidth || Math.min(width / 3, drawHeight * 0.05);\n const left = (width - drawWidth) * 0.5;\n const top = height * 0.05;\n this.paintValue = value;\n const paintValue = this.paintValue;\n if (paintValue > this.maxValue) {\n this.maxValue = paintValue;\n if (this.maxTimer) window.clearTimeout(this.maxTimer);\n this.maxTimer = window.setTimeout(() => {\n this.maxValue = this.paintValue;\n this.maxTimer = undefined;\n this.schedule(this.paint);\n }, 1000);\n }\n if (paintValue < this.maxValue && typeof this.maxTimer === \"undefined\") {\n this.maxTimer = window.setTimeout(() => {\n this.maxValue = this.paintValue;\n this.maxTimer = undefined;\n this.schedule(this.paint);\n }, 1000);\n }\n const maxValue = this.maxValue;\n const coldStop = (-18 - min) / (max - min);\n const warmStop = (-6 - min) / (max - min);\n const hotStop = (-3 - min) / (max - min);\n const overloadStop = Math.max(0, -min / (max - min));\n const gradient = ctx.createLinearGradient(0, drawHeight, 0, top);\n if (coldStop <= 1 && coldStop >= 0) gradient.addColorStop(coldStop, coldcolor);\n else if (coldStop > 1) gradient.addColorStop(1, coldcolor);\n if (warmStop <= 1 && warmStop >= 0) gradient.addColorStop(warmStop, warmcolor);\n if (hotStop <= 1 && hotStop >= 0) gradient.addColorStop(hotStop, hotcolor);\n if (overloadStop <= 1 && overloadStop >= 0) gradient.addColorStop(overloadStop, overloadcolor);\n else if (overloadStop < 0) gradient.addColorStop(0, coldcolor);\n\n ctx.fillStyle = barbgcolor;\n if (paintValue < 0) ctx.fillRect(left, top + (1 - overloadStop) * drawHeight, drawWidth, drawHeight * overloadStop);\n if (paintValue < max) ctx.fillRect(left, top, drawWidth, (1 - overloadStop) * drawHeight - 1);\n ctx.fillStyle = gradient;\n if (paintValue > min) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(0, paintValue) }));\n ctx.fillRect(left, top + (1 - distance) * drawHeight, drawWidth, drawHeight * distance);\n }\n if (paintValue > 0) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(max, paintValue) }) - overloadStop);\n ctx.fillRect(left, top + (1 - overloadStop - distance) * drawHeight, drawWidth, drawHeight * distance - 1);\n }\n if (maxValue > paintValue) {\n if (maxValue <= 0) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(0, maxValue) }));\n ctx.fillRect(left, top + (1 - distance) * drawHeight, drawWidth, 1);\n }\n if (maxValue > 0) {\n const distance = Math.max(0, AbstractItem.getDistance({ type, max, min, enums, scale, value: Math.min(max, maxValue) }) - overloadStop);\n ctx.fillRect(left, Math.max(top, top + (1 - overloadStop - distance) * drawHeight - 1), drawWidth, 1);\n }\n }\n };\n}\n","import AbstractItem from \"./AbstractItem\";\nimport { fillRoundedRect, normLog, normExp, denormalize, normalize } from \"./utils\";\nimport type { FaustUIItemProps, PointerDownEvent, PointerDragEvent } from \"./types\";\nimport type { FaustUINentryStyle } from \"./Nentry\";\nimport \"./VSlider.scss\";\n\ninterface FaustUISliderStyle extends FaustUINentryStyle {\n sliderwidth?: number;\n sliderbgcolor?: string;\n sliderbgoncolor?: string;\n slidercolor?: string;\n}\nexport default class VSlider extends AbstractItem {\n static get defaultProps(): FaustUIItemProps {\n const inherited = super.defaultProps;\n return {\n ...inherited,\n style: {\n ...inherited.style,\n fontname: \"Arial\",\n fontsize: undefined,\n fontface: \"regular\",\n bgcolor: \"rgba(18, 18, 18, 0)\",\n bordercolor: \"rgba(80, 80, 80, 0)\",\n labelcolor: \"rgba(226, 222, 255, 0.5)\",\n textcolor: \"rgba(18, 18, 18, 1)\",\n sliderwidth: undefined,\n sliderbgcolor: \"rgba(18, 18, 18, 1)\",\n sliderbgoncolor: \"rgba(255, 165, 0, 1)\",\n slidercolor: \"rgba(200, 200, 200, 0.75)\"\n }\n };\n }\n className = \"vslider\";\n\n canvas: HTMLCanvasElement;\n inputNumber: HTMLInputElement;\n input: HTMLInputElement;\n flexDiv: HTMLDivElement;\n canvasDiv: HTMLDivElement;\n ctx: CanvasRenderingContext2D;\n interactionRect: number[] = [0, 0, 0, 0];\n componentWillMount() {\n super.componentWillMount();\n this.flexDiv = document.createElement(\"div\");\n this.flexDiv.className = `faust-ui-component-${this.className}-flexdiv`;\n this.canvasDiv = document.createElement(\"div\");\n this.canvasDiv.className = `faust-ui-component-${this.className}-canvasdiv`;\n this.canvas = document.createElement(\"canvas\");\n this.canvas.width = 10;\n this.canvas.height = 10;\n this.ctx = this.canvas.getContext(\"2d\");\n this.inputNumber = document.createElement(\"input\");\n this.inputNumber.type = \"number\";\n this.inputNumber.value = (+this.state.value.toFixed(3)).toString();\n this.inputNumber.max = this.state.max.toString();\n this.inputNumber.min = this.state.min.toString();\n this.inputNumber.step = this.state.step.toString();\n this.input = document.createElement(\"input\");\n this.input.value = this.inputNumber.value + (this.state.unit || \"\");\n this.input.spellcheck = false;\n this.setStyle();\n return this;\n }\n handleChange = (e: Event) => {\n const value = parseFloat((e.currentTarget as HTMLInputElement).value);\n if (isFinite(value)) {\n const changed = this.setValue(+value);\n if (changed) return;\n }\n this.input.value = this.inputNumber.value + (this.state.unit || \"\");\n };\n setStyle = () => {\n const { height, width, grid, fontsize, textcolor, bgcolor, bordercolor } = this.state.style;\n const fontSize = Math.min(height * grid * 0.05, width * grid * 0.2);\n this.input.style.fontSize = `${fontsize || fontSize}px`;\n this.input.style.color = textcolor;\n this.container.style.backgroundColor = bgcolor;\n this.container.style.borderColor = bordercolor;\n };\n componentDidMount() {\n super.componentDidMount();\n this.input.addEventListener(\"change\", this.handleChange);\n this.canvas.addEventListener(\"mousedown\", this.handleMouseDown);\n this.canvas.addEventListener(\"touchstart\", this.handleTouchStart, { passive: false });\n this.on(\"style\", () => {\n this.schedule(this.setStyle);\n this.schedule(this.paint);\n });\n this.on(\"label\", () => this.schedule(this.paintLabel));\n const valueChange = () => {\n this.inputNumber.value = (+this.state.value.toFixed(3)).toString();\n this.input.value = this.inputNumber.value + (this.state.unit || \"\");\n };\n this.on(\"value\", () => {\n this.schedule(valueChange);\n this.schedule(this.paint);\n });\n const maxChange = () => this.inputNumber.max = this.state.max.toString();\n this.on(\"max\", () => {\n this.schedule(maxChange);\n this.schedule(this.paint);\n });\n const minChange = () => this.inputNumber.min = this.state.min.toString();\n this.on(\"min\", () => {\n this.schedule(minChange);\n this.schedule(this.paint);\n });\n const stepChange = () => this.inputNumber.step = this.state.step.toString();\n this.on(\"step\", () => {\n this.schedule(stepChange);\n this.schedule(this.paint);\n });\n this.schedule(this.paint);\n return this;\n }\n mount() {\n this.canvasDiv.appendChild(this.canvas);\n this.flexDiv.appendChild(this.canvasDiv);\n this.flexDiv.appendChild(this.input);\n this.container.appendChild(this.label);\n this.container.appendChild(this.flexDiv);\n return super.mount();\n }\n paint = () => {\n const { sliderwidth, sliderbgcolor, sliderbgoncolor, slidercolor } = this.state.style;\n const ctx = this.ctx;\n const canvas = this.canvas;\n const distance = this.distance;\n const ratio = window.devicePixelRatio || 1;\n let { width, height } = this.canvasDiv.getBoundingClientRect();\n width = Math.floor(width);\n height = Math.floor(height);\n const scaledWidth = Math.floor(width * ratio);\n const scaledHeight = Math.floor(height * ratio);\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n // canvas.style.width = width + \"px\";\n // canvas.style.height = height + \"px\";\n ctx.scale(ratio, ratio);\n\n const drawHeight = height * 0.9;\n const drawWidth = sliderwidth || Math.min(width / 3, drawHeight * 0.05);\n const left = (width - drawWidth) * 0.5;\n const top = height * 0.05;\n const borderRadius = drawWidth * 0.25;\n this.interactionRect = [0, top, width, drawHeight];\n const grd = ctx.createLinearGradient(0, top, 0, top + drawHeight);\n grd.addColorStop(Math.max(0, Math.min(1, 1 - distance)), sliderbgcolor);\n grd.addColorStop(Math.max(0, Math.min(1, 1 - distance)), sliderbgoncolor);\n ctx.fillStyle = grd;\n fillRoundedRect(ctx, left, top, drawWidth, drawHeight, borderRadius);\n // draw slider\n ctx.fillStyle = slidercolor;\n fillRoundedRect(ctx, left - drawWidth, top + drawHeight * (1 - distance) - drawWidth, drawWidth * 3, drawWidth * 2, borderRadius);\n };\n get stepsCount() {\n const { type, max, min, step, enums } = this.state;\n const maxSteps = type === \"enum\" ? enums.length : type === \"int\" ? max - min : (max - min) / step;\n if (step) {\n if (type === \"enum\") return enums.length;\n if (type === \"int\") return Math.min(Math.floor((max - min) / (Math.round(step) || 0)), maxSteps);\n return Math.floor((max - min) / step);\n }\n return maxSteps;\n }\n get stepRange() {\n const full = this.interactionRect[this.className === \"vslider\" ? 3 : 2];\n const stepsCount = this.stepsCount;\n return full / stepsCount;\n }\n getValueFromPos(e: { x: number; y: number }) {\n const { type, min, max, scale } = this.state;\n const step = type === \"enum\" ? 1 : (this.state.step || 1);\n const stepRange = this.stepRange;\n const stepsCount = this.stepsCount;\n const distance = (this.className === \"vslider\" ? this.interactionRect[3] - (e.y - this.interactionRect[1]) : e.x - this.interactionRect[0]);\n const range = this.className === \"vslider\" ? this.interactionRect[3] : this.interactionRect[2];\n const denormalized = denormalize(distance / range, min, max);\n const v = scale === \"exp\" ? normExp(denormalized, min, max) : scale === \"log\" ? normLog(denormalized, min, max) : denormalized;\n let steps = Math.round(normalize(v, min, max) * range / stepRange);\n steps = Math.min(stepsCount, Math.max(0, steps));\n if (type === \"enum\") return steps;\n if (type === \"int\") return Math.round(steps * step + min);\n return steps * step + min;\n }\n handlePointerDown = (e: PointerDownEvent) => {\n const { value } = this.state;\n if (\n e.x < this.interactionRect[0]\n || e.x > this.interactionRect[0] + this.interactionRect[2]\n || e.y < this.interactionRect[1]\n || e.y > this.interactionRect[1] + this.interactionRect[3]\n ) return;\n const newValue = this.getValueFromPos(e);\n if (newValue !== value) this.setValue(this.getValueFromPos(e));\n };\n handlePointerDrag = (e: PointerDragEvent) => {\n const newValue = this.getValueFromPos(e);\n if (newValue !== this.state.value) this.setValue(newValue);\n };\n}\n","export const toMIDI = (f: number) => [\"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\", \"A\", \"A#\", \"B\"][(f % 12 + 12) % 12] + Math.round(f / 12 - 2);\nexport const toRad = (degrees: number) => degrees * Math.PI / 180;\nexport const atodb = (a: number) => 20 * Math.log10(a);\nexport const dbtoa = (db: number) => 10 ** (db / 20);\nexport const denormalize = (x: number, min: number, max: number) => min + (max - min) * x;\nexport const normalize = (x: number, min: number, max: number) => (x - min) / (max - min) || 0;\nexport const normLog = (x: number, min: number, max: number) => {\n const normalized = normalize(x, min, max);\n const logMin = Math.log(Math.max(Number.EPSILON, min));\n const logMax = Math.log(Math.max(Number.EPSILON, max));\n const vLog = denormalize(normalized, logMin, logMax);\n const v = Math.exp(vLog);\n return Math.max(min, Math.min(max, v));\n};\nexport const iNormLog = (vIn: number, min: number, max: number) => {\n const v = Math.max(min, Math.min(max, vIn));\n const vLog = Math.log(Math.max(Number.EPSILON, v));\n const logMin = Math.log(Math.max(Number.EPSILON, min));\n const logMax = Math.log(Math.max(Number.EPSILON, max));\n const normalized = normalize(vLog, logMin, logMax);\n return denormalize(normalized, min, max);\n};\nexport const normExp = iNormLog;\nexport const iNormExp = normLog;\nexport const roundedRect = (ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number | number[]) => {\n const radii = [0, 0, 0, 0];\n if (typeof radius === \"number\") radii.fill(radius);\n else radius.forEach((v, i) => radii[i] = v);\n ctx.beginPath();\n ctx.moveTo(x + radii[0], y);\n ctx.lineTo(x + width - radii[1], y);\n ctx.quadraticCurveTo(x + width, y, x + width, y + radii[1]);\n ctx.lineTo(x + width, y + height - radii[2]);\n ctx.quadraticCurveTo(x + width, y + height, x + width - radii[2], y + height);\n ctx.lineTo(x + radii[3], y + height);\n ctx.quadraticCurveTo(x, y + height, x, y + height - radii[3]);\n ctx.lineTo(x, y + radii[0]);\n ctx.quadraticCurveTo(x, y, x + radii[0], y);\n ctx.closePath();\n ctx.stroke();\n};\nexport const fillRoundedRect = (ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number | number[]) => {\n const radii = [0, 0, 0, 0];\n if (typeof radius === \"number\") radii.fill(radius);\n else radius.forEach((v, i) => radii[i] = v);\n ctx.beginPath();\n ctx.moveTo(x + radii[0], y);\n ctx.lineTo(x + width - radii[1], y);\n ctx.quadraticCurveTo(x + width, y, x + width, y + radii[1]);\n ctx.lineTo(x + width, y + height - radii[2]);\n ctx.quadraticCurveTo(x + width, y + height, x + width - radii[2], y + height);\n ctx.lineTo(x + radii[3], y + height);\n ctx.quadraticCurveTo(x, y + height, x, y + height - radii[3]);\n ctx.lineTo(x, y + radii[0]);\n ctx.quadraticCurveTo(x, y, x + radii[0], y);\n ctx.closePath();\n ctx.fill();\n};\n","import FaustUI from \"./FaustUI\";\n\nconst instantiate = () => {\n const faustUI = new FaustUI({\n root: document.getElementById(\"root\") as HTMLDivElement,\n listenWindowResize: true,\n listenWindowMessage: true\n });\n let host: Window;\n window.addEventListener(\"message\", (e) => {\n const { source } = e;\n host = source as Window;\n });\n\n window.addEventListener(\"keydown\", (e) => {\n if (host) host.postMessage({ type: \"keydown\", key: e.key }, \"*\");\n });\n window.addEventListener(\"keyup\", (e) => {\n if (host) host.postMessage({ type: \"keyup\", key: e.key }, \"*\");\n });\n (window as any).faustUI = faustUI;\n};\n\nexport default instantiate;\n","import type { FaustUIGroupType } from \"@grame/faustwasm\";\nimport IItem from \"./IItem\";\nimport AbstractItem from \"./AbstractItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default abstract class AbstractGroup implements IItem {\n static padding = 0.2;\n static labelHeight = 0.25;\n static spaceBetween = 0.1;\n isRoot: boolean;\n type: FaustUIGroupType;\n label: string;\n items: (AbstractGroup | AbstractItem)[];\n layout: LayoutProps;\n\n constructor(group: { type: FaustUIGroupType; label: string; items: (AbstractGroup | AbstractItem)[] }, isRoot?: boolean) {\n this.isRoot = !!isRoot;\n Object.assign(this, group);\n const { hasHSizingDesc, hasVSizingDesc } = this;\n const sizing = hasHSizingDesc && hasVSizingDesc ? \"both\" : hasHSizingDesc ? \"horizontal\" : hasVSizingDesc ? \"vertical\" : \"none\";\n this.layout = {\n type: group.type,\n width: AbstractGroup.padding * 2,\n height: AbstractGroup.padding * 2 + (this.isRoot ? 0 : AbstractGroup.labelHeight),\n sizing\n };\n }\n\n /**\n * find recursively if the group has horizontal-sizable item\n */\n get hasHSizingDesc(): boolean {\n return !!this.items.find((item) => {\n if (item instanceof AbstractGroup) return item.hasHSizingDesc;\n return item.layout.sizing === \"horizontal\" || item.layout.sizing === \"both\";\n });\n }\n /**\n * find recursively if the group has vertical-sizable item\n */\n get hasVSizingDesc(): boolean {\n return !!this.items.find((item) => {\n if (item instanceof AbstractGroup) return item.hasVSizingDesc;\n return item.layout.sizing === \"vertical\" || item.layout.sizing === \"both\";\n });\n }\n adjust() {\n return this;\n }\n expand(dX: number, dY: number) {\n return this;\n }\n offset() {\n return this;\n }\n}\n","import type { FaustUIInputItem } from \"@grame/faustwasm\";\nimport AbstractItem from \"./AbstractItem\";\n\nexport default abstract class AbstractInputItem extends AbstractItem {\n init: number;\n step: number;\n constructor(item: FaustUIInputItem) {\n super(item);\n this.init = +item.init || 0;\n this.step = +item.step || 1;\n }\n}\n","import type { FaustUIInputType, FaustUIItem, FaustUIMeta, FaustUIOutputType } from \"@grame/faustwasm\";\nimport type { LayoutProps } from \"../types\";\nimport type IItem from \"./IItem\";\n\nexport default abstract class AbstractItem implements IItem {\n type: FaustUIInputType | FaustUIOutputType;\n label: string;\n address: string;\n url: string;\n index: number;\n init: number;\n min: number;\n max: number;\n meta?: FaustUIMeta[];\n layout: LayoutProps;\n constructor(item: FaustUIItem) {\n Object.assign(this, item);\n this.min = isFinite(+this.min) ? +this.min : 0;\n this.max = isFinite(+this.max) ? +this.max : 1;\n }\n\n adjust(): this {\n return this;\n }\n expand(dX: number, dY: number): this {\n return this;\n }\n offset(): this {\n return this;\n }\n}\n","import AbstractItem from \"./AbstractItem\";\n\nexport default abstract class AbstractOutputItem extends AbstractItem {\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport { LayoutProps } from \"../types\";\n\nexport default class Button extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"button\",\n width: 2,\n height: 1,\n sizing: \"horizontal\"\n };\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport { LayoutProps } from \"../types\";\n\nexport default class Checkbox extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"checkbox\",\n width: 2,\n height: 1,\n sizing: \"horizontal\"\n };\n}\n","import AbstractOutputItem from \"./AbstractOutputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class HBargraph extends AbstractOutputItem {\n layout: LayoutProps = {\n type: \"hbargraph\",\n width: 5,\n height: 1,\n sizing: \"horizontal\"\n };\n}\n","import AbstractGroup from \"./AbstractGroup\";\n\nexport default class HGroup extends AbstractGroup {\n adjust() {\n this.items.forEach((item) => {\n item.adjust();\n this.layout.width += item.layout.width;\n this.layout.height = Math.max(this.layout.height, item.layout.height + 2 * AbstractGroup.padding + (this.isRoot ? 0 : AbstractGroup.labelHeight));\n });\n this.layout.width += AbstractGroup.spaceBetween * (this.items.length - 1);\n if (this.layout.width < 1) this.layout.width += 1;\n return this;\n }\n expand(dX: number) {\n let hExpandItems = 0;\n this.items.forEach((item) => { // Count items that need to expand horizontally\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"horizontal\") hExpandItems++;\n });\n this.items.forEach((item) => {\n let dX$ = 0;\n let dY$ = 0; // Space available to expand for current item\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"horizontal\") {\n dX$ = hExpandItems ? dX / hExpandItems : 0;\n item.layout.width += dX$;\n }\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"vertical\") {\n dY$ = this.layout.height - 2 * AbstractGroup.padding - (this.isRoot ? 0 : AbstractGroup.labelHeight) - item.layout.height;\n item.layout.height += dY$;\n }\n item.expand(dX$, dY$);\n });\n // this.layout.width += dX;\n return this;\n }\n offset() {\n const { labelHeight, padding, spaceBetween } = AbstractGroup;\n let $left = padding;\n const $top = padding + (this.isRoot ? 0 : labelHeight);\n const { height } = this.layout;\n this.items.forEach((item) => {\n item.layout.offsetLeft = $left;\n item.layout.offsetTop = $top;\n // center the item\n item.layout.offsetTop += (height - (this.isRoot ? 0 : labelHeight) - item.layout.height) / 2 - padding;\n item.layout.left = (this.layout.left || 0) + item.layout.offsetLeft;\n item.layout.top = (this.layout.top || 0) + item.layout.offsetTop;\n item.offset();\n $left += item.layout.width + spaceBetween;\n });\n return this;\n }\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class HSlider extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"hslider\",\n width: 5,\n height: 1,\n sizing: \"horizontal\"\n };\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class Knob extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"knob\",\n width: 1,\n height: 1.75,\n sizing: \"none\"\n };\n}\n","import type { FaustUIItem } from \"@grame/faustwasm\";\nimport HSlider from \"./HSlider\";\nimport VSlider from \"./VSlider\";\nimport Nentry from \"./Nentry\";\nimport Soundfile from \"./Soundfile\";\nimport Button from \"./Button\";\nimport Checkbox from \"./Checkbox\";\nimport Knob from \"./Knob\";\nimport Menu from \"./Menu\";\nimport Radio from \"./Radio\";\nimport Led from \"./Led\";\nimport Numerical from \"./Numerical\";\nimport HBargraph from \"./HBargraph\";\nimport VBargraph from \"./VBargraph\";\nimport HGroup from \"./HGroup\";\nimport VGroup from \"./VGroup\";\nimport TGroup from \"./TGroup\";\nimport type AbstractItem from \"./AbstractItem\";\nimport type AbstractGroup from \"./AbstractGroup\";\nimport type { TLayoutType } from \"../types\";\n\nexport default class Layout {\n /**\n * Get the rendering type of an item by parsing its metadata\n */\n static predictType(item: FaustUIItem): TLayoutType {\n if (item.type === \"vgroup\"\n || item.type === \"hgroup\"\n || item.type === \"tgroup\"\n || item.type === \"button\"\n || item.type === \"checkbox\"\n || item.type === \"soundfile\"\n ) return item.type;\n if (item.type === \"hbargraph\" || item.type === \"vbargraph\") {\n if (item.meta && item.meta.find(meta => meta.style && meta.style.startsWith(\"led\"))) return \"led\";\n if (item.meta && item.meta.find(meta => meta.style && meta.style.startsWith(\"numerical\"))) return \"numerical\";\n return item.type;\n }\n if (item.type === \"hslider\" || item.type === \"nentry\" || item.type === \"vslider\") {\n if (item.meta && item.meta.find(meta => meta.style && meta.style.startsWith(\"knob\"))) return \"knob\";\n if (item.meta && item.meta.find(meta => meta.style && meta.style.startsWith(\"menu\"))) return \"menu\";\n if (item.meta && item.meta.find(meta => meta.style && meta.style.startsWith(\"radio\"))) return \"radio\";\n }\n return item.type;\n }\n /**\n * Get the Layout class constructor of an item\n */\n static getItem(item: FaustUIItem): AbstractItem | AbstractGroup {\n const Ctor = {\n hslider: HSlider,\n vslider: VSlider,\n nentry: Nentry,\n soundfile: Soundfile,\n button: Button,\n checkbox: Checkbox,\n knob: Knob,\n menu: Menu,\n radio: Radio,\n led: Led,\n numerical: Numerical,\n hbargraph: HBargraph,\n vbargraph: VBargraph,\n hgroup: HGroup,\n vgroup: VGroup,\n tgroup: TGroup\n };\n const layoutType = this.predictType(item);\n return new Ctor[layoutType](item as any);\n }\n static getItems(items: FaustUIItem[]) {\n return items.map((item) => {\n if (\"items\" in item) item.items = this.getItems(item.items);\n return this.getItem(item);\n });\n }\n static calc(ui: FaustUIItem[]) {\n const rootGroup = new VGroup({ items: this.getItems(ui), type: \"vgroup\", label: \"\" }, true);\n rootGroup.adjust();\n rootGroup.expand(0, 0);\n rootGroup.offset();\n return rootGroup;\n }\n}\n","import AbstractOutputItem from \"./AbstractOutputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class Led extends AbstractOutputItem {\n layout: LayoutProps = {\n type: \"led\",\n width: 1,\n height: 1,\n sizing: \"none\"\n };\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class Menu extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"menu\",\n width: 2,\n height: 1,\n sizing: \"horizontal\"\n };\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class Nentry extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"nentry\",\n width: 1,\n height: 1,\n sizing: \"none\"\n };\n}\n","import AbstractOutputItem from \"./AbstractOutputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class Numerical extends AbstractOutputItem {\n layout: LayoutProps = {\n type: \"numerical\",\n width: 1,\n height: 1,\n sizing: \"none\"\n };\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class Radio extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"radio\",\n width: 2,\n height: 2, // TODO: vradio and hradio\n sizing: \"both\"\n };\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport { LayoutProps } from \"../types\";\n\nexport default class Soundfile extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"soundfile\",\n width: 2,\n height: 1,\n sizing: \"horizontal\"\n };\n}\n","import AbstractGroup from \"./AbstractGroup\";\n\nexport default class TGroup extends AbstractGroup {\n static tabLayout = {\n width: 2,\n height: 1\n };\n adjust() {\n this.items.forEach((item) => {\n item.adjust();\n this.layout.width = Math.max(this.layout.width, item.layout.width + 2 * AbstractGroup.padding);\n this.layout.height = Math.max(this.layout.height, item.layout.height + 2 * AbstractGroup.padding + TGroup.labelHeight);\n });\n const tabsCount = this.items.length;\n this.layout.width = Math.max(this.layout.width, tabsCount * TGroup.tabLayout.width);\n this.layout.height += TGroup.tabLayout.height;\n if (this.layout.width < 1) this.layout.width += 1;\n return this;\n }\n expand() {\n const tabsCount = this.items.length;\n this.items.forEach((item) => {\n let dY$ = 0; // Space available to expand for current item\n let dX$ = 0;\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"horizontal\") dX$ = this.layout.width - 2 * AbstractGroup.padding - item.layout.width;\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"vertical\") dY$ = this.layout.height - 2 * AbstractGroup.padding - (this.isRoot ? 0 : AbstractGroup.labelHeight) - (tabsCount ? TGroup.tabLayout.height : 0) - item.layout.height;\n item.expand(dX$, dY$);\n });\n return this;\n }\n offset() {\n const { labelHeight, padding } = AbstractGroup;\n const $left = padding;\n const $top = padding + (this.isRoot ? 0 : labelHeight) + TGroup.tabLayout.height;\n this.items.forEach((item) => {\n item.layout.offsetLeft = $left;\n item.layout.offsetTop = $top;\n item.layout.left = (this.layout.left || 0) + item.layout.offsetLeft;\n item.layout.top = (this.layout.top || 0) + item.layout.offsetTop;\n item.offset();\n });\n return this;\n }\n}\n","import AbstractOutputItem from \"./AbstractOutputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class VBargraph extends AbstractOutputItem {\n layout: LayoutProps = {\n type: \"vbargraph\",\n width: 1,\n height: 5,\n sizing: \"vertical\"\n };\n}\n","import AbstractGroup from \"./AbstractGroup\";\n\nexport default class VGroup extends AbstractGroup {\n adjust() {\n this.items.forEach((item) => {\n item.adjust();\n this.layout.width = Math.max(this.layout.width, item.layout.width + 2 * AbstractGroup.padding);\n this.layout.height += item.layout.height;\n });\n this.layout.height += AbstractGroup.spaceBetween * (this.items.length - 1);\n if (this.layout.width < 1) this.layout.width += 1;\n return this;\n }\n expand(dX: number, dY: number) {\n let vExpandItems = 0;\n this.items.forEach((item) => {\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"vertical\") vExpandItems++;\n });\n this.items.forEach((item) => {\n let dX$ = 0;\n let dY$ = 0; // Space available to expand for current item\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"horizontal\") {\n dX$ = this.layout.width - 2 * AbstractGroup.padding - item.layout.width;\n item.layout.width += dX$;\n }\n if (item.layout.sizing === \"both\" || item.layout.sizing === \"vertical\") {\n dY$ = vExpandItems ? dY / vExpandItems : 0;\n item.layout.height += dY$;\n }\n item.expand(dX$, dY$);\n });\n // this.layout.height += dY;\n return this;\n }\n offset() {\n const { labelHeight, padding, spaceBetween } = AbstractGroup;\n const $left = padding;\n let $top = padding + (this.isRoot ? 0 : labelHeight);\n const { width } = this.layout;\n this.items.forEach((item) => {\n item.layout.offsetLeft = $left;\n item.layout.offsetTop = $top;\n // center the item\n item.layout.offsetLeft += (width - item.layout.width) / 2 - padding;\n item.layout.left = (this.layout.left || 0) + item.layout.offsetLeft;\n item.layout.top = (this.layout.top || 0) + item.layout.offsetTop;\n item.offset();\n $top += item.layout.height + spaceBetween;\n });\n return this;\n }\n}\n","import AbstractInputItem from \"./AbstractInputItem\";\nimport type { LayoutProps } from \"../types\";\n\nexport default class VSlider extends AbstractInputItem {\n layout: LayoutProps = {\n type: \"vslider\",\n width: 1,\n height: 5,\n sizing: \"vertical\"\n };\n}\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Base.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Base.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Button.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Button.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Checkbox.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Checkbox.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Group.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Group.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./HBargraph.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./HBargraph.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./HSlider.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./HSlider.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Knob.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Knob.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Led.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Led.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Menu.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Menu.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Nentry.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Nentry.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Numerical.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Numerical.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Radio.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Radio.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Soundfile.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./Soundfile.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./VBargraph.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./VBargraph.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./VSlider.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./VSlider.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\n import API from \"!../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n import domAPI from \"!../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n import insertFn from \"!../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n import setAttributes from \"!../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n import insertStyleElement from \"!../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n import styleTagTransformFn from \"!../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n import content, * as namedExport from \"!!../node_modules/css-loader/dist/cjs.js!../node_modules/sass-loader/dist/cjs.js!./index.scss\";\n \n \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n options.insert = insertFn.bind(null, \"head\");\n \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../node_modules/css-loader/dist/cjs.js!../node_modules/sass-loader/dist/cjs.js!./index.scss\";\n export default content && content.locals ? content.locals : undefined;\n","\"use strict\";\n\nvar stylesInDOM = [];\nfunction getIndexByIdentifier(identifier) {\n var result = -1;\n for (var i = 0; i < stylesInDOM.length; i++) {\n if (stylesInDOM[i].identifier === identifier) {\n result = i;\n break;\n }\n }\n return result;\n}\nfunction modulesToDom(list, options) {\n var idCountMap = {};\n var identifiers = [];\n for (var i = 0; i < list.length; i++) {\n var item = list[i];\n var id = options.base ? item[0] + options.base : item[0];\n var count = idCountMap[id] || 0;\n var identifier = \"\".concat(id, \" \").concat(count);\n idCountMap[id] = count + 1;\n var indexByIdentifier = getIndexByIdentifier(identifier);\n var obj = {\n css: item[1],\n media: item[2],\n sourceMap: item[3],\n supports: item[4],\n layer: item[5]\n };\n if (indexByIdentifier !== -1) {\n stylesInDOM[indexByIdentifier].references++;\n stylesInDOM[indexByIdentifier].updater(obj);\n } else {\n var updater = addElementStyle(obj, options);\n options.byIndex = i;\n stylesInDOM.splice(i, 0, {\n identifier: identifier,\n updater: updater,\n references: 1\n });\n }\n identifiers.push(identifier);\n }\n return identifiers;\n}\nfunction addElementStyle(obj, options) {\n var api = options.domAPI(options);\n api.update(obj);\n var updater = function updater(newObj) {\n if (newObj) {\n if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n return;\n }\n api.update(obj = newObj);\n } else {\n api.remove();\n }\n };\n return updater;\n}\nmodule.exports = function (list, options) {\n options = options || {};\n list = list || [];\n var lastIdentifiers = modulesToDom(list, options);\n return function update(newList) {\n newList = newList || [];\n for (var i = 0; i < lastIdentifiers.length; i++) {\n var identifier = lastIdentifiers[i];\n var index = getIndexByIdentifier(identifier);\n stylesInDOM[index].references--;\n }\n var newLastIdentifiers = modulesToDom(newList, options);\n for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n var _identifier = lastIdentifiers[_i];\n var _index = getIndexByIdentifier(_identifier);\n if (stylesInDOM[_index].references === 0) {\n stylesInDOM[_index].updater();\n stylesInDOM.splice(_index, 1);\n }\n }\n lastIdentifiers = newLastIdentifiers;\n };\n};","\"use strict\";\n\nvar memo = {};\n\n/* istanbul ignore next */\nfunction getTarget(target) {\n if (typeof memo[target] === \"undefined\") {\n var styleTarget = document.querySelector(target);\n\n // Special case to return head of iframe instead of iframe itself\n if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n try {\n // This will throw an exception if access to iframe is blocked\n // due to cross-origin restrictions\n styleTarget = styleTarget.contentDocument.head;\n } catch (e) {\n // istanbul ignore next\n styleTarget = null;\n }\n }\n memo[target] = styleTarget;\n }\n return memo[target];\n}\n\n/* istanbul ignore next */\nfunction insertBySelector(insert, style) {\n var target = getTarget(insert);\n if (!target) {\n throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n }\n target.appendChild(style);\n}\nmodule.exports = insertBySelector;","\"use strict\";\n\n/* istanbul ignore next */\nfunction insertStyleElement(options) {\n var element = document.createElement(\"style\");\n options.setAttributes(element, options.attributes);\n options.insert(element, options.options);\n return element;\n}\nmodule.exports = insertStyleElement;","\"use strict\";\n\n/* istanbul ignore next */\nfunction setAttributesWithoutAttributes(styleElement) {\n var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n if (nonce) {\n styleElement.setAttribute(\"nonce\", nonce);\n }\n}\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\n/* istanbul ignore next */\nfunction apply(styleElement, options, obj) {\n var css = \"\";\n if (obj.supports) {\n css += \"@supports (\".concat(obj.supports, \") {\");\n }\n if (obj.media) {\n css += \"@media \".concat(obj.media, \" {\");\n }\n var needLayer = typeof obj.layer !== \"undefined\";\n if (needLayer) {\n css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n }\n css += obj.css;\n if (needLayer) {\n css += \"}\";\n }\n if (obj.media) {\n css += \"}\";\n }\n if (obj.supports) {\n css += \"}\";\n }\n var sourceMap = obj.sourceMap;\n if (sourceMap && typeof btoa !== \"undefined\") {\n css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n }\n\n // For old IE\n /* istanbul ignore if */\n options.styleTagTransform(css, styleElement, options.options);\n}\nfunction removeStyleElement(styleElement) {\n // istanbul ignore if\n if (styleElement.parentNode === null) {\n return false;\n }\n styleElement.parentNode.removeChild(styleElement);\n}\n\n/* istanbul ignore next */\nfunction domAPI(options) {\n if (typeof document === \"undefined\") {\n return {\n update: function update() {},\n remove: function remove() {}\n };\n }\n var styleElement = options.insertStyleElement(options);\n return {\n update: function update(obj) {\n apply(styleElement, options, obj);\n },\n remove: function remove() {\n removeStyleElement(styleElement);\n }\n };\n}\nmodule.exports = domAPI;","\"use strict\";\n\n/* istanbul ignore next */\nfunction styleTagTransform(css, styleElement) {\n if (styleElement.styleSheet) {\n styleElement.styleSheet.cssText = css;\n } else {\n while (styleElement.firstChild) {\n styleElement.removeChild(styleElement.firstChild);\n }\n styleElement.appendChild(document.createTextNode(css));\n }\n}\nmodule.exports = styleTagTransform;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nc = undefined;","export { default as FaustUI } from \"./FaustUI\";\nexport { default as instantiate } from \"./instantiate\";\n"],"names":["e","label","type","layout","props","key"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/faustwasm/libfaust-wasm.d.cts b/dist/faustwasm/libfaust-wasm.d.cts new file mode 100644 index 00000000..6dcb9603 --- /dev/null +++ b/dist/faustwasm/libfaust-wasm.d.cts @@ -0,0 +1,3 @@ +import { FaustModuleFactory } from "../src/types"; +declare const faustModuleFactory: FaustModuleFactory; +export default faustModuleFactory; diff --git a/dist/faustwasm/libfaust-wasm.d.ts b/dist/faustwasm/libfaust-wasm.d.ts new file mode 100644 index 00000000..6dcb9603 --- /dev/null +++ b/dist/faustwasm/libfaust-wasm.d.ts @@ -0,0 +1,3 @@ +import { FaustModuleFactory } from "../src/types"; +declare const faustModuleFactory: FaustModuleFactory; +export default faustModuleFactory; diff --git a/dist/faustwasm/libfaust-wasm.data b/dist/faustwasm/libfaust-wasm.data new file mode 100644 index 00000000..ff845a5e Binary files /dev/null and b/dist/faustwasm/libfaust-wasm.data differ diff --git a/dist/faustwasm/libfaust-wasm.data.d.ts b/dist/faustwasm/libfaust-wasm.data.d.ts new file mode 100644 index 00000000..11303181 --- /dev/null +++ b/dist/faustwasm/libfaust-wasm.data.d.ts @@ -0,0 +1,2 @@ +declare const data: Uint8Array; +export default data; \ No newline at end of file diff --git a/dist/faustwasm/libfaust-wasm.js b/dist/faustwasm/libfaust-wasm.js new file mode 100644 index 00000000..1e2e69b4 --- /dev/null +++ b/dist/faustwasm/libfaust-wasm.js @@ -0,0 +1,20 @@ + +var FaustModule = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( +function(FaustModule = {}) { + +var Module=typeof FaustModule!="undefined"?FaustModule:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise(function(resolve,reject){readyPromiseResolve=resolve;readyPromiseReject=reject});["_main","___getTypeName","__embind_initialize_bindings","_fflush","onRuntimeInitialized"].forEach(prop=>{if(!Object.getOwnPropertyDescriptor(Module["ready"],prop)){Object.defineProperty(Module["ready"],prop,{get:()=>abort("You are getting "+prop+" on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"),set:()=>abort("You are setting "+prop+" on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js")})}});if(!Module.expectedDataFileDownloads){Module.expectedDataFileDownloads=0}Module.expectedDataFileDownloads++;(function(){if(Module["ENVIRONMENT_IS_PTHREAD"])return;var loadPackage=function(metadata){var PACKAGE_PATH="";if(typeof window==="object"){PACKAGE_PATH=window["encodeURIComponent"](window.location.pathname.toString().substring(0,window.location.pathname.toString().lastIndexOf("/"))+"/")}else if(typeof process==="undefined"&&typeof location!=="undefined"){PACKAGE_PATH=encodeURIComponent(location.pathname.toString().substring(0,location.pathname.toString().lastIndexOf("/"))+"/")}var PACKAGE_NAME="libfaust-wasm.data";var REMOTE_PACKAGE_BASE="libfaust-wasm.data";if(typeof Module["locateFilePackage"]==="function"&&!Module["locateFile"]){Module["locateFile"]=Module["locateFilePackage"];err("warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)")}var REMOTE_PACKAGE_NAME=Module["locateFile"]?Module["locateFile"](REMOTE_PACKAGE_BASE,""):REMOTE_PACKAGE_BASE;var REMOTE_PACKAGE_SIZE=metadata["remote_package_size"];function fetchRemotePackage(packageName,packageSize,callback,errback){if(typeof process==="object"&&typeof process.versions==="object"&&typeof process.versions.node==="string"){require("fs").readFile(packageName,function(err,contents){if(err){errback(err)}else{callback(contents.buffer)}});return}var xhr=new XMLHttpRequest;xhr.open("GET",packageName,true);xhr.responseType="arraybuffer";xhr.onprogress=function(event){var url=packageName;var size=packageSize;if(event.total)size=event.total;if(event.loaded){if(!xhr.addedTotal){xhr.addedTotal=true;if(!Module.dataFileDownloads)Module.dataFileDownloads={};Module.dataFileDownloads[url]={loaded:event.loaded,total:size}}else{Module.dataFileDownloads[url].loaded=event.loaded}var total=0;var loaded=0;var num=0;for(var download in Module.dataFileDownloads){var data=Module.dataFileDownloads[download];total+=data.total;loaded+=data.loaded;num++}total=Math.ceil(total*Module.expectedDataFileDownloads/num);if(Module["setStatus"])Module["setStatus"]("Downloading data... ("+loaded+"/"+total+")")}else if(!Module.dataFileDownloads){if(Module["setStatus"])Module["setStatus"]("Downloading data...")}};xhr.onerror=function(event){throw new Error("NetworkError for: "+packageName)};xhr.onload=function(event){if(xhr.status==200||xhr.status==304||xhr.status==206||xhr.status==0&&xhr.response){var packageData=xhr.response;callback(packageData)}else{throw new Error(xhr.statusText+" : "+xhr.responseURL)}};xhr.send(null)}function handleError(error){console.error("package error:",error)}var fetchedCallback=null;var fetched=Module["getPreloadedPackage"]?Module["getPreloadedPackage"](REMOTE_PACKAGE_NAME,REMOTE_PACKAGE_SIZE):null;if(!fetched)fetchRemotePackage(REMOTE_PACKAGE_NAME,REMOTE_PACKAGE_SIZE,function(data){if(fetchedCallback){fetchedCallback(data);fetchedCallback=null}else{fetched=data}},handleError);function runWithFS(){function assert(check,msg){if(!check)throw msg+(new Error).stack}Module["FS_createPath"]("/","usr",true,true);Module["FS_createPath"]("/usr","rsrc",true,true);Module["FS_createPath"]("/usr","share",true,true);Module["FS_createPath"]("/usr/share","faust",true,true);function DataRequest(start,end,audio){this.start=start;this.end=end;this.audio=audio}DataRequest.prototype={requests:{},open:function(mode,name){this.name=name;this.requests[name]=this;Module["addRunDependency"]("fp "+this.name)},send:function(){},onload:function(){var byteArray=this.byteArray.subarray(this.start,this.end);this.finish(byteArray)},finish:function(byteArray){var that=this;Module["FS_createDataFile"](this.name,null,byteArray,true,true,true);Module["removeRunDependency"]("fp "+that.name);this.requests[this.name]=null}};var files=metadata["files"];for(var i=0;i{throw toThrow};var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;if(Module["ENVIRONMENT"]){throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)")}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary,setWindowTitle;function logExceptionOnExit(e){if(e instanceof ExitStatus)return;let toLog=e;if(e&&typeof e=="object"&&e.stack){toLog=[e,e.stack]}err("exiting due to exception: "+toLog)}if(ENVIRONMENT_IS_NODE){if(typeof process=="undefined"||!process.release||process.release.name!=="node")throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");var fs=require("fs");var nodePath=require("path");if(ENVIRONMENT_IS_WORKER){scriptDirectory=nodePath.dirname(scriptDirectory)+"/"}else{scriptDirectory=__dirname+"/"}read_=(filename,binary)=>{filename=isFileURI(filename)?new URL(filename):nodePath.normalize(filename);return fs.readFileSync(filename,binary?undefined:"utf8")};readBinary=filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}assert(ret.buffer);return ret};readAsync=(filename,onload,onerror)=>{filename=isFileURI(filename)?new URL(filename):nodePath.normalize(filename);fs.readFile(filename,function(err,data){if(err)onerror(err);else onload(data.buffer)})};if(process["argv"].length>1){thisProgram=process["argv"][1].replace(/\\/g,"/")}arguments_=process["argv"].slice(2);process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});var nodeMajor=process.version.match(/^v(\d+)\./)[1];if(nodeMajor<15){process["on"]("unhandledRejection",function(reason){throw reason})}quit_=(status,toThrow)=>{if(keepRuntimeAlive()){process["exitCode"]=status;throw toThrow}logExceptionOnExit(toThrow);process["exit"](status)};Module["inspect"]=function(){return"[Emscripten Module object]"}}else if(ENVIRONMENT_IS_SHELL){if(typeof process=="object"&&typeof require==="function"||typeof window=="object"||typeof importScripts=="function")throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");if(typeof read!="undefined"){read_=function shell_read(f){return read(f)}}readBinary=function readBinary(f){let data;if(typeof readbuffer=="function"){return new Uint8Array(readbuffer(f))}data=read(f,"binary");assert(typeof data=="object");return data};readAsync=function readAsync(f,onload,onerror){setTimeout(()=>onload(readBinary(f)),0)};if(typeof clearTimeout=="undefined"){globalThis.clearTimeout=id=>{}}if(typeof scriptArgs!="undefined"){arguments_=scriptArgs}else if(typeof arguments!="undefined"){arguments_=arguments}if(typeof quit=="function"){quit_=(status,toThrow)=>{logExceptionOnExit(toThrow);quit(status)}}if(typeof print!="undefined"){if(typeof console=="undefined")console={};console.log=print;console.warn=console.error=typeof printErr!="undefined"?printErr:print}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptDir){scriptDirectory=_scriptDir}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}else{scriptDirectory=""}if(!(typeof window=="object"||typeof importScripts=="function"))throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");{read_=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}setWindowTitle=title=>document.title=title}else{throw new Error("environment detection error")}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;checkIncomingModuleAPI();if(Module["arguments"])arguments_=Module["arguments"];legacyModuleProp("arguments","arguments_");if(Module["thisProgram"])thisProgram=Module["thisProgram"];legacyModuleProp("thisProgram","thisProgram");if(Module["quit"])quit_=Module["quit"];legacyModuleProp("quit","quit_");assert(typeof Module["memoryInitializerPrefixURL"]=="undefined","Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["pthreadMainPrefixURL"]=="undefined","Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["cdInitializerPrefixURL"]=="undefined","Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["filePackagePrefixURL"]=="undefined","Module.filePackagePrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["read"]=="undefined","Module.read option was removed (modify read_ in JS)");assert(typeof Module["readAsync"]=="undefined","Module.readAsync option was removed (modify readAsync in JS)");assert(typeof Module["readBinary"]=="undefined","Module.readBinary option was removed (modify readBinary in JS)");assert(typeof Module["setWindowTitle"]=="undefined","Module.setWindowTitle option was removed (modify setWindowTitle in JS)");assert(typeof Module["TOTAL_MEMORY"]=="undefined","Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");legacyModuleProp("read","read_");legacyModuleProp("readAsync","readAsync");legacyModuleProp("readBinary","readBinary");legacyModuleProp("setWindowTitle","setWindowTitle");assert(!ENVIRONMENT_IS_SHELL,"shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable.");var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];legacyModuleProp("wasmBinary","wasmBinary");var noExitRuntime=Module["noExitRuntime"]||true;legacyModuleProp("noExitRuntime","noExitRuntime");if(typeof WebAssembly!="object"){abort("no native wasm support detected")}var wasmMemory;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort("Assertion failed"+(text?": "+text:""))}}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(heapOrArray,idx,maxBytesToRead){var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;if(u>1114111)warnOnce("Invalid Unicode code point "+ptrToString(u)+" encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx}function stringToUTF8(str,outPtr,maxBytesToWrite){assert(typeof maxBytesToWrite=="number","stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len}var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b)}assert(!Module["STACK_SIZE"],"STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time");assert(typeof Int32Array!="undefined"&&typeof Float64Array!=="undefined"&&Int32Array.prototype.subarray!=undefined&&Int32Array.prototype.set!=undefined,"JS engine does not provide full typed array support");assert(!Module["wasmMemory"],"Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally");assert(!Module["INITIAL_MEMORY"],"Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically");var wasmTable;function writeStackCookie(){var max=_emscripten_stack_get_end();assert((max&3)==0);if(max==0){max+=4}HEAPU32[max>>2]=34821223;HEAPU32[max+4>>2]=2310721022;HEAPU32[0]=1668509029}function checkStackCookie(){if(ABORT)return;var max=_emscripten_stack_get_end();if(max==0){max+=4}var cookie1=HEAPU32[max>>2];var cookie2=HEAPU32[max+4>>2];if(cookie1!=34821223||cookie2!=2310721022){abort("Stack overflow! Stack cookie has been overwritten at "+ptrToString(max)+", expected hex dwords 0x89BACDFE and 0x2135467, but received "+ptrToString(cookie2)+" "+ptrToString(cookie1))}if(HEAPU32[0]!==1668509029){abort("Runtime error: The application has corrupted its heap memory area (address zero)!")}}(function(){var h16=new Int16Array(1);var h8=new Int8Array(h16.buffer);h16[0]=25459;if(h8[0]!==115||h8[1]!==99)throw"Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)"})();var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;function keepRuntimeAlive(){return noExitRuntime}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){assert(!runtimeInitialized);runtimeInitialized=true;checkStackCookie();if(!Module["noFSInit"]&&!FS.init.initialized)FS.init();FS.ignorePermissions=false;TTY.init();SOCKFS.root=FS.mount(SOCKFS,{},null);callRuntimeCallbacks(__ATINIT__)}function postRun(){checkStackCookie();if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}assert(Math.imul,"This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");assert(Math.fround,"This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");assert(Math.clz32,"This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");assert(Math.trunc,"This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;var runDependencyTracking={};function getUniqueRunDependency(id){var orig=id;while(1){if(!runDependencyTracking[id])return id;id=orig+Math.random()}}function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}if(id){assert(!runDependencyTracking[id]);runDependencyTracking[id]=1;if(runDependencyWatcher===null&&typeof setInterval!="undefined"){runDependencyWatcher=setInterval(function(){if(ABORT){clearInterval(runDependencyWatcher);runDependencyWatcher=null;return}var shown=false;for(var dep in runDependencyTracking){if(!shown){shown=true;err("still waiting on run dependencies:")}err("dependency: "+dep)}if(shown){err("(end of list)")}},1e4)}}else{err("warning: run dependency added without ID")}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}if(id){assert(runDependencyTracking[id]);delete runDependencyTracking[id]}else{err("warning: run dependency removed without ID")}if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){if(Module["onAbort"]){Module["onAbort"](what)}what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}function isFileURI(filename){return filename.startsWith("file://")}function createExportWrapper(name,fixedasm){return function(){var displayName=name;var asm=fixedasm;if(!fixedasm){asm=Module["asm"]}assert(runtimeInitialized,"native function `"+displayName+"` called before runtime initialization");if(!asm[name]){assert(asm[name],"exported native function `"+displayName+"` not found")}return asm[name].apply(null,arguments)}}var wasmBinaryFile;wasmBinaryFile="libfaust-wasm.wasm";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}catch(err){abort(err)}}function getBinaryPromise(){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"&&!isFileURI(wasmBinaryFile)){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){if(!response["ok"]){throw"failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()}).catch(function(){return getBinary(wasmBinaryFile)})}else{if(readAsync){return new Promise(function(resolve,reject){readAsync(wasmBinaryFile,function(response){resolve(new Uint8Array(response))},reject)})}}}return Promise.resolve().then(function(){return getBinary(wasmBinaryFile)})}function createWasm(){var info={"env":wasmImports,"wasi_snapshot_preview1":wasmImports};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["memory"];assert(wasmMemory,"memory not found in wasm exports");updateMemoryViews();wasmTable=Module["asm"]["__indirect_function_table"];assert(wasmTable,"table not found in wasm exports");addOnInit(Module["asm"]["__wasm_call_ctors"]);removeRunDependency("wasm-instantiate")}addRunDependency("wasm-instantiate");var trueModule=Module;function receiveInstantiationResult(result){assert(Module===trueModule,"the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");trueModule=null;receiveInstance(result["instance"])}function instantiateArrayBuffer(receiver){return getBinaryPromise().then(function(binary){return WebAssembly.instantiate(binary,info)}).then(function(instance){return instance}).then(receiver,function(reason){err("failed to asynchronously prepare wasm: "+reason);if(isFileURI(wasmBinaryFile)){err("warning: Loading from a file URI ("+wasmBinaryFile+") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing")}abort(reason)})}function instantiateAsync(){if(!wasmBinary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(wasmBinaryFile)&&!isFileURI(wasmBinaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){var result=WebAssembly.instantiateStreaming(response,info);return result.then(receiveInstantiationResult,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(receiveInstantiationResult)})})}else{return instantiateArrayBuffer(receiveInstantiationResult)}}if(Module["instantiateWasm"]){try{var exports=Module["instantiateWasm"](info,receiveInstance);return exports}catch(e){err("Module.instantiateWasm callback failed with error: "+e);readyPromiseReject(e)}}instantiateAsync().catch(readyPromiseReject);return{}}var tempDouble;var tempI64;function legacyModuleProp(prop,newName){if(!Object.getOwnPropertyDescriptor(Module,prop)){Object.defineProperty(Module,prop,{configurable:true,get:function(){abort("Module."+prop+" has been replaced with plain "+newName+" (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)")}})}}function ignoredModuleProp(prop){if(Object.getOwnPropertyDescriptor(Module,prop)){abort("`Module."+prop+"` was supplied but `"+prop+"` not included in INCOMING_MODULE_JS_API")}}function isExportedByForceFilesystem(name){return name==="FS_createPath"||name==="FS_createDataFile"||name==="FS_createPreloadedFile"||name==="FS_unlink"||name==="addRunDependency"||name==="FS_createLazyFile"||name==="FS_createDevice"||name==="removeRunDependency"}function missingGlobal(sym,msg){if(typeof globalThis!=="undefined"){Object.defineProperty(globalThis,sym,{configurable:true,get:function(){warnOnce("`"+sym+"` is not longer defined by emscripten. "+msg);return undefined}})}}missingGlobal("buffer","Please use HEAP8.buffer or wasmMemory.buffer");function missingLibrarySymbol(sym){if(typeof globalThis!=="undefined"&&!Object.getOwnPropertyDescriptor(globalThis,sym)){Object.defineProperty(globalThis,sym,{configurable:true,get:function(){var msg="`"+sym+"` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line";var librarySymbol=sym;if(!librarySymbol.startsWith("_")){librarySymbol="$"+sym}msg+=" (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE="+librarySymbol+")";if(isExportedByForceFilesystem(sym)){msg+=". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"}warnOnce(msg);return undefined}})}unexportedRuntimeSymbol(sym)}function unexportedRuntimeSymbol(sym){if(!Object.getOwnPropertyDescriptor(Module,sym)){Object.defineProperty(Module,sym,{configurable:true,get:function(){var msg="'"+sym+"' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)";if(isExportedByForceFilesystem(sym)){msg+=". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"}abort(msg)}})}}var ASM_CONSTS={158104:$0=>{var dsp_code="";try{var xmlhttp=new XMLHttpRequest;xmlhttp.open("GET",Module.UTF8ToString($0),false);xmlhttp.send();if(xmlhttp.status==200){dsp_code=xmlhttp.responseText}}catch(e){console.log(e)}return allocate(intArrayFromString(dsp_code),"i8",ALLOC_STACK)}};function ExitStatus(status){this.name="ExitStatus";this.message="Program terminated with exit("+status+")";this.status=status}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){callbacks.shift()(Module)}}function ptrToString(ptr){assert(typeof ptr==="number");return"0x"+ptr.toString(16).padStart(8,"0")}function warnOnce(text){if(!warnOnce.shown)warnOnce.shown={};if(!warnOnce.shown[text]){warnOnce.shown[text]=1;if(ENVIRONMENT_IS_NODE)text="warning: "+text;err(text)}}function ___assert_fail(condition,filename,line,func){abort("Assertion failed: "+UTF8ToString(condition)+", at: "+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false)};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;assert(prev>0);return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}var exceptionLast=0;var uncaughtExceptionCount=0;function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);exceptionLast=ptr;uncaughtExceptionCount++;throw ptr+" - Exception catching is disabled, this exception cannot be caught. Compile with -sNO_DISABLE_EXCEPTION_CATCHING or -sEXCEPTION_CATCHING_ALLOWED=[..] to catch."}var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:path=>{if(path==="/")return"/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:function(){var paths=Array.prototype.slice.call(arguments);return PATH.normalize(paths.join("/"))},join2:(l,r)=>{return PATH.normalize(l+"/"+r)}};function getRandomDevice(){if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){var randomBuffer=new Uint8Array(1);return()=>{crypto.getRandomValues(randomBuffer);return randomBuffer[0]}}else if(ENVIRONMENT_IS_NODE){try{var crypto_module=require("crypto");return()=>crypto_module["randomBytes"](1)[0]}catch(e){}}return()=>abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };")}var PATH_FS={resolve:function(){var resolvedPath="",resolvedAbsolute=false;for(var i=arguments.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?arguments[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array}var TTY={ttys:[],init:function(){},shutdown:function(){},register:function(dev,ops){TTY.ttys[dev]={input:[],output:[],ops:ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open:function(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close:function(stream){stream.tty.ops.fsync(stream.tty)},fsync:function(stream){stream.tty.ops.fsync(stream.tty)},read:function(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i0){result=buf.slice(0,bytesRead).toString("utf-8")}else{result=null}}else if(typeof window!="undefined"&&typeof window.prompt=="function"){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else if(typeof readline=="function"){result=readline();if(result!==null){result+="\n"}}if(!result){return null}tty.input=intArrayFromString(result,true)}return tty.input.shift()},put_char:function(tty,val){if(val===null||val===10){out(UTF8ArrayToString(tty.output,0));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync:function(tty){if(tty.output&&tty.output.length>0){out(UTF8ArrayToString(tty.output,0));tty.output=[]}}},default_tty1_ops:{put_char:function(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output,0));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync:function(tty){if(tty.output&&tty.output.length>0){err(UTF8ArrayToString(tty.output,0));tty.output=[]}}}};function mmapAlloc(size){abort("internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported")}var MEMFS={ops_table:null,mount:function(mount){return MEMFS.createNode(null,"/",16384|511,0)},createNode:function(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}if(!MEMFS.ops_table){MEMFS.ops_table={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,allocate:MEMFS.stream_ops.allocate,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}}}var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.timestamp=Date.now();if(parent){parent.contents[name]=node;parent.timestamp=node.timestamp}return node},getFileDataAsTypedArray:function(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage:function(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0)},resizeFileStorage:function(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize}},node_ops:{getattr:function(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.timestamp);attr.mtime=new Date(node.timestamp);attr.ctime=new Date(node.timestamp);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr:function(node,attr){if(attr.mode!==undefined){node.mode=attr.mode}if(attr.timestamp!==undefined){node.timestamp=attr.timestamp}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup:function(parent,name){throw FS.genericErrors[44]},mknod:function(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename:function(old_node,new_dir,new_name){if(FS.isDir(old_node.mode)){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}}delete old_node.parent.contents[old_node.name];old_node.parent.timestamp=Date.now();old_node.name=new_name;new_dir.contents[new_name]=old_node;new_dir.timestamp=old_node.parent.timestamp;old_node.parent=new_dir},unlink:function(parent,name){delete parent.contents[name];parent.timestamp=Date.now()},rmdir:function(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.timestamp=Date.now()},readdir:function(node){var entries=[".",".."];for(var key in node.contents){if(!node.contents.hasOwnProperty(key)){continue}entries.push(key)}return entries},symlink:function(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink:function(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read:function(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);assert(size>=0);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length{assert(arrayBuffer,'Loading data file "'+url+'" failed (no arrayBuffer).');onload(new Uint8Array(arrayBuffer));if(dep)removeRunDependency(dep)},event=>{if(onerror){onerror()}else{throw'Loading data file "'+url+'" failed.'}});if(dep)addRunDependency(dep)}var ERRNO_MESSAGES={0:"Success",1:"Arg list too long",2:"Permission denied",3:"Address already in use",4:"Address not available",5:"Address family not supported by protocol family",6:"No more processes",7:"Socket already connected",8:"Bad file number",9:"Trying to read unreadable message",10:"Mount device busy",11:"Operation canceled",12:"No children",13:"Connection aborted",14:"Connection refused",15:"Connection reset by peer",16:"File locking deadlock error",17:"Destination address required",18:"Math arg out of domain of func",19:"Quota exceeded",20:"File exists",21:"Bad address",22:"File too large",23:"Host is unreachable",24:"Identifier removed",25:"Illegal byte sequence",26:"Connection already in progress",27:"Interrupted system call",28:"Invalid argument",29:"I/O error",30:"Socket is already connected",31:"Is a directory",32:"Too many symbolic links",33:"Too many open files",34:"Too many links",35:"Message too long",36:"Multihop attempted",37:"File or path name too long",38:"Network interface is not configured",39:"Connection reset by network",40:"Network is unreachable",41:"Too many open files in system",42:"No buffer space available",43:"No such device",44:"No such file or directory",45:"Exec format error",46:"No record locks available",47:"The link has been severed",48:"Not enough core",49:"No message of desired type",50:"Protocol not available",51:"No space left on device",52:"Function not implemented",53:"Socket is not connected",54:"Not a directory",55:"Directory not empty",56:"State not recoverable",57:"Socket operation on non-socket",59:"Not a typewriter",60:"No such device or address",61:"Value too large for defined data type",62:"Previous owner died",63:"Not super-user",64:"Broken pipe",65:"Protocol error",66:"Unknown protocol",67:"Protocol wrong type for socket",68:"Math result not representable",69:"Read only file system",70:"Illegal seek",71:"No such process",72:"Stale file handle",73:"Connection timed out",74:"Text file busy",75:"Cross-device link",100:"Device not a stream",101:"Bad font file fmt",102:"Invalid slot",103:"Invalid request code",104:"No anode",105:"Block device required",106:"Channel number out of range",107:"Level 3 halted",108:"Level 3 reset",109:"Link number out of range",110:"Protocol driver not attached",111:"No CSI structure available",112:"Level 2 halted",113:"Invalid exchange",114:"Invalid request descriptor",115:"Exchange full",116:"No data (for no delay io)",117:"Timer expired",118:"Out of streams resources",119:"Machine is not on the network",120:"Package not installed",121:"The object is remote",122:"Advertise error",123:"Srmount error",124:"Communication error on send",125:"Cross mount point (not really error)",126:"Given log. name not unique",127:"f.d. invalid for this operation",128:"Remote address changed",129:"Can access a needed shared lib",130:"Accessing a corrupted shared lib",131:".lib section in a.out corrupted",132:"Attempting to link in too many libs",133:"Attempting to exec a shared library",135:"Streams pipe error",136:"Too many users",137:"Socket type not supported",138:"Not supported",139:"Protocol family not supported",140:"Can't send after socket shutdown",141:"Too many references",142:"Host is down",148:"No medium (in tape drive)",156:"Level 2 not synchronized"};var ERRNO_CODES={};function demangle(func){warnOnce("warning: build with -sDEMANGLE_SUPPORT to link in libcxxabi demangling");return func}function demangleAll(text){var regex=/\b_Z[\w\d_]+/g;return text.replace(regex,function(x){var y=demangle(x);return x===y?x:y+" ["+x+"]"})}var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path,opts={})=>{path=PATH_FS.resolve(path);if(!path)return{path:"",node:null};var defaults={follow_mount:true,recurse_count:0};opts=Object.assign(defaults,opts);if(opts.recurse_count>8){throw new FS.ErrnoError(32)}var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i40){throw new FS.ErrnoError(32)}}}}return{path:current_path,node:current}},getPath:node=>{var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?mount+"/"+path:mount+path}path=path?node.name+"/"+path:node.name;node=node.parent}},hashName:(parentid,name)=>{var hash=0;for(var i=0;i>>0)%FS.nameTable.length},hashAddNode:node=>{var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode:node=>{var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode:(parent,name)=>{var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode,parent)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode:(parent,name,mode,rdev)=>{assert(typeof parent=="object");var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode:node=>{FS.hashRemoveNode(node)},isRoot:node=>{return node===node.parent},isMountpoint:node=>{return!!node.mounted},isFile:mode=>{return(mode&61440)===32768},isDir:mode=>{return(mode&61440)===16384},isLink:mode=>{return(mode&61440)===40960},isChrdev:mode=>{return(mode&61440)===8192},isBlkdev:mode=>{return(mode&61440)===24576},isFIFO:mode=>{return(mode&61440)===4096},isSocket:mode=>{return(mode&49152)===49152},flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:str=>{var flags=FS.flagModes[str];if(typeof flags=="undefined"){throw new Error("Unknown file open mode: "+str)}return flags},flagsToPermissionString:flag=>{var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions:(node,perms)=>{if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup:dir=>{var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate:(dir,name)=>{try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete:(dir,name,isdir)=>{var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen:(node,flags)=>{if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd:(fd_start=0,fd_end=FS.MAX_OPEN_FDS)=>{for(var fd=fd_start;fd<=fd_end;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStream:fd=>FS.streams[fd],createStream:(stream,fd_start,fd_end)=>{if(!FS.FSStream){FS.FSStream=function(){this.shared={}};FS.FSStream.prototype={};Object.defineProperties(FS.FSStream.prototype,{object:{get:function(){return this.node},set:function(val){this.node=val}},isRead:{get:function(){return(this.flags&2097155)!==1}},isWrite:{get:function(){return(this.flags&2097155)!==0}},isAppend:{get:function(){return this.flags&1024}},flags:{get:function(){return this.shared.flags},set:function(val){this.shared.flags=val}},position:{get:function(){return this.shared.position},set:function(val){this.shared.position=val}}})}stream=Object.assign(new FS.FSStream,stream);var fd=FS.nextfd(fd_start,fd_end);stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream:fd=>{FS.streams[fd]=null},chrdev_stream_ops:{open:stream=>{var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;if(stream.stream_ops.open){stream.stream_ops.open(stream)}},llseek:()=>{throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice:(dev,ops)=>{FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts:mount=>{var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push.apply(check,m.mounts)}return mounts},syncfs:(populate,callback)=>{if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err("warning: "+FS.syncFSRequests+" FS.syncfs operations in flight at once, probably just doing extra work")}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){assert(FS.syncFSRequests>0);FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount:(type,opts,mountpoint)=>{if(typeof type=="string"){throw type}var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type:type,opts:opts,mountpoint:mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount:mountpoint=>{var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);Object.keys(FS.nameTable).forEach(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);assert(idx!==-1);node.mount.mounts.splice(idx,1)},lookup:(parent,name)=>{return parent.node_ops.lookup(parent,name)},mknod:(path,mode,dev)=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},create:(path,mode)=>{mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir:(path,mode)=>{mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree:(path,mode)=>{var dirs=path.split("/");var d="";for(var i=0;i{if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink:(oldpath,newpath)=>{if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename:(old_path,new_path)=>{var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(75)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH_FS.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(28)}relative=PATH_FS.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(55)}var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(old_node===new_node){return}var isdir=FS.isDir(old_node.mode);var errCode=FS.mayDelete(old_dir,old_name,isdir);if(errCode){throw new FS.ErrnoError(errCode)}errCode=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(errCode){throw new FS.ErrnoError(errCode)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(63)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(10)}if(new_dir!==old_dir){errCode=FS.nodePermissions(old_dir,"w");if(errCode){throw new FS.ErrnoError(errCode)}}FS.hashRemoveNode(old_node);try{old_dir.node_ops.rename(old_node,new_dir,new_name)}catch(e){throw e}finally{FS.hashAddNode(old_node)}},rmdir:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir:path=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node.node_ops.readdir){throw new FS.ErrnoError(54)}return node.node_ops.readdir(node)},unlink:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink:path=>{var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return PATH_FS.resolve(FS.getPath(link.parent),link.node_ops.readlink(link))},stat:(path,dontFollow)=>{var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;if(!node){throw new FS.ErrnoError(44)}if(!node.node_ops.getattr){throw new FS.ErrnoError(63)}return node.node_ops.getattr(node)},lstat:path=>{return FS.stat(path,true)},chmod:(path,mode,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{mode:mode&4095|node.mode&~4095,timestamp:Date.now()})},lchmod:(path,mode)=>{FS.chmod(path,mode,true)},fchmod:(fd,mode)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chmod(stream.node,mode)},chown:(path,uid,gid,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{timestamp:Date.now()})},lchown:(path,uid,gid)=>{FS.chown(path,uid,gid,true)},fchown:(fd,uid,gid)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chown(stream.node,uid,gid)},truncate:(path,len)=>{if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}node.node_ops.setattr(node,{size:len,timestamp:Date.now()})},ftruncate:(fd,len)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(28)}FS.truncate(stream.node,len)},utime:(path,atime,mtime)=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;node.node_ops.setattr(node,{timestamp:Math.max(atime,mtime)})},open:(path,flags,mode)=>{if(path===""){throw new FS.ErrnoError(44)}flags=typeof flags=="string"?FS.modeStringToFlags(flags):flags;mode=typeof mode=="undefined"?438:mode;if(flags&64){mode=mode&4095|32768}else{mode=0}var node;if(typeof path=="object"){node=path}else{path=PATH.normalize(path);try{var lookup=FS.lookupPath(path,{follow:!(flags&131072)});node=lookup.node}catch(e){}}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(20)}}else{node=FS.mknod(path,mode,0);created=true}}if(!node){throw new FS.ErrnoError(44)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}if(!created){var errCode=FS.mayOpen(node,flags);if(errCode){throw new FS.ErrnoError(errCode)}}if(flags&512&&!created){FS.truncate(node,0)}flags&=~(128|512|131072);var stream=FS.createStream({node:node,path:FS.getPath(node),flags:flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false});if(stream.stream_ops.open){stream.stream_ops.open(stream)}if(Module["logReadFiles"]&&!(flags&1)){if(!FS.readFiles)FS.readFiles={};if(!(path in FS.readFiles)){FS.readFiles[path]=1}}return stream},close:stream=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(stream.getdents)stream.getdents=null;try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed:stream=>{return stream.fd===null},llseek:(stream,offset,whence)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read:(stream,buffer,offset,length,position)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write:(stream,buffer,offset,length,position,canOwn)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},allocate:(stream,offset,length)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(offset<0||length<=0){throw new FS.ErrnoError(28)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(!FS.isFile(stream.node.mode)&&!FS.isDir(stream.node.mode)){throw new FS.ErrnoError(43)}if(!stream.stream_ops.allocate){throw new FS.ErrnoError(138)}stream.stream_ops.allocate(stream,offset,length)},mmap:(stream,length,position,prot,flags)=>{if((prot&2)!==0&&(flags&2)===0&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync:(stream,buffer,offset,length,mmapFlags)=>{if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},munmap:stream=>0,ioctl:(stream,cmd,arg)=>{if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile:(path,opts={})=>{opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){throw new Error('Invalid encoding type "'+opts.encoding+'"')}var ret;var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){ret=UTF8ArrayToString(buf,0)}else if(opts.encoding==="binary"){ret=buf}FS.close(stream);return ret},writeFile:(path,data,opts={})=>{opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){var buf=new Uint8Array(lengthBytesUTF8(data)+1);var actualNumBytes=stringToUTF8Array(data,buf,0,buf.length);FS.write(stream,buf,0,actualNumBytes,undefined,opts.canOwn)}else if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{throw new Error("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir:path=>{var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories:()=>{FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices:()=>{FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var random_device=getRandomDevice();FS.createDevice("/dev","random",random_device);FS.createDevice("/dev","urandom",random_device);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories:()=>{FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount:()=>{var node=FS.createNode(proc_self,"fd",16384|511,73);node.node_ops={lookup:(parent,name)=>{var fd=+name;var stream=FS.getStream(fd);if(!stream)throw new FS.ErrnoError(8);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd")},createStandardStreams:()=>{if(Module["stdin"]){FS.createDevice("/dev","stdin",Module["stdin"])}else{FS.symlink("/dev/tty","/dev/stdin")}if(Module["stdout"]){FS.createDevice("/dev","stdout",null,Module["stdout"])}else{FS.symlink("/dev/tty","/dev/stdout")}if(Module["stderr"]){FS.createDevice("/dev","stderr",null,Module["stderr"])}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1);assert(stdin.fd===0,"invalid handle for stdin ("+stdin.fd+")");assert(stdout.fd===1,"invalid handle for stdout ("+stdout.fd+")");assert(stderr.fd===2,"invalid handle for stderr ("+stderr.fd+")")},ensureErrnoError:()=>{if(FS.ErrnoError)return;FS.ErrnoError=function ErrnoError(errno,node){this.node=node;this.setErrno=function(errno){this.errno=errno;for(var key in ERRNO_CODES){if(ERRNO_CODES[key]===errno){this.code=key;break}}};this.setErrno(errno);this.message=ERRNO_MESSAGES[errno];if(this.stack){Object.defineProperty(this,"stack",{value:(new Error).stack,writable:true});this.stack=demangleAll(this.stack)}};FS.ErrnoError.prototype=new Error;FS.ErrnoError.prototype.constructor=FS.ErrnoError;[44].forEach(code=>{FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack=""})},staticInit:()=>{FS.ensureErrnoError();FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={"MEMFS":MEMFS}},init:(input,output,error)=>{assert(!FS.init.initialized,"FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");FS.init.initialized=true;FS.ensureErrnoError();Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams()},quit:()=>{FS.init.initialized=false;_fflush(0);for(var i=0;i{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode},findObject:(path,dontResolveLastLink)=>{var ret=FS.analyzePath(path,dontResolveLastLink);if(!ret.exists){return null}return ret.object},analyzePath:(path,dontResolveLastLink)=>{try{var lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});path=lookup.path}catch(e){}var ret={isRoot:false,exists:false,error:0,name:null,path:null,object:null,parentExists:false,parentPath:null,parentObject:null};try{var lookup=FS.lookupPath(path,{parent:true});ret.parentExists=true;ret.parentPath=lookup.path;ret.parentObject=lookup.node;ret.name=PATH.basename(path);lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});ret.exists=true;ret.path=lookup.path;ret.object=lookup.node;ret.name=lookup.node.name;ret.isRoot=lookup.path==="/"}catch(e){ret.error=e.errno}return ret},createPath:(parent,path,canRead,canWrite)=>{parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){}parent=current}return current},createFile:(parent,name,properties,canRead,canWrite)=>{var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile:(parent,name,data,canRead,canWrite,canOwn)=>{var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS.getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data=="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i{var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(!!input,!!output);if(!FS.createDevice.major)FS.createDevice.major=64;var dev=FS.makedev(FS.createDevice.major++,0);FS.registerDevice(dev,{open:stream=>{stream.seekable=false},close:stream=>{if(output&&output.buffer&&output.buffer.length){output(10)}},read:(stream,buffer,offset,length,pos)=>{var bytesRead=0;for(var i=0;i{for(var i=0;i{if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(typeof XMLHttpRequest!="undefined"){throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else if(read_){try{obj.contents=intArrayFromString(read_(obj.url),true);obj.usedBytes=obj.contents.length}catch(e){throw new FS.ErrnoError(29)}}else{throw new Error("Cannot load without read() or XMLHttpRequest.")}},createLazyFile:(parent,name,url,canRead,canWrite)=>{function LazyUint8Array(){this.lengthKnown=false;this.chunks=[]}LazyUint8Array.prototype.get=function LazyUint8Array_get(idx){if(idx>this.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]};LazyUint8Array.prototype.setDataGetter=function LazyUint8Array_setDataGetter(getter){this.getter=getter};LazyUint8Array.prototype.cacheLength=function LazyUint8Array_cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)throw new Error("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)throw new Error("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")throw new Error("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true};if(typeof XMLHttpRequest!="undefined"){if(!ENVIRONMENT_IS_WORKER)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var lazyArray=new LazyUint8Array;Object.defineProperties(lazyArray,{length:{get:function(){if(!this.lengthKnown){this.cacheLength()}return this._length}},chunkSize:{get:function(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}});var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url:url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};var keys=Object.keys(node.stream_ops);keys.forEach(key=>{var fn=node.stream_ops[key];stream_ops[key]=function forceLoadLazyFile(){FS.forceLoadFile(node);return fn.apply(null,arguments)}});function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);assert(size>=0);if(contents.slice){for(var i=0;i{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr:ptr,allocated:true}};node.stream_ops=stream_ops;return node},createPreloadedFile:(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency("cp "+fullname);function processData(byteArray){function finish(byteArray){if(preFinish)preFinish();if(!dontCreateFile){FS.createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}if(onload)onload();removeRunDependency(dep)}if(Browser.handledByPreloadPlugin(byteArray,fullname,finish,()=>{if(onerror)onerror();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url,byteArray=>processData(byteArray),onerror)}else{processData(url)}},indexedDB:()=>{return window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB},DB_NAME:()=>{return"EM_FS_"+window.location.pathname},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(paths,onload=(()=>{}),onerror=(()=>{}))=>{var indexedDB=FS.indexedDB();try{var openRequest=indexedDB.open(FS.DB_NAME(),FS.DB_VERSION)}catch(e){return onerror(e)}openRequest.onupgradeneeded=()=>{out("creating db");var db=openRequest.result;db.createObjectStore(FS.DB_STORE_NAME)};openRequest.onsuccess=()=>{var db=openRequest.result;var transaction=db.transaction([FS.DB_STORE_NAME],"readwrite");var files=transaction.objectStore(FS.DB_STORE_NAME);var ok=0,fail=0,total=paths.length;function finish(){if(fail==0)onload();else onerror()}paths.forEach(path=>{var putRequest=files.put(FS.analyzePath(path).object.contents,path);putRequest.onsuccess=()=>{ok++;if(ok+fail==total)finish()};putRequest.onerror=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror},loadFilesFromDB:(paths,onload=(()=>{}),onerror=(()=>{}))=>{var indexedDB=FS.indexedDB();try{var openRequest=indexedDB.open(FS.DB_NAME(),FS.DB_VERSION)}catch(e){return onerror(e)}openRequest.onupgradeneeded=onerror;openRequest.onsuccess=()=>{var db=openRequest.result;try{var transaction=db.transaction([FS.DB_STORE_NAME],"readonly")}catch(e){onerror(e);return}var files=transaction.objectStore(FS.DB_STORE_NAME);var ok=0,fail=0,total=paths.length;function finish(){if(fail==0)onload();else onerror()}paths.forEach(path=>{var getRequest=files.get(path);getRequest.onsuccess=()=>{if(FS.analyzePath(path).exists){FS.unlink(path)}FS.createDataFile(PATH.dirname(path),PATH.basename(path),getRequest.result,true,true,true);ok++;if(ok+fail==total)finish()};getRequest.onerror=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror},absolutePath:()=>{abort("FS.absolutePath has been removed; use PATH_FS.resolve instead")},createFolder:()=>{abort("FS.createFolder has been removed; use FS.mkdir instead")},createLink:()=>{abort("FS.createLink has been removed; use FS.symlink instead")},joinPath:()=>{abort("FS.joinPath has been removed; use PATH.join instead")},mmapAlloc:()=>{abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc")},standardizePath:()=>{abort("FS.standardizePath has been removed; use PATH.normalize instead")}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt:function(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return PATH.join2(dir,path)},doStat:function(func,path,buf){try{var stat=func(path)}catch(e){if(e&&e.node&&PATH.normalize(path)!==PATH.normalize(FS.getPath(e.node))){return-54}throw e}HEAP32[buf>>2]=stat.dev;HEAP32[buf+8>>2]=stat.ino;HEAP32[buf+12>>2]=stat.mode;HEAPU32[buf+16>>2]=stat.nlink;HEAP32[buf+20>>2]=stat.uid;HEAP32[buf+24>>2]=stat.gid;HEAP32[buf+28>>2]=stat.rdev;tempI64=[stat.size>>>0,(tempDouble=stat.size,+Math.abs(tempDouble)>=1?tempDouble>0?(Math.min(+Math.floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+40>>2]=tempI64[0],HEAP32[buf+44>>2]=tempI64[1];HEAP32[buf+48>>2]=4096;HEAP32[buf+52>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();tempI64=[Math.floor(atime/1e3)>>>0,(tempDouble=Math.floor(atime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?(Math.min(+Math.floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+56>>2]=tempI64[0],HEAP32[buf+60>>2]=tempI64[1];HEAPU32[buf+64>>2]=atime%1e3*1e3;tempI64=[Math.floor(mtime/1e3)>>>0,(tempDouble=Math.floor(mtime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?(Math.min(+Math.floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+72>>2]=tempI64[0],HEAP32[buf+76>>2]=tempI64[1];HEAPU32[buf+80>>2]=mtime%1e3*1e3;tempI64=[Math.floor(ctime/1e3)>>>0,(tempDouble=Math.floor(ctime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?(Math.min(+Math.floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+88>>2]=tempI64[0],HEAP32[buf+92>>2]=tempI64[1];HEAPU32[buf+96>>2]=ctime%1e3*1e3;tempI64=[stat.ino>>>0,(tempDouble=stat.ino,+Math.abs(tempDouble)>=1?tempDouble>0?(Math.min(+Math.floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+104>>2]=tempI64[0],HEAP32[buf+108>>2]=tempI64[1];return 0},doMsync:function(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},varargs:undefined,get:function(){assert(SYSCALLS.varargs!=undefined);SYSCALLS.varargs+=4;var ret=HEAP32[SYSCALLS.varargs-4>>2];return ret},getStr:function(ptr){var ret=UTF8ToString(ptr);return ret},getStreamFromFD:function(fd){var stream=FS.getStream(fd);if(!stream)throw new FS.ErrnoError(8);return stream}};function ___syscall__newselect(nfds,readfds,writefds,exceptfds,timeout){try{assert(nfds<=64,"nfds must be less than or equal to 64");assert(!exceptfds,"exceptfds not supported");var total=0;var srcReadLow=readfds?HEAP32[readfds>>2]:0,srcReadHigh=readfds?HEAP32[readfds+4>>2]:0;var srcWriteLow=writefds?HEAP32[writefds>>2]:0,srcWriteHigh=writefds?HEAP32[writefds+4>>2]:0;var srcExceptLow=exceptfds?HEAP32[exceptfds>>2]:0,srcExceptHigh=exceptfds?HEAP32[exceptfds+4>>2]:0;var dstReadLow=0,dstReadHigh=0;var dstWriteLow=0,dstWriteHigh=0;var dstExceptLow=0,dstExceptHigh=0;var allLow=(readfds?HEAP32[readfds>>2]:0)|(writefds?HEAP32[writefds>>2]:0)|(exceptfds?HEAP32[exceptfds>>2]:0);var allHigh=(readfds?HEAP32[readfds+4>>2]:0)|(writefds?HEAP32[writefds+4>>2]:0)|(exceptfds?HEAP32[exceptfds+4>>2]:0);var check=function(fd,low,high,val){return fd<32?low&val:high&val};for(var fd=0;fd>2]=dstReadLow;HEAP32[readfds+4>>2]=dstReadHigh}if(writefds){HEAP32[writefds>>2]=dstWriteLow;HEAP32[writefds+4>>2]=dstWriteHigh}if(exceptfds){HEAP32[exceptfds>>2]=dstExceptLow;HEAP32[exceptfds+4>>2]=dstExceptHigh}return total}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_chdir(path){try{path=SYSCALLS.getStr(path);FS.chdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}var SOCKFS={mount:function(mount){Module["websocket"]=Module["websocket"]&&"object"===typeof Module["websocket"]?Module["websocket"]:{};Module["websocket"]._callbacks={};Module["websocket"]["on"]=function(event,callback){if("function"===typeof callback){this._callbacks[event]=callback}return this};Module["websocket"].emit=function(event,param){if("function"===typeof this._callbacks[event]){this._callbacks[event].call(this,param)}};return FS.createNode(null,"/",16384|511,0)},createSocket:function(family,type,protocol){type&=~526336;var streaming=type==1;if(streaming&&protocol&&protocol!=6){throw new FS.ErrnoError(66)}var sock={family:family,type:type,protocol:protocol,server:null,error:null,peers:{},pending:[],recv_queue:[],sock_ops:SOCKFS.websocket_sock_ops};var name=SOCKFS.nextname();var node=FS.createNode(SOCKFS.root,name,49152,0);node.sock=sock;var stream=FS.createStream({path:name,node:node,flags:2,seekable:false,stream_ops:SOCKFS.stream_ops});sock.stream=stream;return sock},getSocket:function(fd){var stream=FS.getStream(fd);if(!stream||!FS.isSocket(stream.node.mode)){return null}return stream.node.sock},stream_ops:{poll:function(stream){var sock=stream.node.sock;return sock.sock_ops.poll(sock)},ioctl:function(stream,request,varargs){var sock=stream.node.sock;return sock.sock_ops.ioctl(sock,request,varargs)},read:function(stream,buffer,offset,length,position){var sock=stream.node.sock;var msg=sock.sock_ops.recvmsg(sock,length);if(!msg){return 0}buffer.set(msg.buffer,offset);return msg.buffer.length},write:function(stream,buffer,offset,length,position){var sock=stream.node.sock;return sock.sock_ops.sendmsg(sock,buffer,offset,length)},close:function(stream){var sock=stream.node.sock;sock.sock_ops.close(sock)}},nextname:function(){if(!SOCKFS.nextname.current){SOCKFS.nextname.current=0}return"socket["+SOCKFS.nextname.current+++"]"},websocket_sock_ops:{createPeer:function(sock,addr,port){var ws;if(typeof addr=="object"){ws=addr;addr=null;port=null}if(ws){if(ws._socket){addr=ws._socket.remoteAddress;port=ws._socket.remotePort}else{var result=/ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);if(!result){throw new Error("WebSocket URL must be in the format ws(s)://address:port")}addr=result[1];port=parseInt(result[2],10)}}else{try{var runtimeConfig=Module["websocket"]&&"object"===typeof Module["websocket"];var url="ws:#".replace("#","//");if(runtimeConfig){if("string"===typeof Module["websocket"]["url"]){url=Module["websocket"]["url"]}}if(url==="ws://"||url==="wss://"){var parts=addr.split("/");url=url+parts[0]+":"+port+"/"+parts.slice(1).join("/")}var subProtocols="binary";if(runtimeConfig){if("string"===typeof Module["websocket"]["subprotocol"]){subProtocols=Module["websocket"]["subprotocol"]}}var opts=undefined;if(subProtocols!=="null"){subProtocols=subProtocols.replace(/^ +| +$/g,"").split(/ *, */);opts=subProtocols}if(runtimeConfig&&null===Module["websocket"]["subprotocol"]){subProtocols="null";opts=undefined}var WebSocketConstructor;if(ENVIRONMENT_IS_NODE){WebSocketConstructor=require("ws")}else{WebSocketConstructor=WebSocket}ws=new WebSocketConstructor(url,opts);ws.binaryType="arraybuffer"}catch(e){throw new FS.ErrnoError(23)}}var peer={addr:addr,port:port,socket:ws,dgram_send_queue:[]};SOCKFS.websocket_sock_ops.addPeer(sock,peer);SOCKFS.websocket_sock_ops.handlePeerEvents(sock,peer);if(sock.type===2&&typeof sock.sport!="undefined"){peer.dgram_send_queue.push(new Uint8Array([255,255,255,255,"p".charCodeAt(0),"o".charCodeAt(0),"r".charCodeAt(0),"t".charCodeAt(0),(sock.sport&65280)>>8,sock.sport&255]))}return peer},getPeer:function(sock,addr,port){return sock.peers[addr+":"+port]},addPeer:function(sock,peer){sock.peers[peer.addr+":"+peer.port]=peer},removePeer:function(sock,peer){delete sock.peers[peer.addr+":"+peer.port]},handlePeerEvents:function(sock,peer){var first=true;var handleOpen=function(){Module["websocket"].emit("open",sock.stream.fd);try{var queued=peer.dgram_send_queue.shift();while(queued){peer.socket.send(queued);queued=peer.dgram_send_queue.shift()}}catch(e){peer.socket.close()}};function handleMessage(data){if(typeof data=="string"){var encoder=new TextEncoder;data=encoder.encode(data)}else{assert(data.byteLength!==undefined);if(data.byteLength==0){return}data=new Uint8Array(data)}var wasfirst=first;first=false;if(wasfirst&&data.length===10&&data[0]===255&&data[1]===255&&data[2]===255&&data[3]===255&&data[4]==="p".charCodeAt(0)&&data[5]==="o".charCodeAt(0)&&data[6]==="r".charCodeAt(0)&&data[7]==="t".charCodeAt(0)){var newport=data[8]<<8|data[9];SOCKFS.websocket_sock_ops.removePeer(sock,peer);peer.port=newport;SOCKFS.websocket_sock_ops.addPeer(sock,peer);return}sock.recv_queue.push({addr:peer.addr,port:peer.port,data:data});Module["websocket"].emit("message",sock.stream.fd)}if(ENVIRONMENT_IS_NODE){peer.socket.on("open",handleOpen);peer.socket.on("message",function(data,isBinary){if(!isBinary){return}handleMessage(new Uint8Array(data).buffer)});peer.socket.on("close",function(){Module["websocket"].emit("close",sock.stream.fd)});peer.socket.on("error",function(error){sock.error=14;Module["websocket"].emit("error",[sock.stream.fd,sock.error,"ECONNREFUSED: Connection refused"])})}else{peer.socket.onopen=handleOpen;peer.socket.onclose=function(){Module["websocket"].emit("close",sock.stream.fd)};peer.socket.onmessage=function peer_socket_onmessage(event){handleMessage(event.data)};peer.socket.onerror=function(error){sock.error=14;Module["websocket"].emit("error",[sock.stream.fd,sock.error,"ECONNREFUSED: Connection refused"])}}},poll:function(sock){if(sock.type===1&&sock.server){return sock.pending.length?64|1:0}var mask=0;var dest=sock.type===1?SOCKFS.websocket_sock_ops.getPeer(sock,sock.daddr,sock.dport):null;if(sock.recv_queue.length||!dest||dest&&dest.socket.readyState===dest.socket.CLOSING||dest&&dest.socket.readyState===dest.socket.CLOSED){mask|=64|1}if(!dest||dest&&dest.socket.readyState===dest.socket.OPEN){mask|=4}if(dest&&dest.socket.readyState===dest.socket.CLOSING||dest&&dest.socket.readyState===dest.socket.CLOSED){mask|=16}return mask},ioctl:function(sock,request,arg){switch(request){case 21531:var bytes=0;if(sock.recv_queue.length){bytes=sock.recv_queue[0].data.length}HEAP32[arg>>2]=bytes;return 0;default:return 28}},close:function(sock){if(sock.server){try{sock.server.close()}catch(e){}sock.server=null}var peers=Object.keys(sock.peers);for(var i=0;i>2]=value;return value}function inetNtop4(addr){return(addr&255)+"."+(addr>>8&255)+"."+(addr>>16&255)+"."+(addr>>24&255)}function inetNtop6(ints){var str="";var word=0;var longest=0;var lastzero=0;var zstart=0;var len=0;var i=0;var parts=[ints[0]&65535,ints[0]>>16,ints[1]&65535,ints[1]>>16,ints[2]&65535,ints[2]>>16,ints[3]&65535,ints[3]>>16];var hasipv4=true;var v4part="";for(i=0;i<5;i++){if(parts[i]!==0){hasipv4=false;break}}if(hasipv4){v4part=inetNtop4(parts[6]|parts[7]<<16);if(parts[5]===-1){str="::ffff:";str+=v4part;return str}if(parts[5]===0){str="::";if(v4part==="0.0.0.0")v4part="";if(v4part==="0.0.0.1")v4part="1";str+=v4part;return str}}for(word=0;word<8;word++){if(parts[word]===0){if(word-lastzero>1){len=0}lastzero=word;len++}if(len>longest){longest=len;zstart=word-longest+1}}for(word=0;word<8;word++){if(longest>1){if(parts[word]===0&&word>=zstart&&word>1];var port=_ntohs(HEAPU16[sa+2>>1]);var addr;switch(family){case 2:if(salen!==16){return{errno:28}}addr=HEAP32[sa+4>>2];addr=inetNtop4(addr);break;case 10:if(salen!==28){return{errno:28}}addr=[HEAP32[sa+8>>2],HEAP32[sa+12>>2],HEAP32[sa+16>>2],HEAP32[sa+20>>2]];addr=inetNtop6(addr);break;default:return{errno:5}}return{family:family,addr:addr,port:port}}function inetPton4(str){var b=str.split(".");for(var i=0;i<4;i++){var tmp=Number(b[i]);if(isNaN(tmp))return null;b[i]=tmp}return(b[0]|b[1]<<8|b[2]<<16|b[3]<<24)>>>0}function jstoi_q(str){return parseInt(str)}function inetPton6(str){var words;var w,offset,z;var valid6regx=/^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i;var parts=[];if(!valid6regx.test(str)){return null}if(str==="::"){return[0,0,0,0,0,0,0,0]}if(str.startsWith("::")){str=str.replace("::","Z:")}else{str=str.replace("::",":Z:")}if(str.indexOf(".")>0){str=str.replace(new RegExp("[.]","g"),":");words=str.split(":");words[words.length-4]=jstoi_q(words[words.length-4])+jstoi_q(words[words.length-3])*256;words[words.length-3]=jstoi_q(words[words.length-2])+jstoi_q(words[words.length-1])*256;words=words.slice(0,words.length-2)}else{words=str.split(":")}offset=0;z=0;for(w=0;w>1]=2;return 0}case 6:case 7:return 0;case 16:case 8:return-28;case 9:setErrNo(28);return-1;default:{return-28}}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_getcwd(buf,size){try{if(size===0)return-28;var cwd=FS.cwd();var cwdLengthInBytes=lengthBytesUTF8(cwd)+1;if(size>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21531:{var argp=SYSCALLS.get();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;return 0}case 21524:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_mkdirat(dirfd,path,mode){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);path=PATH.normalize(path);if(path[path.length-1]==="/")path=path.substr(0,path.length-1);FS.mkdir(path,mode,0);return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?SYSCALLS.get():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_readlinkat(dirfd,path,buf,bufsize){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(bufsize<=0)return-28;var ret=FS.readlink(path);var len=Math.min(bufsize,lengthBytesUTF8(ret));var endChar=HEAP8[buf+len];stringToUTF8(ret,buf,bufsize+1);HEAP8[buf+len]=endChar;return len}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_socket(domain,type,protocol){try{var sock=SOCKFS.createSocket(domain,type,protocol);assert(sock.stream.fd<64);return sock.stream.fd}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}var structRegistrations={};function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAP32[pointer>>2])}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var char_0=48;var char_9=57;function makeLegalFunctionName(name){if(undefined===name){return"_unknown"}name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return"_"+name}return name}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return new Function("body","return function "+name+"() {\n"+' "use strict";'+" return body.apply(this, arguments);\n"+"};\n")(body)}function extendError(baseErrorType,errorName){var errorClass=createNamedFunction(errorName,function(message){this.name=errorName;this.message=message;var stack=new Error(message).stack;if(stack!==undefined){this.stack=this.toString()+"\n"+stack.replace(/^Error(:[^\n]*)?\n/,"")}});errorClass.prototype=Object.create(baseErrorType.prototype);errorClass.prototype.constructor=errorClass;errorClass.prototype.toString=function(){if(this.message===undefined){return this.name}else{return this.name+": "+this.message}};return errorClass}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function whenDependentTypesAreResolved(myTypes,dependentTypes,getTypeConverters){myTypes.forEach(function(type){typeDependencies[type]=dependentTypes});function onComplete(typeConverters){var myTypeConverters=getTypeConverters(typeConverters);if(myTypeConverters.length!==myTypes.length){throwInternalError("Mismatched type converter count")}for(var i=0;i{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}function __embind_finalize_value_object(structType){var reg=structRegistrations[structType];delete structRegistrations[structType];var rawConstructor=reg.rawConstructor;var rawDestructor=reg.rawDestructor;var fieldRecords=reg.fields;var fieldTypes=fieldRecords.map(field=>field.getterReturnType).concat(fieldRecords.map(field=>field.setterArgumentType));whenDependentTypesAreResolved([structType],fieldTypes,fieldTypes=>{var fields={};fieldRecords.forEach((field,i)=>{var fieldName=field.fieldName;var getterReturnType=fieldTypes[i];var getter=field.getter;var getterContext=field.getterContext;var setterArgumentType=fieldTypes[i+fieldRecords.length];var setter=field.setter;var setterContext=field.setterContext;fields[fieldName]={read:ptr=>{return getterReturnType["fromWireType"](getter(getterContext,ptr))},write:(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}}});return[{name:reg.name,"fromWireType":function(ptr){var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv},"toWireType":function(destructors,o){for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError('Missing field: "'+fieldName+'"')}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:rawDestructor}]})}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+size)}}function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i)}embind_charCodes=codes}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]]}return ret}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError('type "'+name+'" must have a positive integer typeid pointer')}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else{throwBindingError("Cannot register type '"+name+"' twice")}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb())}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return!!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8}else if(size===2){heap=HEAP16}else if(size===4){heap=HEAP32}else{throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null})}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;var rightClass=other.$$.ptrType.registeredClass;var right=other.$$.ptr;while(leftClass.baseClass){left=leftClass.upcast(left);leftClass=leftClass.baseClass}while(rightClass.baseClass){right=rightClass.upcast(right);rightClass=rightClass.baseClass}return leftClass===rightClass&&left===right}function shallowCopyInternalPointer(o){return{count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted")}var finalizationRegistry=false;function detachFinalizer(handle){}function runDestructor($$){if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr)}else{$$.ptrType.registeredClass.rawDestructor($$.ptr)}}function releaseClassHandle($$){$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$)}}function downcastPointer(ptr,ptrClass,desiredClass){if(ptrClass===desiredClass){return ptr}if(undefined===desiredClass.baseClass){return null}var rv=downcastPointer(ptr,ptrClass,desiredClass.baseClass);if(rv===null){return null}return desiredClass.downcast(rv)}var registeredPointers={};function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k])}}return rv}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}var delayFunction=undefined;function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes)}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined")}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass}return ptr}function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}function makeClassHandle(prototype,record){if(!record.ptrType||!record.ptr){throwInternalError("makeClassHandle requires ptr and ptrType")}var hasSmartPtrType=!!record.smartPtrType;var hasSmartPtr=!!record.smartPtr;if(hasSmartPtrType!==hasSmartPtr){throwInternalError("Both smartPtrType and smartPtr must be specified")}record.count={value:1};return attachFinalizer(Object.create(prototype,{$$:{value:record}}))}function RegisteredPointer_fromWireType(ptr){var rawPointer=this.getPointee(ptr);if(!rawPointer){this.destructor(ptr);return null}var registeredInstance=getInheritedInstance(this.registeredClass,rawPointer);if(undefined!==registeredInstance){if(0===registeredInstance.$$.count.value){registeredInstance.$$.ptr=rawPointer;registeredInstance.$$.smartPtr=ptr;return registeredInstance["clone"]()}else{var rv=registeredInstance["clone"]();this.destructor(ptr);return rv}}function makeDefaultHandle(){if(this.isSmartPointer){return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this.pointeeType,ptr:rawPointer,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this,ptr:ptr})}}var actualType=this.registeredClass.getActualType(rawPointer);var registeredPointerRecord=registeredPointers[actualType];if(!registeredPointerRecord){return makeDefaultHandle.call(this)}var toType;if(this.isConst){toType=registeredPointerRecord.constPointerType}else{toType=registeredPointerRecord.pointerType}var dp=downcastPointer(rawPointer,this.registeredClass,toType.registeredClass);if(dp===null){return makeDefaultHandle.call(this)}if(this.isSmartPointer){return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp})}}function attachFinalizer(handle){if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{console.warn(info.leakWarning.stack.replace(/^Error: /,""));releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};var cls=$$.ptrType.registeredClass;info.leakWarning=new Error("Embind found a leaked C++ instance "+cls.name+" <"+ptrToString($$.ptr)+">.\n"+"We'll free it automatically in this case, but this functionality is not reliable across various environments.\n"+"Make sure to invoke .delete() manually once you're done with the instance instead.\n"+"Originally allocated");if("captureStackTrace"in Error){Error.captureStackTrace(info.leakWarning,RegisteredPointer_fromWireType)}finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.unregister(handle);return attachFinalizer(handle)}function ClassHandle_clone(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.preservePointerOnDelete){this.$$.count.value+=1;return this}else{var clone=attachFinalizer(Object.create(Object.getPrototypeOf(this),{$$:{value:shallowCopyInternalPointer(this.$$)}}));clone.$$.count.value+=1;clone.$$.deleteScheduled=false;return clone}}function ClassHandle_delete(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}detachFinalizer(this);releaseClassHandle(this.$$);if(!this.$$.preservePointerOnDelete){this.$$.smartPtr=undefined;this.$$.ptr=undefined}}function ClassHandle_isDeleted(){return!this.$$.ptr}function ClassHandle_deleteLater(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}deletionQueue.push(this);if(deletionQueue.length===1&&delayFunction){delayFunction(flushPendingDeletes)}this.$$.deleteScheduled=true;return this}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater}function ClassHandle(){}function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError("Function '"+humanName+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+proto[methodName].overloadTable+")!")}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc}}function exposePublicSymbol(name,value,numArguments){if(Module.hasOwnProperty(name)){if(undefined===numArguments||undefined!==Module[name].overloadTable&&undefined!==Module[name].overloadTable[numArguments]){throwBindingError("Cannot register public name '"+name+"' twice")}ensureOverloadTable(Module,name,name);if(Module.hasOwnProperty(numArguments)){throwBindingError("Cannot register multiple overloads of a function with the same number of arguments ("+numArguments+")!")}Module[name].overloadTable[numArguments]=value}else{Module[name]=value;if(undefined!==numArguments){Module[name].numArguments=numArguments}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[]}function upcastPointer(ptr,ptrClass,desiredClass){while(ptrClass!==desiredClass){if(!ptrClass.upcast){throwBindingError("Expected null or instance of "+desiredClass.name+", got an instance of "+ptrClass.name)}ptr=ptrClass.upcast(ptr);ptrClass=ptrClass.baseClass}return ptr}function constNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name)}return 0}if(!handle.$$){throwBindingError('Cannot pass "'+embindRepr(handle)+'" as a '+this.name)}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name)}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr)}return ptr}else{return 0}}if(!handle.$$){throwBindingError('Cannot pass "'+embindRepr(handle)+'" as a '+this.name)}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name)}if(!this.isConst&&handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+(handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name)+" to parameter type "+this.name)}var handleClass=handle.$$.ptrType.registeredClass;ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);if(this.isSmartPointer){if(undefined===handle.$$.smartPtr){throwBindingError("Passing raw pointer to smart pointer is illegal")}switch(this.sharingPolicy){case 0:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{throwBindingError("Cannot convert argument of type "+(handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name)+" to parameter type "+this.name)}break;case 1:ptr=handle.$$.smartPtr;break;case 2:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{var clonedHandle=handle["clone"]();ptr=this.rawShare(ptr,Emval.toHandle(function(){clonedHandle["delete"]()}));if(destructors!==null){destructors.push(this.rawDestructor,ptr)}}break;default:throwBindingError("Unsupporting sharing policy")}}return ptr}function nonConstNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name)}return 0}if(!handle.$$){throwBindingError('Cannot pass "'+embindRepr(handle)+'" as a '+this.name)}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name)}if(handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+handle.$$.ptrType.name+" to parameter type "+this.name)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr)}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr)}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]()}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType}function RegisteredPointer(name,registeredClass,isReference,isConst,isSmartPointer,pointeeType,sharingPolicy,rawGetPointee,rawConstructor,rawShare,rawDestructor){this.name=name;this.registeredClass=registeredClass;this.isReference=isReference;this.isConst=isConst;this.isSmartPointer=isSmartPointer;this.pointeeType=pointeeType;this.sharingPolicy=sharingPolicy;this.rawGetPointee=rawGetPointee;this.rawConstructor=rawConstructor;this.rawShare=rawShare;this.rawDestructor=rawDestructor;if(!isSmartPointer&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null}else{this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null}}else{this["toWireType"]=genericPointerToWireType}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}}function dynCallLegacy(sig,ptr,args){assert("dynCall_"+sig in Module,"bad function pointer type - dynCall function not found for sig '"+sig+"'");if(args&&args.length){assert(args.length===sig.substring(1).replace(/j/g,"--").length)}else{assert(sig.length==1)}var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}assert(wasmTable.get(funcPtr)==func,"JavaScript-side Wasm function table mirror is out of date!");return func}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}assert(getWasmTableEntry(ptr),"missing table entry in dynCall: "+ptr);var rtn=getWasmTableEntry(ptr).apply(null,args);return rtn}function getDynCaller(sig,ptr){assert(sig.includes("j")||sig.includes("p"),"getDynCaller should only be called with i64 sigs");var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(signature,rawFunction){signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();if(typeof fp!="function"){throwBindingError("unknown function pointer with signature "+signature+": "+rawFunction)}return fp}var UnboundTypeError=undefined;function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function throwUnboundTypeError(message,types){var unboundTypes=[];var seen={};function visit(type){if(seen[type]){return}if(registeredTypes[type]){return}if(typeDependencies[type]){typeDependencies[type].forEach(visit);return}unboundTypes.push(type);seen[type]=true}types.forEach(visit);throw new UnboundTypeError(message+": "+unboundTypes.map(getTypeName).join([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast)}if(downcast){downcast=embind__requireFunction(downcastSignature,downcast)}rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);var legalFunctionName=makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName,function(){throwUnboundTypeError("Cannot construct "+name+" due to unbound types",[baseClassRawType])});whenDependentTypesAreResolved([rawType,rawPointerType,rawConstPointerType],baseClassRawType?[baseClassRawType]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype}else{basePrototype=ClassHandle.prototype}var constructor=createNamedFunction(legalFunctionName,function(){if(Object.getPrototypeOf(this)!==instancePrototype){throw new BindingError("Use 'new' to construct "+name)}if(undefined===registeredClass.constructor_body){throw new BindingError(name+" has no accessible constructor")}var body=registeredClass.constructor_body[arguments.length];if(undefined===body){throw new BindingError("Tried to invoke ctor of "+name+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(registeredClass.constructor_body).toString()+") parameters instead!")}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);var referenceConverter=new RegisteredPointer(name,registeredClass,true,false,false);var pointerConverter=new RegisteredPointer(name+"*",registeredClass,false,false,false);var constPointerConverter=new RegisteredPointer(name+" const*",registeredClass,false,true,false);registeredPointers[rawType]={pointerType:pointerConverter,constPointerType:constPointerConverter};replacePublicSymbol(legalFunctionName,constructor);return[referenceConverter,pointerConverter,constPointerConverter]})}function new_(constructor,argumentList){if(!(constructor instanceof Function)){throw new TypeError("new_ called with constructor type "+typeof constructor+" which is not a function")}var dummy=createNamedFunction(constructor.name||"unknownFunctionName",function(){});dummy.prototype=constructor.prototype;var obj=new dummy;var r=constructor.apply(obj,argumentList);return r instanceof Object?r:obj}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc){var argCount=argTypes.length;if(argCount<2){throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")}var isClassMethodFunc=argTypes[1]!==null&&classType!==null;var needsDestructorStack=false;for(var i=1;i0?", ":"")+argsListWired}invokerFnBody+=(returns?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n"}else{for(var i=isClassMethodFunc?1:2;i>2])}return array}function __embind_register_class_class_function(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,fn){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=classType.name+"."+methodName;function unboundTypesHandler(){throwUnboundTypeError("Cannot call "+humanName+" due to unbound types",rawArgTypes)}if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}var proto=classType.registeredClass.constructor;if(undefined===proto[methodName]){unboundTypesHandler.argCount=argCount-1;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-1]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));var func=craftInvokerFunction(humanName,invokerArgsArray,null,rawInvoker,fn);if(undefined===proto[methodName].overloadTable){func.argCount=argCount-1;proto[methodName]=func}else{proto[methodName].overloadTable[argCount-1]=func}return[]});return[]})}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName="constructor "+classType.name;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError("Cannot register multiple constructors with identical number of parameters ("+(argCount-1)+") for class '"+classType.name+"'! Overload resolution is currently only performed using the parameter count, not actual type info!")}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError("Cannot construct "+classType.name+" due to unbound types",rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})}function __embind_register_class_function(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,context,isPureVirtual){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=classType.name+"."+methodName;if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}if(isPureVirtual){classType.registeredClass.pureVirtualFunctions.push(methodName)}function unboundTypesHandler(){throwUnboundTypeError("Cannot call "+humanName+" due to unbound types",rawArgTypes)}var proto=classType.registeredClass.instancePrototype;var method=proto[methodName];if(undefined===method||undefined===method.overloadTable&&method.className!==classType.name&&method.argCount===argCount-2){unboundTypesHandler.argCount=argCount-2;unboundTypesHandler.className=classType.name;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-2]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){var memberFunction=craftInvokerFunction(humanName,argTypes,classType,rawInvoker,context);if(undefined===proto[methodName].overloadTable){memberFunction.argCount=argCount-2;proto[methodName]=memberFunction}else{proto[methodName].overloadTable[argCount-2]=memberFunction}return[]});return[]})}var emval_free_list=[];var emval_handle_array=[{},{value:undefined},{value:null},{value:true},{value:false}];function __emval_decref(handle){if(handle>4&&0===--emval_handle_array[handle].refcount){emval_handle_array[handle]=undefined;emval_free_list.push(handle)}}function count_emval_handles(){var count=0;for(var i=5;i{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handle_array[handle].value},toHandle:value=>{switch(value){case undefined:return 1;case null:return 2;case true:return 3;case false:return 4;default:{var handle=emval_free_list.length?emval_free_list.pop():emval_handle_array.length;emval_handle_array[handle]={refcount:1,value:value};return handle}}}};function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null})}function embindRepr(v){if(v===null){return"null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else{return""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){if(typeof value!="number"&&typeof value!="boolean"){throw new TypeError('Cannot convert "'+embindRepr(value)+'" to '+this.name)}return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}function __embind_register_function(name,argCount,rawArgTypesAddr,signature,rawInvoker,fn){var argTypes=heap32VectorToArray(argCount,rawArgTypesAddr);name=readLatin1String(name);rawInvoker=embind__requireFunction(signature,rawInvoker);exposePublicSymbol(name,function(){throwUnboundTypeError("Cannot call "+name+" due to unbound types",argTypes)},argCount-1);whenDependentTypesAreResolved([],argTypes,function(argTypes){var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));replacePublicSymbol(name,craftInvokerFunction(name,invokerArgsArray,null,rawInvoker,fn),argCount-1);return[]})}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);if(maxRange===-1){maxRange=4294967295}var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{if(typeof value!="number"&&typeof value!="boolean"){throw new TypeError('Cannot convert "'+embindRepr(value)+'" to '+toTypeName)}if(valuemaxRange){throw new TypeError('Passing a number "'+embindRepr(value)+'" from JS side to C/C++ side to an argument of type "'+name+'", which is outside the valid range ['+minRange+", "+maxRange+"]!")}};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"argPackAdvance":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null})}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(heap.buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true})}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var payload=value+4;var str;if(stdStringIsUTF8){var decodeStartPtr=payload;for(var i=0;i<=length;++i){var currentBytePtr=payload+i;if(i==length||HEAPU8[currentBytePtr]==0){var maxRead=currentBytePtr-decodeStartPtr;var stringSegment=UTF8ToString(decodeStartPtr,maxRead);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}}else{var a=new Array(length);for(var i=0;i>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr,length+1)}else{if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+i]=charCode}}else{for(var i=0;i>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder)return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr));var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit)}return str}function stringToUTF16(str,outPtr,maxBytesToWrite){assert(outPtr%2==0,"Pointer passed to stringToUTF16 must be aligned to two bytes!");assert(typeof maxBytesToWrite=="number","stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(ptr,maxBytesToRead){assert(ptr%4==0,"Pointer passed to UTF32ToString must be aligned to four bytes!");var i=0;var str="";while(!(i>=maxBytesToRead/4)){var utf32=HEAP32[ptr+i*4>>2];if(utf32==0)break;++i;if(utf32>=65536){var ch=utf32-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}else{str+=String.fromCharCode(utf32)}}return str}function stringToUTF32(str,outPtr,maxBytesToWrite){assert(outPtr%4==0,"Pointer passed to stringToUTF32 must be aligned to four bytes!");assert(typeof maxBytesToWrite=="number","stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4}return len}function __embind_register_std_wstring(rawType,charSize,name){name=readLatin1String(name);var decodeString,encodeString,getHeap,lengthBytesUTF,shift;if(charSize===2){decodeString=UTF16ToString;encodeString=stringToUTF16;lengthBytesUTF=lengthBytesUTF16;getHeap=()=>HEAPU16;shift=1}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>HEAPU32;shift=2}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str},"toWireType":function(destructors,value){if(!(typeof value=="string")){throwBindingError("Cannot pass non-string to C++ string type "+name)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr)}})}function __embind_register_value_object(rawType,name,constructorSignature,rawConstructor,destructorSignature,rawDestructor){structRegistrations[rawType]={name:readLatin1String(name),rawConstructor:embind__requireFunction(constructorSignature,rawConstructor),rawDestructor:embind__requireFunction(destructorSignature,rawDestructor),fields:[]}}function __embind_register_value_object_field(structType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext){structRegistrations[structType].fields.push({fieldName:readLatin1String(fieldName),getterReturnType:getterReturnType,getter:embind__requireFunction(getterSignature,getter),getterContext:getterContext,setterArgumentType:setterArgumentType,setter:embind__requireFunction(setterSignature,setter),setterContext:setterContext})}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}})}function __emval_incref(handle){if(handle>4){emval_handle_array[handle].refcount+=1}}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType))}return impl}function __emval_take_value(type,arg){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](arg);return Emval.toHandle(v)}function readI53FromI64(ptr){return HEAPU32[ptr>>2]+HEAP32[ptr+4>>2]*4294967296}function __isLeapYear(year){return year%4===0&&(year%100!==0||year%400===0)}var __MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var __MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];function __yday_from_date(date){var isLeapYear=__isLeapYear(date.getFullYear());var monthDaysCumulative=isLeapYear?__MONTH_DAYS_LEAP_CUMULATIVE:__MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday}function __localtime_js(time,tmPtr){var date=new Date(readI53FromI64(time)*1e3);HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=__yday_from_date(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst}function allocateUTF8(str){var size=lengthBytesUTF8(str)+1;var ret=_malloc(size);if(ret)stringToUTF8Array(str,HEAP8,ret,size);return ret}function __tzset_js(timezone,daylight,tzname){var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);function extractZone(date){var match=date.toTimeString().match(/\(([A-Za-z ]+)\)$/);return match?match[1]:"GMT"}var winterName=extractZone(winter);var summerName=extractZone(summer);var winterNamePtr=allocateUTF8(winterName);var summerNamePtr=allocateUTF8(summerName);if(summerOffset>2]=winterNamePtr;HEAPU32[tzname+4>>2]=summerNamePtr}else{HEAPU32[tzname>>2]=summerNamePtr;HEAPU32[tzname+4>>2]=winterNamePtr}}function _abort(){abort("native code called abort()")}var readEmAsmArgsArray=[];function readEmAsmArgs(sigPtr,buf){assert(Array.isArray(readEmAsmArgsArray));assert(buf%16==0);readEmAsmArgsArray.length=0;var ch;buf>>=2;while(ch=HEAPU8[sigPtr++]){var chr=String.fromCharCode(ch);var validChars=["d","f","i"];assert(validChars.includes(chr),"Invalid character "+ch+'("'+chr+'") in readEmAsmArgs! Use only ['+validChars+'], and do not specify "v" for void return argument.');buf+=ch!=105&buf;readEmAsmArgsArray.push(ch==105?HEAP32[buf]:HEAPF64[buf++>>1]);++buf}return readEmAsmArgsArray}function runEmAsmFunction(code,sigPtr,argbuf){var args=readEmAsmArgs(sigPtr,argbuf);if(!ASM_CONSTS.hasOwnProperty(code))abort("No EM_ASM constant found at address "+code);return ASM_CONSTS[code].apply(null,args)}function _emscripten_asm_const_int(code,sigPtr,argbuf){return runEmAsmFunction(code,sigPtr,argbuf)}function _emscripten_date_now(){return Date.now()}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function getHeapMax(){return 2147483648}function emscripten_realloc_buffer(size){var b=wasmMemory.buffer;try{wasmMemory.grow(size-b.byteLength+65535>>>16);updateMemoryViews();return 1}catch(e){err("emscripten_realloc_buffer: Attempted to grow heap from "+b.byteLength+" bytes to "+size+" bytes, but got error: "+e)}}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;assert(requestedSize>oldSize);var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){err("Cannot enlarge memory, asked to go up to "+requestedSize+" bytes, but the limit is "+maxHeapSize+" bytes!");return false}let alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=emscripten_realloc_buffer(newSize);if(replacement){return true}}err("Failed to grow the heap from "+oldSize+" bytes to "+newSize+" bytes, not enough memory!");return false}var ENV={};function getExecutableName(){return thisProgram||"./this.program"}function getEnvStrings(){if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8";var env={"USER":"web_user","LOGNAME":"web_user","PATH":"/","PWD":"/","HOME":"/home/web_user","LANG":lang,"_":getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(x+"="+env[x])}getEnvStrings.strings=strings}return getEnvStrings.strings}function writeAsciiToMemory(str,buffer,dontAddNull){for(var i=0;i>0]=str.charCodeAt(i)}if(!dontAddNull)HEAP8[buffer>>0]=0}function _environ_get(__environ,environ_buf){var bufSize=0;getEnvStrings().forEach(function(string,i){var ptr=environ_buf+bufSize;HEAPU32[__environ+i*4>>2]=ptr;writeAsciiToMemory(string,ptr);bufSize+=string.length+1});return 0}function _environ_sizes_get(penviron_count,penviron_buf_size){var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(function(string){bufSize+=string.length+1});HEAPU32[penviron_buf_size>>2]=bufSize;return 0}function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _fd_fdstat_get(fd,pbuf){try{var stream=SYSCALLS.getStreamFromFD(fd);var type=stream.tty?2:FS.isDir(stream.mode)?3:FS.isLink(stream.mode)?7:4;HEAP8[pbuf>>0]=type;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function doReadv(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function convertI32PairToI53Checked(lo,hi){assert(lo==lo>>>0||lo==(lo|0));assert(hi===(hi|0));return hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?(Math.min(+Math.floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[newOffset>>2]=tempI64[0],HEAP32[newOffset+4>>2]=tempI64[1];if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function doWritev(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(typeof offset!=="undefined"){offset+=curr}}return ret}function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function getHostByName(name){var ret=_malloc(20);var nameBuf=_malloc(name.length+1);stringToUTF8(name,nameBuf,name.length+1);HEAPU32[ret>>2]=nameBuf;var aliasesBuf=_malloc(4);HEAPU32[aliasesBuf>>2]=0;HEAPU32[ret+4>>2]=aliasesBuf;var afinet=2;HEAP32[ret+8>>2]=afinet;HEAP32[ret+12>>2]=4;var addrListBuf=_malloc(12);HEAPU32[addrListBuf>>2]=addrListBuf+8;HEAPU32[addrListBuf+4>>2]=0;HEAP32[addrListBuf+8>>2]=inetPton4(DNS.lookup_name(name));HEAPU32[ret+16>>2]=addrListBuf;return ret}function _gethostbyname(name){return getHostByName(UTF8ToString(name))}function __arraySum(array,index){var sum=0;for(var i=0;i<=index;sum+=array[i++]){}return sum}var __MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];var __MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];function __addDays(date,days){var newDate=new Date(date.getTime());while(days>0){var leap=__isLeapYear(newDate.getFullYear());var currentMonth=newDate.getMonth();var daysInCurrentMonth=(leap?__MONTH_DAYS_LEAP:__MONTH_DAYS_REGULAR)[currentMonth];if(days>daysInCurrentMonth-newDate.getDate()){days-=daysInCurrentMonth-newDate.getDate()+1;newDate.setDate(1);if(currentMonth<11){newDate.setMonth(currentMonth+1)}else{newDate.setMonth(0);newDate.setFullYear(newDate.getFullYear()+1)}}else{newDate.setDate(newDate.getDate()+days);return newDate}}return newDate}function writeArrayToMemory(array,buffer){assert(array.length>=0,"writeArrayToMemory array must have a length (should be an array or typed array)");HEAP8.set(array,buffer)}function _strftime(s,maxsize,format,tm){var tm_zone=HEAP32[tm+40>>2];var date={tm_sec:HEAP32[tm>>2],tm_min:HEAP32[tm+4>>2],tm_hour:HEAP32[tm+8>>2],tm_mday:HEAP32[tm+12>>2],tm_mon:HEAP32[tm+16>>2],tm_year:HEAP32[tm+20>>2],tm_wday:HEAP32[tm+24>>2],tm_yday:HEAP32[tm+28>>2],tm_isdst:HEAP32[tm+32>>2],tm_gmtoff:HEAP32[tm+36>>2],tm_zone:tm_zone?UTF8ToString(tm_zone):""};var pattern=UTF8ToString(format);var EXPANSION_RULES_1={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y","%X":"%H:%M:%S","%Ec":"%c","%EC":"%C","%Ex":"%m/%d/%y","%EX":"%H:%M:%S","%Ey":"%y","%EY":"%Y","%Od":"%d","%Oe":"%e","%OH":"%H","%OI":"%I","%Om":"%m","%OM":"%M","%OS":"%S","%Ou":"%u","%OU":"%U","%OV":"%V","%Ow":"%w","%OW":"%W","%Oy":"%y"};for(var rule in EXPANSION_RULES_1){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_1[rule])}var WEEKDAYS=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];var MONTHS=["January","February","March","April","May","June","July","August","September","October","November","December"];function leadingSomething(value,digits,character){var str=typeof value=="number"?value.toString():value||"";while(str.length0?1:0}var compare;if((compare=sgn(date1.getFullYear()-date2.getFullYear()))===0){if((compare=sgn(date1.getMonth()-date2.getMonth()))===0){compare=sgn(date1.getDate()-date2.getDate())}}return compare}function getFirstWeekStartDate(janFourth){switch(janFourth.getDay()){case 0:return new Date(janFourth.getFullYear()-1,11,29);case 1:return janFourth;case 2:return new Date(janFourth.getFullYear(),0,3);case 3:return new Date(janFourth.getFullYear(),0,2);case 4:return new Date(janFourth.getFullYear(),0,1);case 5:return new Date(janFourth.getFullYear()-1,11,31);case 6:return new Date(janFourth.getFullYear()-1,11,30)}}function getWeekBasedYear(date){var thisDate=__addDays(new Date(date.tm_year+1900,0,1),date.tm_yday);var janFourthThisYear=new Date(thisDate.getFullYear(),0,4);var janFourthNextYear=new Date(thisDate.getFullYear()+1,0,4);var firstWeekStartThisYear=getFirstWeekStartDate(janFourthThisYear);var firstWeekStartNextYear=getFirstWeekStartDate(janFourthNextYear);if(compareByDay(firstWeekStartThisYear,thisDate)<=0){if(compareByDay(firstWeekStartNextYear,thisDate)<=0){return thisDate.getFullYear()+1}return thisDate.getFullYear()}return thisDate.getFullYear()-1}var EXPANSION_RULES_2={"%a":function(date){return WEEKDAYS[date.tm_wday].substring(0,3)},"%A":function(date){return WEEKDAYS[date.tm_wday]},"%b":function(date){return MONTHS[date.tm_mon].substring(0,3)},"%B":function(date){return MONTHS[date.tm_mon]},"%C":function(date){var year=date.tm_year+1900;return leadingNulls(year/100|0,2)},"%d":function(date){return leadingNulls(date.tm_mday,2)},"%e":function(date){return leadingSomething(date.tm_mday,2," ")},"%g":function(date){return getWeekBasedYear(date).toString().substring(2)},"%G":function(date){return getWeekBasedYear(date)},"%H":function(date){return leadingNulls(date.tm_hour,2)},"%I":function(date){var twelveHour=date.tm_hour;if(twelveHour==0)twelveHour=12;else if(twelveHour>12)twelveHour-=12;return leadingNulls(twelveHour,2)},"%j":function(date){return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900)?__MONTH_DAYS_LEAP:__MONTH_DAYS_REGULAR,date.tm_mon-1),3)},"%m":function(date){return leadingNulls(date.tm_mon+1,2)},"%M":function(date){return leadingNulls(date.tm_min,2)},"%n":function(){return"\n"},"%p":function(date){if(date.tm_hour>=0&&date.tm_hour<12){return"AM"}return"PM"},"%S":function(date){return leadingNulls(date.tm_sec,2)},"%t":function(){return"\t"},"%u":function(date){return date.tm_wday||7},"%U":function(date){var days=date.tm_yday+7-date.tm_wday;return leadingNulls(Math.floor(days/7),2)},"%V":function(date){var val=Math.floor((date.tm_yday+7-(date.tm_wday+6)%7)/7);if((date.tm_wday+371-date.tm_yday-2)%7<=2){val++}if(!val){val=52;var dec31=(date.tm_wday+7-date.tm_yday-1)%7;if(dec31==4||dec31==5&&__isLeapYear(date.tm_year%400-1)){val++}}else if(val==53){var jan1=(date.tm_wday+371-date.tm_yday)%7;if(jan1!=4&&(jan1!=3||!__isLeapYear(date.tm_year)))val=1}return leadingNulls(val,2)},"%w":function(date){return date.tm_wday},"%W":function(date){var days=date.tm_yday+7-(date.tm_wday+6)%7;return leadingNulls(Math.floor(days/7),2)},"%y":function(date){return(date.tm_year+1900).toString().substring(2)},"%Y":function(date){return date.tm_year+1900},"%z":function(date){var off=date.tm_gmtoff;var ahead=off>=0;off=Math.abs(off)/60;off=off/60*100+off%60;return(ahead?"+":"-")+String("0000"+off).slice(-4)},"%Z":function(date){return date.tm_zone},"%%":function(){return"%"}};pattern=pattern.replace(/%%/g,"\0\0");for(var rule in EXPANSION_RULES_2){if(pattern.includes(rule)){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_2[rule](date))}}pattern=pattern.replace(/\0\0/g,"%");var bytes=intArrayFromString(pattern,false);if(bytes.length>maxsize){return 0}writeArrayToMemory(bytes,s);return bytes.length-1}function _strftime_l(s,maxsize,format,tm,loc){return _strftime(s,maxsize,format,tm)}var FSNode=function(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.mounted=null;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.node_ops={};this.stream_ops={};this.rdev=rdev};var readMode=292|73;var writeMode=146;Object.defineProperties(FSNode.prototype,{read:{get:function(){return(this.mode&readMode)===readMode},set:function(val){val?this.mode|=readMode:this.mode&=~readMode}},write:{get:function(){return(this.mode&writeMode)===writeMode},set:function(val){val?this.mode|=writeMode:this.mode&=~writeMode}},isFolder:{get:function(){return FS.isDir(this.mode)}},isDevice:{get:function(){return FS.isChrdev(this.mode)}}});FS.FSNode=FSNode;FS.staticInit();Module["FS_createPath"]=FS.createPath;Module["FS_createDataFile"]=FS.createDataFile;Module["FS_createPreloadedFile"]=FS.createPreloadedFile;Module["FS_unlink"]=FS.unlink;Module["FS_createLazyFile"]=FS.createLazyFile;Module["FS_createDevice"]=FS.createDevice;ERRNO_CODES={"EPERM":63,"ENOENT":44,"ESRCH":71,"EINTR":27,"EIO":29,"ENXIO":60,"E2BIG":1,"ENOEXEC":45,"EBADF":8,"ECHILD":12,"EAGAIN":6,"EWOULDBLOCK":6,"ENOMEM":48,"EACCES":2,"EFAULT":21,"ENOTBLK":105,"EBUSY":10,"EEXIST":20,"EXDEV":75,"ENODEV":43,"ENOTDIR":54,"EISDIR":31,"EINVAL":28,"ENFILE":41,"EMFILE":33,"ENOTTY":59,"ETXTBSY":74,"EFBIG":22,"ENOSPC":51,"ESPIPE":70,"EROFS":69,"EMLINK":34,"EPIPE":64,"EDOM":18,"ERANGE":68,"ENOMSG":49,"EIDRM":24,"ECHRNG":106,"EL2NSYNC":156,"EL3HLT":107,"EL3RST":108,"ELNRNG":109,"EUNATCH":110,"ENOCSI":111,"EL2HLT":112,"EDEADLK":16,"ENOLCK":46,"EBADE":113,"EBADR":114,"EXFULL":115,"ENOANO":104,"EBADRQC":103,"EBADSLT":102,"EDEADLOCK":16,"EBFONT":101,"ENOSTR":100,"ENODATA":116,"ETIME":117,"ENOSR":118,"ENONET":119,"ENOPKG":120,"EREMOTE":121,"ENOLINK":47,"EADV":122,"ESRMNT":123,"ECOMM":124,"EPROTO":65,"EMULTIHOP":36,"EDOTDOT":125,"EBADMSG":9,"ENOTUNIQ":126,"EBADFD":127,"EREMCHG":128,"ELIBACC":129,"ELIBBAD":130,"ELIBSCN":131,"ELIBMAX":132,"ELIBEXEC":133,"ENOSYS":52,"ENOTEMPTY":55,"ENAMETOOLONG":37,"ELOOP":32,"EOPNOTSUPP":138,"EPFNOSUPPORT":139,"ECONNRESET":15,"ENOBUFS":42,"EAFNOSUPPORT":5,"EPROTOTYPE":67,"ENOTSOCK":57,"ENOPROTOOPT":50,"ESHUTDOWN":140,"ECONNREFUSED":14,"EADDRINUSE":3,"ECONNABORTED":13,"ENETUNREACH":40,"ENETDOWN":38,"ETIMEDOUT":73,"EHOSTDOWN":142,"EHOSTUNREACH":23,"EINPROGRESS":26,"EALREADY":7,"EDESTADDRREQ":17,"EMSGSIZE":35,"EPROTONOSUPPORT":66,"ESOCKTNOSUPPORT":137,"EADDRNOTAVAIL":4,"ENETRESET":39,"EISCONN":30,"ENOTCONN":53,"ETOOMANYREFS":141,"EUSERS":136,"EDQUOT":19,"ESTALE":72,"ENOTSUP":138,"ENOMEDIUM":148,"EILSEQ":25,"EOVERFLOW":61,"ECANCELED":11,"ENOTRECOVERABLE":56,"EOWNERDEAD":62,"ESTRPIPE":135};InternalError=Module["InternalError"]=extendError(Error,"InternalError");embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");init_ClassHandle();init_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();var decodeBase64=typeof atob=="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2)}if(enc4!==64){output=output+String.fromCharCode(chr3)}}while(i0){return}stackCheckInit();preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();assert(!Module["_main"],'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}checkStackCookie()}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run(); + + + return FaustModule.ready +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = FaustModule; +else if (typeof define === 'function' && define['amd']) + define([], function() { return FaustModule; }); +else if (typeof exports === 'object') + exports["FaustModule"] = FaustModule; diff --git a/dist/faustwasm/libfaust-wasm.wasm b/dist/faustwasm/libfaust-wasm.wasm new file mode 100644 index 00000000..7ad889da Binary files /dev/null and b/dist/faustwasm/libfaust-wasm.wasm differ diff --git a/dist/faustwasm/libfaust-wasm.wasm.d.ts b/dist/faustwasm/libfaust-wasm.wasm.d.ts new file mode 100644 index 00000000..11303181 --- /dev/null +++ b/dist/faustwasm/libfaust-wasm.wasm.d.ts @@ -0,0 +1,2 @@ +declare const data: Uint8Array; +export default data; \ No newline at end of file diff --git a/dist/favicon.png b/dist/favicon.png new file mode 100644 index 00000000..a83a3597 Binary files /dev/null and b/dist/favicon.png differ diff --git a/dist/icon/icon_192.png b/dist/icon/icon_192.png new file mode 100644 index 00000000..70d0d6ce Binary files /dev/null and b/dist/icon/icon_192.png differ diff --git a/dist/icon/icon_512.png b/dist/icon/icon_512.png new file mode 100644 index 00000000..9958dc61 Binary files /dev/null and b/dist/icon/icon_512.png differ diff --git a/dist/index.html b/dist/index.html new file mode 100644 index 00000000..07ac0934 --- /dev/null +++ b/dist/index.html @@ -0,0 +1,721 @@ + + + + + + + + + + + + Faust IDE + + + + + +
+
+
+
+ +
+
+
+ Poly Voices +
+ +
+
+
+ Buffer Size +
+ +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
+ +
+
+ Mode +
+ +
+
+
+ Samples +
+ +
+
+
+ Sample Rate +
+ +
+
+
+ FFT Size +
+ +
+
+
+ FFT Overlap +
+ +
+
+ + +
+ +
+
+ +
+ + +
+
+ + +
+
+
+ FFT Size +
+ +
+
+
+ FFT Overlap +
+ +
+
+
+ WinFunc +
+ +
+
+
+
+
+ +
+
+
+
+
+
+
+
+ +
+
+ +
+
+
+ + +
+
+ + +
+
+
+ +
+ +
+ +
+ +
+
+
+ + +
+ + + +
+ + + diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 00000000..284361e2 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,263576 @@ +/******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ "./src/Analyser.ts": +/*!*************************!*\ + !*** ./src/Analyser.ts ***! + \*************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Analyser: () => (/* binding */ Analyser) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); +/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/utils.ts"); + + + +/** + * This class provides a default handler for a buffer given by Faust2WebAudio. + * The handler analyses the buffer with FFT, then saves both time-domain and frequency-domain data. + * After each buffer is analysed, a drawHandler is called to display data. + */ +class Analyser { + constructor(FFTR, buffers, drawMode, drawHandler) { + /** + * KissFFT FFTR Constructor + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "FFTR", void 0); + /** + * Time Domain Data + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "t", void 0); + /** + * Frequency Domain Data, overlap x2 gives same length as t + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "f", void 0); + /** + * Events stored + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "e", void 0); + /** + * Buffer count in t & f + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "buffers", void 0); + /** + * current buffer index of dsp, used for events + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "$buffer", void 0); + /** + * current sample as index in t & f to draw + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "$", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_drawMode", void 0); + /** + * In on event mode, buffers count remaining to draw + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "capturing", void 0); + /** + * KissFFT instance + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_fft", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_fftSize", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_fftOverlap", void 0); + /** + * This function property can be overwritten, will be called after each buffer received. + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "drawHandler", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "freqEstimated", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "plotHandler", (t, index, events, drawOffline) => { + if (!t.length) return; + if (this.drawMode === "offline" && !drawOffline) return; + if (drawOffline) { + this.$ = 0; + this.e = []; + } + var channels = t.length; + var bufferSize = t[0].length; + this.initCache(bufferSize, channels); + this.$ = index % this.buffers * bufferSize; + this.$buffer = index; + var $ = this.$, + fftSize = this.fftSize, + fftOverlap = this.fftOverlap, + fftHopSize = this.fftHopSize, + fftBins = this.fftBins, + fft = this.fft; + t.forEach((a, i) => { + this.t[i].set(a, $); + var fData; + for (var $fftEnd = $ + bufferSize - ($ + bufferSize) % fftHopSize; $fftEnd > $; $fftEnd -= fftHopSize) { + var $fft = $fftEnd - fftSize; + var t4fft = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.sliceWrap)(this.t[i], $fft, fftSize); + fData = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.getFrequencyDomainData)(t4fft, fft); + (0,_utils__WEBPACK_IMPORTED_MODULE_1__.setWrap)(this.f[i], fData, $fftEnd * fftOverlap / 2 - fftBins); + } + if (fData) this.freqEstimated = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.estimateFreq)(fData, this.sampleRate); + }); + this.e[index] = events || []; + delete this.e[index - this.buffers - 1]; + if (this.drawMode === "onevent") { + if (events && events.length && this.capturing === -1) this.capturing = this.buffers - 1; + if (this.capturing >= 0) this.capturing--; + if (this.capturing !== -1 || events && events.length) this.draw(); + } else if (this.drawMode === "manual") { + if (index === this.buffers - 1) this.draw(); + } else this.draw(); + }); + /** + * The function property can be overwritten to get the sampleRate differently. + * + * @memberof Analyser + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "getSampleRate", () => 48000); + this.FFTR = FFTR; + this.buffers = buffers || 0; + this.drawMode = drawMode || "manual"; + this.drawHandler = drawHandler; + this._fftOverlap = 2; + this.capturing = -1; + this.fftSize = 256; + } + initCache(bufferSize, channels) { + var buffers = this.drawMode === "offline" ? 1 : this.buffers; + if (this.t && this.t.length === channels && this.t[0].length === bufferSize * buffers) return; + this.t = new Array(channels).fill(null).map(() => new Float32Array(bufferSize * buffers)); + this.f = new Array(channels).fill(null).map(() => new Float32Array(bufferSize * buffers * this.fftOverlap / 2).fill(-Infinity)); + this.$ = 0; + this.e = []; + } + draw() { + var t = this.t, + f = this.f, + e = this.e, + drawHandler = this.drawHandler, + drawMode = this.drawMode, + fftSize = this.fftSize, + fftOverlap = this.fftOverlap, + freqEstimated = this.freqEstimated, + sampleRate = this.sampleRate; + if (!drawHandler) return; + if (!t || !t.length) return; + if (drawMode === "offline") { + drawHandler({ + $: 0, + $buffer: 0, + bufferSize: t[0].length, + drawMode, + fftSize, + fftOverlap, + freqEstimated, + sampleRate, + t, + f, + e + }); + return; + } + var bufferSize = this.t[0].length / this.buffers; + var $ = (this.$ + bufferSize) % this.t[0].length; + var $buffer = this.$buffer + 1 - this.buffers; + if (this.drawMode === "continuous" || this.capturing > 0) this.drawHandler({ + $, + $buffer, + bufferSize, + drawMode, + fftSize, + fftOverlap, + freqEstimated, + sampleRate, + t, + f, + e + });else this.drawHandler({ + $, + $buffer, + bufferSize, + drawMode, + fftSize, + fftOverlap, + freqEstimated, + sampleRate, + t: this.t.map(a => a.slice()), + f: this.f.map(a => a.slice()), + e: this.e.slice() + }); + } + get sampleRate() { + return this.getSampleRate(); + } + get drawMode() { + return this._drawMode; + } + set drawMode(modeIn) { + this._drawMode = modeIn; + this.draw(); + } + get fft() { + return this._fft; + } + get fftSize() { + return this._fftSize; + } + set fftSize(fftSizeIn) { + this._fftSize = fftSizeIn; + if (this.fft) this.fft.dispose(); + this._fft = new this.FFTR(fftSizeIn); + } + get fftOverlap() { + return this._fftOverlap; + } + set fftOverlap(fftOverlapIn) { + if (this._fftOverlap === fftOverlapIn) return; + this._fftOverlap = fftOverlapIn; + if (!this.t || !this.t.length || !this.t[0].length) return; + this.f = new Array(this.t.length).fill(null).map(() => new Float32Array(this.t[0].length * this.fftOverlap / 2).fill(-Infinity)); + } + get fftHopSize() { + return this.fftSize / this.fftOverlap; + } + get fftBins() { + return this.fftSize / 2; + } +} + +/***/ }), + +/***/ "./src/FFTUtils.ts": +/*!*************************!*\ + !*** ./src/FFTUtils.ts ***! + \*************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ FFTUtils: () => (/* binding */ FFTUtils) +/* harmony export */ }); +var FFTUtils = class { + static get windowFunctions() { + return [ + // hamming + (i, N) => 0.54 - 0.46 * Math.cos(6.283185307179586 * i / (N - 1)), + // hann + (i, N) => 0.5 * (1 - Math.cos(6.283185307179586 * i / (N - 1))), + // blackman + (i, N) => { + var a0 = 0.42; + var a1 = 0.5; + var a2 = 0.08; + var f = 6.283185307179586 * i / (N - 1); + return a0 - a1 * Math.cos(f) + a2 * Math.cos(2 * f); + }, + // triangular + (i, N) => 1 - Math.abs(2 * (i - 0.5 * (N - 1)) / N)]; + } + static getFFT() { + // eslint-disable-next-line + var _kissfftwasm = globalThis.kissfftwasm, + instantiateKissFFTModule = _kissfftwasm.instantiateKissFFTModule, + KissFFT = _kissfftwasm.KissFFT; + return instantiateKissFFTModule().then(Module => new KissFFT(Module).FFTR); + } + static fftToSignal(f, r, i, b) { + var fftSize = f.length - 2; + var len = fftSize / 2 + 1; + var invFFTSize = 1 / fftSize; + for (var j = 0; j < len; j++) { + r[j] = f[2 * j] * invFFTSize; + if (i) i[j] = f[2 * j + 1] * invFFTSize; + if (b) b[j] = j; + } + } + static signalToFFT(r, i, f) { + for (var j = 0; j < r.length; j++) { + f[2 * j] = r[j]; + f[2 * j + 1] = i[j]; + } + } + static signalToNoFFT(r, i, f) { + f.set(r.subarray(1, r.length)); + f.set(i.subarray(0, i.length - 1), r.length - 1); + } +}; + +/***/ }), + +/***/ "./src/FileManager.ts": +/*!****************************!*\ + !*** ./src/FileManager.ts ***! + \****************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ FileManager: () => (/* binding */ FileManager) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); +/* harmony import */ var _FileManager_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./FileManager.scss */ "./src/FileManager.scss"); + + +/** + * FileManager UI, interactive with Emscripten Virtual File System + * + * @export + * @class FileManager + */ +class FileManager { + constructor(options) { + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "divLabel", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnExpand", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "spanLabel", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnNewFile", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "divFiles", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "divOverlay", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "container", void 0); + /** + * Root path in Emscripten FS + * + * @type {string} + * @memberof FileManager + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "path", "./"); + /** + * Index of main DSP to execute + * + * @type {number} + * @memberof FileManager + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "$mainFile", 0); + /** + * Project files list + * + * @type {string[]} + * @memberof FileManager + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_fileList", void 0); + /** + * File System reference + * + * @private + * @type {TFileSystem} + * @memberof FileManager + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_fs", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "selectHandler", () => undefined); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "saveHandler", () => undefined); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "deleteHandler", () => undefined); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "mainFileChangeHandler", () => undefined); + this.container = options.container; + this.fs = options.fs; + this.path = options.path; + this.$mainFile = options.$mainFile; + this.selectHandler = options.selectHandler; + this.saveHandler = options.saveHandler; + this.deleteHandler = options.deleteHandler; + this.mainFileChangeHandler = options.mainFileChangeHandler; + this.getChildren(); + this.getFiles(); + this.bind(); + if (options.$mainFile < this._fileList.length) { + this.select(this._fileList[options.$mainFile]); + } + } + getChildren() { + for (var i = 0; i < this.container.children.length; i++) { + var e = this.container.children[i]; + if (e.classList.contains("filemanager-label")) this.divLabel = e; + if (e.classList.contains("filemanager-files")) this.divFiles = e; + if (e.classList.contains("filemanager-overlay")) this.divOverlay = e; + } + if (!this.divLabel) { + var divLabel = document.createElement("div"); + divLabel.classList.add("filemanager-label"); + this.container.appendChild(divLabel); + this.divLabel = divLabel; + } + for (var _i = 0; _i < this.divLabel.children.length; _i++) { + var _e = this.divLabel.children[_i]; + if (_e.classList.contains("filemanager-btn-expand")) this.btnExpand = _e; + if (_e.classList.contains("filemanager-span-label")) this.btnNewFile = _e; + if (_e.classList.contains("filemanager-btn-new-file")) this.btnNewFile = _e; + } + if (!this.btnExpand) { + var btnExpand = document.createElement("button"); + btnExpand.classList.add("filemanager-btn-expand", "filemanager-btn-icon", "expanded"); + this.divLabel.appendChild(btnExpand); + this.btnExpand = btnExpand; + } + if (!this.spanLabel) { + var spanLabel = document.createElement("span"); + spanLabel.classList.add("filemanager-span-label"); + spanLabel.innerText = "Project Files"; + this.divLabel.appendChild(spanLabel); + this.spanLabel = spanLabel; + } + if (!this.btnNewFile) { + var btnNewFile = document.createElement("button"); + btnNewFile.classList.add("filemanager-btn-new-file", "filemanager-btn-icon"); + btnNewFile.title = "New File"; + this.divLabel.appendChild(btnNewFile); + this.btnNewFile = btnNewFile; + } + if (!this.divFiles) { + var divFiles = document.createElement("div"); + divFiles.classList.add("filemanager-files"); + this.container.appendChild(divFiles); + this.divFiles = divFiles; + } + if (!this.divOverlay) { + var divOverlap = document.createElement("div"); + divOverlap.classList.add("filemanager-overlay"); + this.container.appendChild(divOverlap); + this.divOverlay = divOverlap; + } + } + bind() { + this.divLabel.addEventListener("click", () => { + this.expanded = !this.expanded; // File Manager UI can be folded. + }); + /** + * create a new file with name `untitled\d*.dsp`, + * Select the filename as editing + * + * @param {MouseEvent} e + */ + var newFileHandler = e => { + e.stopPropagation(); + e.preventDefault(); + var i = 1; + var fileName = "untitled".concat(i, ".dsp"); + while (this._fileList.indexOf(fileName) !== -1) { + fileName = "untitled".concat(++i, ".dsp"); + } + this.fs.writeFile(this.path + fileName, ""); + this._fileList.push(fileName); + var divFile = this.createFileDiv(fileName, true); + this.divFiles.appendChild(divFile); + if (this.saveHandler) this.saveHandler(fileName, "", this.mainCode); + this.select(fileName); + if (fileName.endsWith(".dsp")) this.setMain(this._fileList.length - 1); + var spanName = divFile.getElementsByClassName("filemanager-filename")[0]; + spanName.focus(); + var range = document.createRange(); + range.selectNodeContents(spanName); + var sel = window.getSelection(); + sel.removeAllRanges(); + sel.addRange(range); + }; + this.btnNewFile.addEventListener("click", newFileHandler); + // File drag and drop + var dragenterHandler = e => { + if (e.dataTransfer && e.dataTransfer.items.length && e.dataTransfer.items[0].kind === "file") { + e.preventDefault(); + e.stopPropagation(); + this.divOverlay.style.display = "block"; + } + }; + var dragendHandler = e => { + e.preventDefault(); + e.stopPropagation(); + this.divOverlay.style.display = ""; + }; + var dragoverHandler = e => { + e.preventDefault(); + e.stopPropagation(); + }; + /** + * Drop a new file into file manager + * if the filename exists or has illegal name, replace it by `untitled\d*.dsp` + * + * @param {DragEvent} e + */ + var dropHandler = e => { + this.divOverlay.style.display = ""; + if (e.dataTransfer && e.dataTransfer.files.length) { + e.preventDefault(); + e.stopPropagation(); + var file = e.dataTransfer.files[0]; + var reader = new FileReader(); + reader.onload = () => { + var fileName = this.newFile(file.name, reader.result.toString()); + this.select(fileName); + }; + reader.onerror = () => undefined; + reader.readAsText(file); + } + }; + this.container.addEventListener("dragenter", dragenterHandler); + this.container.addEventListener("dragover", dragenterHandler); + this.divOverlay.addEventListener("dragenter", dragoverHandler); + this.divOverlay.addEventListener("dragover", dragoverHandler); + this.divOverlay.addEventListener("dragleave", dragendHandler); + this.divOverlay.addEventListener("dragend", dragendHandler); + this.divOverlay.addEventListener("drop", dropHandler); + } + /** + * create a new file container with buttons + * + * @param {string} name + * @param {boolean} [editing] + * @returns + * @memberof FileManager + */ + createFileDiv(name, editing) { + var divFile = document.createElement("div"); + divFile.classList.add("filemanager-file"); + var spanName = document.createElement("span"); + spanName.classList.add("filemanager-filename"); + spanName.innerText = name; + divFile.dataset.filename = name; + if (editing) spanName.contentEditable = "true"; + var btnMain = document.createElement("button"); + btnMain.classList.add("filemanager-btn-main", "filemanager-btn-icon"); + btnMain.title = "Set as main DSP"; + var btnRename = document.createElement("button"); + btnRename.classList.add("filemanager-btn-rename", "filemanager-btn-icon"); + btnRename.title = "Rename"; + var btnDelete = document.createElement("button"); + btnDelete.classList.add("filemanager-btn-delete", "filemanager-btn-icon"); + btnDelete.title = "Delete"; + divFile.appendChild(btnMain); + divFile.appendChild(spanName); + divFile.appendChild(btnRename); + divFile.appendChild(btnDelete); + var fileName = spanName.innerText; + btnRename.addEventListener("click", e => { + e.stopPropagation(); + spanName.contentEditable = "true"; + spanName.focus(); + var range = document.createRange(); + range.selectNodeContents(spanName); + var sel = window.getSelection(); + sel.removeAllRanges(); + sel.addRange(range); + }); + spanName.addEventListener("blur", e => { + var newName = e.currentTarget.innerText.replace(/[^a-zA-Z0-9_.]/g, "") || "untitled.dsp"; + e.currentTarget.innerText = newName; + if (this.rename(fileName, newName)) fileName = newName; + e.currentTarget.contentEditable = "false"; + }); + spanName.addEventListener("keydown", e => { + e.stopPropagation(); + if (e.key === "Enter") e.currentTarget.blur(); + if (e.key.match(/[^a-zA-Z0-9_.]/)) e.preventDefault(); + }); + btnMain.addEventListener("mousedown", () => this.setMain(this._fileList.indexOf(fileName))); + btnMain.addEventListener("touchstart", () => this.setMain(this._fileList.indexOf(fileName))); + btnDelete.addEventListener("click", e => { + e.stopPropagation(); + var i = this._fileList.indexOf(fileName); + this.fs.unlink(this.path + fileName); + this._fileList.splice(i, 1); + divFile.remove(); + if (this.deleteHandler) this.deleteHandler(fileName, this.mainCode); + if (this._fileList.length === 0) { + var _fileName = this.newFile("untitled.dsp", "import(\"stdfaust.lib\");\nprocess = ba.pulsen(1, 10000) : pm.djembe(60, 0.3, 0.4, 1) <: dm.freeverb_demo;"); + this.select(_fileName); + } else { + this.select(this._fileList[0]); + } + if (this.$mainFile >= this._fileList.length) this.setMain(this._fileList.length - 1);else this.setMain(this.$mainFile); + }); + var handlePointerDown = () => this.select(fileName); + divFile.addEventListener("mousedown", handlePointerDown); + divFile.addEventListener("touchstart", handlePointerDown); + return divFile; + } + /** + * Change main DSP file with index in file list. + * + * @param {number} $ + * @returns + * @memberof FileManager + */ + setMain($) { + if ($ >= this._fileList.length) return; + this.$mainFile = $; + for (var i = 0; i < this.divFiles.children.length; i++) { + var e = this.divFiles.children[i]; + var btnMain = e.querySelector(".filemanager-btn-main"); + if (btnMain) { + if (i === $) btnMain.classList.add("active");else btnMain.classList.remove("active"); + } + } + if (this.mainFileChangeHandler) this.mainFileChangeHandler($, this.mainCode); + } + /** + * Get files from Emscripten Virtual File System. + * + * @memberof FileManager + */ + getFiles() { + this.divFiles.innerHTML = ""; + this._fileList = this.fs.readdir(this.path).filter(fileName => fileName !== "." && fileName !== ".." && this.fs.isFile(this.fs.stat(this.path + fileName).mode)); + this._fileList.forEach(fileName => { + var divFile = this.createFileDiv(fileName, false); + this.divFiles.appendChild(divFile); + }); + if (this._fileList.length === 0) { + var fileName = this.newFile("untitled.dsp", "import(\"stdfaust.lib\");\nprocess = ba.pulsen(1, 10000) : pm.djembe(60, 0.3, 0.4, 1) <: dm.freeverb_demo;"); + this.select(fileName); + } else { + this.select(this._fileList[0]); + } + if (this.$mainFile >= this._fileList.length) this.setMain(this._fileList.length - 1);else this.setMain(this.$mainFile); + } + rename(oldName, newName) { + if (oldName === newName) return false; + var i = this._fileList.indexOf(oldName); + var spanName; + var divFile; + for (var _i2 = 0; _i2 < this.divFiles.children.length; _i2++) { + var file = this.divFiles.children[_i2]; + if (file.dataset.filename === oldName) { + divFile = file; + spanName = file.getElementsByClassName("filemanager-filename")[0]; + break; + } + } + if (!divFile || !spanName) return false; + try { + this.fs.rename(this.path + oldName, this.path + newName); + } catch (e) { + spanName.focus(); + return false; + } + this._fileList[i] = newName; + spanName.innerText = newName; + spanName.contentEditable = "false"; + divFile.dataset.filename = newName; + if (this.saveHandler) this.saveHandler(newName, this.getValue(newName), this.mainCode); + this.select(newName); + this.deleteHandler(oldName, this.mainCode); + return true; + } + renameSelected(newName) { + this.rename(this.selected, newName); + } + newFile(fileNameIn, content) { + var fileName; + if (fileNameIn) fileName = fileNameIn.replace(/[^a-zA-Z0-9_.]/g, ""); + var extension = fileNameIn ? fileNameIn.split(".").slice(-1) || "lib" : "dsp"; + if (!fileName || this._fileList.indexOf(fileName) !== -1) { + var i = 1; + fileName = "untitled".concat(i, ".").concat(extension); + while (this._fileList.indexOf(fileName) !== -1) { + fileName = "untitled".concat(++i, ".").concat(extension); + } + } + this.fs.writeFile(this.path + fileName, content || ""); + this._fileList.push(fileName); + var divFile = this.createFileDiv(fileName, false); + this.divFiles.appendChild(divFile); + if (this.saveHandler) this.saveHandler(fileName, content || "", this.mainCode); + this.select(fileName); + if (fileName.endsWith(".dsp")) this.setMain(this._fileList.length - 1); + return fileName; + } + select(fileName) { + for (var i = 0; i < this.divFiles.children.length; i++) { + var divFile = this.divFiles.children[i]; + if (divFile.dataset.filename === fileName) divFile.classList.add("selected");else divFile.classList.remove("selected"); + } + if (this.selectHandler) this.selectHandler(fileName, this.fs.readFile(this.path + fileName, { + encoding: "utf8" + }), this.mainCode); + } + save(fileName, content) { + if (this.getValue(fileName) === content) return; + this.fs.writeFile(this.path + fileName, content); + if (this.saveHandler) this.saveHandler(fileName, content, this.mainCode); + } + saveAll() { + if (!this.saveHandler) return; + this._fileList.forEach(fileName => { + var content = this.getValue(fileName); + if (this.selectHandler && content) this.saveHandler(fileName, content, this.mainCode); + }); + } + setValue(value, useSelectHandler) { + var fileName = this.selected; + if (fileName) { + if (this.selectHandler && useSelectHandler !== false) this.selectHandler(fileName, value, this.mainCode); + this.save(fileName, value); + } + } + getValue(fileNameIn) { + var fileName = fileNameIn || this.selected; + return this.fs.readFile(this.path + fileName, { + encoding: "utf8" + }); + } + get selected() { + for (var i = 0; i < this.divFiles.children.length; i++) { + var divFile = this.divFiles.children[i]; + if (divFile.classList.contains("selected")) return divFile.dataset.filename; + } + return null; + } + get mainCode() { + var fileName = this._fileList[this.$mainFile]; + return fileName ? this.getValue(fileName) || "" : ""; + } + get mainFileName() { + return this._fileList[this.$mainFile]; + } + get mainFileNameWithoutSuffix() { + return this._fileList[this.$mainFile].split(".").slice(0, -1).join("."); + } + get allCodes() { + var codes = ""; + this._fileList.forEach(fileName => codes += (this.getValue(fileName) || "") + "\n"); + return codes; + } + get selectedCode() { + var selected = this.selected; + if (selected) return this.getValue(selected); + return this.mainCode; + } + set expanded(expanded) { + if (expanded) { + if (!this.btnExpand.classList.contains("expanded")) { + this.btnExpand.classList.add("expanded"); + this.divFiles.style.display = ""; + } + } else if (this.btnExpand.classList.contains("expanded")) { + this.btnExpand.classList.remove("expanded"); + this.divFiles.style.display = "none"; + } + } + get expanded() { + return this.btnExpand.classList.contains("expanded"); + } + get fs() { + return this._fs; + } + set fs(fsIn) { + this._fs = fsIn; + } +} + +/***/ }), + +/***/ "./src/Key2Midi.ts": +/*!*************************!*\ + !*** ./src/Key2Midi.ts ***! + \*************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Key2Midi: () => (/* binding */ Key2Midi) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); + +/** + * Keyboard Events to Midi Messages + * + * @class Key2Midi + */ +class Key2Midi { + /** + * Creates an instance of Key2Midi. + * @param {{ keyMap?: TKeyMap, offset?: number, velocity?: number, handler?: (msg: number[]) => any, enabled?: boolean }} [options] + * @memberof Key2Midi + */ + constructor(options) { + /** + * Current key map + * + * @type {TKeyMap} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "keyMap", void 0); + /** + * Current offset + * + * @type {number} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "offset", void 0); + /** + * Current velocity + * + * @type {number} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "velocity", void 0); + /** + * Current velocity map + * + * @type {number[]} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "velMap", []); + /** + * Handler for midi message output + * + * @type {(msg: number[]) => any} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handler", void 0); + /** + * Enable State + * + * @type {boolean} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "enabled", void 0); + /** + * KeyDown Handler + * + * @param {string} str + * @returns {void} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleKeyDown", str => { + if (!this.enabled) return; + var converted = this.keyMap[str]; + if (typeof converted === "undefined") return; + if (typeof converted === "number") { + var note = converted + this.offset; + if (this.velMap[note]) return; + this.velMap[note] = this.velocity; + this.handler([144, converted + this.offset, this.velocity]); + return; + } + if (converted === "NEXT") { + this.flush(); + this.offset = Math.min(120, this.offset + 12); + return; + } + if (converted === "PREV") { + this.flush(); + this.offset = Math.max(0, this.offset - 12); + return; + } + if (converted === "VELUP") { + this.velocity = Math.min(120, this.velocity + 20); + return; + } + if (converted === "VELDOWN") { + this.velocity = Math.max(20, this.velocity - 20); + } + }); + /** + * KeyUp Handler + * + * @param {string} str + * @returns {void} + * @memberof Key2Midi + */ + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleKeyUp", str => { + if (!this.enabled) return; + var converted = this.keyMap[str]; + if (typeof converted === "undefined") return; + if (typeof converted === "number") { + var note = converted + this.offset; + this.velMap[note] = 0; + this.handler([144, converted + this.offset, 0]); + } + }); + this.keyMap = options.keyMap || Key2Midi.KEY_MAP; + this.offset = options.offset || 36; + this.velocity = options.velocity || 60; + this.handler = options.handler || (() => undefined); + this.enabled = options.enabled || false && 0; + } + /** + * Mute All + * + * @returns {void} + * @memberof Key2Midi + */ + flush() { + if (!this.enabled) return; + for (var note = 0; note < 128; note++) { + if (this.velMap[note]) this.handler([144, note, 0]); + } + } +} +/** + * Default Key Map use for key2midi + * + * @type {TKeyMap} + * @static + * @memberof Key2Midi + */ +(0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(Key2Midi, "KEY_MAP", { + a: 0, + w: 1, + s: 2, + e: 3, + d: 4, + f: 5, + t: 6, + g: 7, + y: 8, + h: 9, + u: 10, + j: 11, + k: 12, + o: 13, + l: 14, + p: 15, + ";": 16, + z: "PREV", + x: "NEXT", + c: "VELDOWN", + v: "VELUP" +}); +(0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(Key2Midi, "KEY_MAP_FR", { + q: 0, + z: 1, + s: 2, + e: 3, + d: 4, + f: 5, + t: 6, + g: 7, + y: 8, + h: 9, + u: 10, + j: 11, + k: 12, + o: 13, + l: 14, + p: 15, + m: 16, + w: "PREV", + x: "NEXT", + c: "VELDOWN", + v: "VELUP" +}); + + +/***/ }), + +/***/ "./src/MeterNode.ts": +/*!**************************!*\ + !*** ./src/MeterNode.ts ***! + \**************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ GainUI: () => (/* binding */ GainUI), +/* harmony export */ createMeterNode: () => (/* binding */ createMeterNode) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); + +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +/** + * Returns a ScriptProcessor that measures the RMSs of each channel in a buffer. + * The processor calls a `levelHandler` callback after calculating each buffer. + * + * @param {AudioContext} audioCtx + * @param {number} [gain] + * @param {number} [averaging] + * @param {(gains: number[]) => any} [gainHandler] + * @returns {MeterNode} + */ +var createMeterNode = (audioCtx, gain, averaging, gainHandler) => { + var node = audioCtx.createScriptProcessor(512, 8, 8); + node.levelHandler = gainHandler; + node.averaging = averaging || 0.95; + node.gain = gain || 1; + node.onaudioprocess = e => { + var levels = []; + var input = e.inputBuffer; + var output = e.outputBuffer; + for (var i = 0; i < input.numberOfChannels; i++) { + var inputBuffer = input.getChannelData(i); + var outputBuffer = output.getChannelData(i); + var l = inputBuffer.length; + var sum = 0; + for (var j = 0; j < l; j++) { + var samp = inputBuffer[j]; + outputBuffer[j] = samp; + sum += samp * samp; + } + levels.push(Math.pow(sum / l, 0.5)); + } + if (node.levelHandler) node.levelHandler(levels); + }; + return node; +}; +/** + * A Live-like meter UI with a gain controller. + * Range from -70dB to +10dB, linear in dB unit. + * Needs a MeterNode described above + * and a WebAudio GainNode to get the gain controller functional. + * + * @export + * @class GainUI + */ +class GainUI { + constructor(container, meterNode, gainNode, state) { + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "state", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "meterNode", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "gainNode", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "container", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "canvas", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "ctx", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "channels", 2); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "interactionRect", [0, 0, 0, 0]); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "$raf", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "$frame", 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "frameReduce", 3); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "paintLevels", [-Infinity]); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "maxLevels", [-Infinity]); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "maxTimer", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleTouchStart", e => { + e.preventDefault(); + var rect = e.currentTarget.getBoundingClientRect(); + var prevX = e.touches[0].pageX; + var prevY = e.touches[0].pageY; + var fromX = prevX - rect.left; + var fromY = prevY - rect.top; + var prevValue = this.value; + this.handlePointerDown({ + x: fromX, + y: fromY, + originalEvent: e + }); + var handleTouchMove = e => { + e.preventDefault(); + var pageX = e.changedTouches[0].pageX; + var pageY = e.changedTouches[0].pageY; + var movementX = pageX - prevX; + var movementY = pageY - prevY; + prevX = pageX; + prevY = pageY; + var x = pageX - rect.left; + var y = pageY - rect.top; + this.handlePointerDrag({ + prevValue, + x, + y, + fromX, + fromY, + movementX, + movementY, + originalEvent: e + }); + }; + var handleTouchEnd = e => { + e.preventDefault(); + var x = e.changedTouches[0].pageX - rect.left; + var y = e.changedTouches[0].pageY - rect.top; + this.handlePointerUp({ + x, + y, + originalEvent: e + }); + document.removeEventListener("touchmove", handleTouchMove); + document.removeEventListener("touchend", handleTouchEnd); + }; + document.addEventListener("touchmove", handleTouchMove, { + passive: false + }); + document.addEventListener("touchend", handleTouchEnd, { + passive: false + }); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleMouseDown", e => { + e.preventDefault(); + e.currentTarget.focus(); + var rect = e.currentTarget.getBoundingClientRect(); + var fromX = e.pageX - rect.left; + var fromY = e.pageY - rect.top; + var prevValue = this.value; + this.handlePointerDown({ + x: fromX, + y: fromY, + originalEvent: e + }); + var handleMouseMove = e => { + e.preventDefault(); + var x = e.pageX - rect.left; + var y = e.pageY - rect.top; + this.handlePointerDrag({ + prevValue, + x, + y, + fromX, + fromY, + movementX: e.movementX, + movementY: e.movementY, + originalEvent: e + }); + }; + var handleMouseUp = e => { + e.preventDefault(); + var x = e.pageX - rect.left; + var y = e.pageY - rect.top; + this.handlePointerUp({ + x, + y, + originalEvent: e + }); + document.removeEventListener("mousemove", handleMouseMove); + document.removeEventListener("mouseup", handleMouseUp); + }; + document.addEventListener("mousemove", handleMouseMove); + document.addEventListener("mouseup", handleMouseUp); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleDblClick", e => { + e.preventDefault(); + this.value = 0; + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handlePointerUp", e => {}); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "levelHandler", levels => { + var levelsIn = levels.map(e => 20 * Math.log10(e)); + if (this.state.levels.length === levelsIn.length && this.state.levels.every((v, i) => v === levelsIn[i])) return; + this.state.levels = levelsIn; + this.paint(); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "raf", () => { + this.$frame++; + if (this.$frame % this.frameReduce !== 0) { + this.$raf = window.requestAnimationFrame(this.raf); + return; + } + this.$raf = undefined; + var _this$state = this.state, + barwidth = _this$state.barwidth, + barbgcolor = _this$state.barbgcolor, + coldcolor = _this$state.coldcolor, + warmcolor = _this$state.warmcolor, + hotcolor = _this$state.hotcolor, + overloadcolor = _this$state.overloadcolor, + tribordercolor = _this$state.tribordercolor, + tricolor = _this$state.tricolor, + textcolor = _this$state.textcolor; + var _this$state2 = this.state, + min = _this$state2.min, + max = _this$state2.max, + value = _this$state2.value, + levels = _this$state2.levels; + var channels = Math.min(this.channels, levels.length); + var ctx = this.ctx; + var canvas = this.canvas; + var distance = this.distance; + var _canvas$getBoundingCl = canvas.getBoundingClientRect(), + width = _canvas$getBoundingCl.width; + canvas.width = width; + var height = barwidth * (channels * 1.5 + 2); + canvas.height = height; + var drawWidth = width; + var left = 0; + var top = 0; + this.interactionRect = [0, top, width, height]; + this.paintLevels = [...levels]; + var paintLevels = [...this.paintLevels]; + if (paintLevels.find((v, i) => v > this.maxLevels[i])) { + this.maxLevels = [...paintLevels]; + if (this.maxTimer) window.clearTimeout(this.maxTimer); + this.maxTimer = window.setTimeout(() => { + this.maxLevels = [...this.paintLevels]; + this.maxTimer = undefined; + this.raf(); + }, 1000); + } + if (paintLevels.find((v, i) => v < this.maxLevels[i]) && typeof this.maxTimer === "undefined") { + this.maxTimer = window.setTimeout(() => { + this.maxLevels = [...this.paintLevels]; + this.maxTimer = undefined; + this.raf(); + }, 1000); + } + var maxLevels = this.maxLevels; + var coldStop = (-18 - min) / (max - min); + var warmStop = (-6 - min) / (max - min); + var hotStop = (-3 - min) / (max - min); + var overloadStop = -min / (max - min); + var gradient = ctx.createLinearGradient(left, 0, drawWidth, 0); + if (coldStop <= 1 && coldStop >= 0) gradient.addColorStop(coldStop, coldcolor);else if (coldStop > 1) gradient.addColorStop(1, coldcolor); + if (warmStop <= 1 && warmStop >= 0) gradient.addColorStop(warmStop, warmcolor); + if (hotStop <= 1 && hotStop >= 0) gradient.addColorStop(hotStop, hotcolor); + if (overloadStop <= 1 && overloadStop >= 0) gradient.addColorStop(overloadStop, overloadcolor);else if (overloadStop < 0) gradient.addColorStop(0, coldcolor); + for (var i = 0; i < channels; i++) { + var level = paintLevels[i]; + var maxLevel = maxLevels[i]; + ctx.fillStyle = barbgcolor; + if (level < 0) ctx.fillRect(left, top, drawWidth * overloadStop, barwidth); + if (level < max) ctx.fillRect(left + drawWidth * overloadStop + 1, top, drawWidth * (1 - overloadStop) - 1, barwidth); + ctx.fillStyle = gradient; + if (level > min) { + var _distance = (Math.min(0, level) - min) / (max - min); + ctx.fillRect(left, top, _distance * drawWidth, barwidth); + } + if (level > 0) { + var _distance2 = Math.min(max, level) / (max - min); + ctx.fillRect(left + overloadStop * drawWidth + 1, top, _distance2 * drawWidth - 1, barwidth); + } + if (maxLevel > level) { + if (maxLevel <= 0) { + var _distance3 = (Math.min(0, maxLevel) - min) / (max - min); + ctx.fillRect(left + _distance3 * drawWidth - 1, top, 1, barwidth); + } + if (maxLevel > 0) { + var _distance4 = Math.min(max, maxLevel) / (max - min); + ctx.fillRect(left + Math.min(drawWidth - 1, (overloadStop + _distance4) * drawWidth), top, 1, barwidth); + } + } + top += 1.5 * barwidth; + } + ctx.lineWidth = 1; + ctx.strokeStyle = tribordercolor; + var triOrigin = [this.interactionRect[0] + this.interactionRect[2] * distance - 4, top - barwidth * 0.5]; + ctx.beginPath(); + ctx.moveTo(triOrigin[0], triOrigin[1] + 8); + ctx.lineTo(triOrigin[0] + 4, triOrigin[1]); + ctx.lineTo(triOrigin[0] + 8, triOrigin[1] + 8); + ctx.lineTo(triOrigin[0], triOrigin[1] + 8); + ctx.stroke(); + ctx.fillStyle = tricolor; + ctx.fill(); + ctx.font = "regular 10px Arial, sans-serif"; + ctx.fillStyle = textcolor; + ctx.textAlign = "left"; + ctx.fillText("".concat(value.toFixed(2), " dB"), 4, height - 2, width); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handlePointerDown", e => { + var value = this.state.value; + if (e.x < this.interactionRect[0] || e.x > this.interactionRect[0] + this.interactionRect[2] || e.y < this.interactionRect[1] || e.y > this.interactionRect[1] + this.interactionRect[3]) return; + var newValue = this.getValueFromPos(e); + if (newValue !== value) this.value = this.getValueFromPos(e); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handlePointerDrag", e => { + var newValue = this.getValueFromPos(e); + if (newValue !== this.state.value) this.value = newValue; + }); + this.container = container; + this.meterNode = meterNode; + this.gainNode = gainNode; + this.state = _objectSpread({ + min: -70, + max: 10, + value: 0, + step: 0.01, + levels: [-Infinity], + barwidth: 8, + barbgcolor: "rgba(18, 18, 18, 1)", + coldcolor: "rgba(12, 248, 100, 1)", + warmcolor: "rgba(195, 248, 100, 1)", + hotcolor: "rgba(255, 193, 10, 1)", + overloadcolor: "rgba(255, 10, 10, 1)", + textcolor: "rgba(255, 255, 255, 1)", + tribordercolor: "rgba(80, 80, 80, 1)", + tricolor: "rgba(165, 165, 165, 1)" + }, state || {}); + this.getChildren(); + this.bind(); + this.paint(); + } + getChildren() { + this.container.innerHTML = ""; + this.canvas = document.createElement("canvas"); + this.ctx = this.canvas.getContext("2d"); + this.container.appendChild(this.canvas); + } + bind() { + this.canvas.addEventListener("mousedown", this.handleMouseDown); + this.canvas.addEventListener("touchstart", this.handleTouchStart, { + passive: false + }); + this.canvas.addEventListener("dblclick", this.handleDblClick); + this.meterNode.levelHandler = this.levelHandler; + } + // eslint-disable-line @typescript-eslint/no-unused-vars + get value() { + return this.state.value; + } + set value(valueIn) { + this.state.value = valueIn; + this.gainNode.gain.setValueAtTime(valueIn <= -70 ? 0 : Math.pow(10, valueIn / 20), 0); + this.paint(); + } + get distance() { + var _this$state3 = this.state, + max = _this$state3.max, + min = _this$state3.min, + value = _this$state3.value; + return (value - min) / (max - min); + } + get trueSteps() { + var _this$state4 = this.state, + max = _this$state4.max, + min = _this$state4.min, + step = _this$state4.step; + var full = this.interactionRect[2]; + var maxSteps = full; + if (step) return Math.min(Math.floor((max - min) / step), maxSteps); + return maxSteps; + } + get stepRange() { + var full = this.interactionRect[2]; + var trueSteps = this.trueSteps; + return full / trueSteps; + } + paint() { + if (this.$raf) return; + this.$raf = window.requestAnimationFrame(this.raf); + } + getValueFromPos(e) { + var _this$state5 = this.state, + min = _this$state5.min, + max = _this$state5.max; + var stepRange = this.stepRange; + var trueSteps = this.trueSteps; + var step = (max - min) / trueSteps; + var steps = Math.round((e.x - this.interactionRect[0]) / stepRange); + steps = Math.min(trueSteps, Math.max(0, steps)); + return steps * step + min; + } +} + +/***/ }), + +/***/ "./src/Recorder.ts": +/*!*************************!*\ + !*** ./src/Recorder.ts ***! + \*************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Recorder: () => (/* binding */ Recorder) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js"); +/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); +/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/regenerator */ "./node_modules/@babel/runtime/regenerator/index.js"); +/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var wav_encoder__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! wav-encoder */ "./node_modules/wav-encoder/index.js"); + + + + +class Recorder { + constructor(sampleRate) { + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__["default"])(this, "$start", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__["default"])(this, "$last", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__["default"])(this, "data", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__["default"])(this, "sampleRate", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__["default"])(this, "enabled", void 0); + this.enabled = false; + this.sampleRate = sampleRate || 44100; + } + reset($start) { + this.$start = $start; + this.$last = $start; + this.data = []; + } + append(buffer, index) { + if (!this.enabled) return this.totalSec; + if (index === 0 || !this.data || this.data.length === 0 || index !== ++this.$last) this.reset(index); + this.data.push(buffer); + return this.totalSec; + } + get totalSec() { + if (!this.data || !this.data.length || !this.data[0].length) return 0; + var sampleRate = this.sampleRate; + var buffers = this.data.length; + var bufferSize = this.data[0][0].length; + return bufferSize * buffers / sampleRate; + } + encode() { + var _this = this; + return (0,_babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_0__["default"])( /*#__PURE__*/_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_2___default().mark(function _callee() { + var sampleRate, buffers, channels, bufferSize, l, channelData, j, channel, i, bufferData; + return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_2___default().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + if (!(!_this.data || !_this.data.length || !_this.data[0].length)) { + _context.next = 2; + break; + } + return _context.abrupt("return", null); + case 2: + sampleRate = _this.sampleRate; + buffers = _this.data.length; + channels = _this.data[0].length; + bufferSize = _this.data[0][0].length; + l = buffers * bufferSize; + channelData = []; + for (j = 0; j < channels; j++) { + channel = new Float32Array(l); + for (i = 0; i < buffers; i++) { + bufferData = _this.data[i][j]; + channel.set(bufferData, i * bufferSize); + } + channelData.push(channel); + } + return _context.abrupt("return", (0,wav_encoder__WEBPACK_IMPORTED_MODULE_3__.encode)({ + sampleRate, + channelData + })); + case 10: + case "end": + return _context.stop(); + } + }, _callee); + }))(); + } +} + +/***/ }), + +/***/ "./src/Scope.ts": +/*!**********************!*\ + !*** ./src/Scope.ts ***! + \**********************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ Scope: () => (/* binding */ Scope) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); +/* harmony import */ var _Scope_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Scope.scss */ "./src/Scope.scss"); +/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ "./src/utils.ts"); +/* provided dependency */ var $ = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"); + + + +var TScopeType = /*#__PURE__*/function (TScopeType) { + TScopeType[TScopeType["Oscilloscope"] = 0] = "Oscilloscope"; + TScopeType[TScopeType["Spectroscope"] = 1] = "Spectroscope"; + TScopeType[TScopeType["Spectrogram"] = 2] = "Spectrogram"; + return TScopeType; +}(TScopeType || {}); +class Scope { + static drawOscilloscope(ctx, w, h, d, freq, sr, zoom, zoomOffset) { + this.drawBackground(ctx, w, h); + this.drawGrid(ctx, w, h); + var l = d.length; + ctx.strokeStyle = "#FFFFFF"; + ctx.lineWidth = 2; + ctx.beginPath(); + // Fastest way to get min and max to have: 1. max abs value for y scaling, 2. mean value for zero-crossing + var min = d[0]; + var max = d[0]; + var i = d.length; + while (i--) { + var s = d[i]; + if (s < min) min = s;else if (s > max) max = s; + } + var $zerox = 0; + var thresh = (min + max) * 0.5 + 0.001; // the zero-crossing with "offset" + var period = sr / freq; + var times = Math.floor(l / period) - 1; + while (d[$zerox++] > thresh && $zerox < l); + if ($zerox >= l - 1) { + $zerox = 0; + } else { + while (d[$zerox++] < thresh && $zerox < l); + if ($zerox >= l - 1) { + $zerox = 0; + } + } + var drawL = times > 0 && isFinite(period) ? Math.min(period * times, l - $zerox) : l - $zerox; + var $0 = Math.round($zerox + drawL * zoomOffset); + var $1 = Math.round($zerox + drawL / zoom + drawL * zoomOffset); + for (var _i = $0; _i < $1; _i++) { + var x = w * (_i - $0) / ($1 - $0 - 1); + var y = h - (d[_i] * 0.5 + 0.5) * h; + if (_i === $0) ctx.moveTo(x, y);else ctx.lineTo(x, y); + } + ctx.stroke(); + } + static drawSpectroscope(ctx, w, h, d, zoom, zoomOffset) { + this.drawBackground(ctx, w, h); + this.drawGrid(ctx, w, h); + var l = d.length; + var $0 = Math.round(l * zoomOffset); + var $1 = Math.round(l / zoom + l * zoomOffset); + ctx.fillStyle = "#FFFFFF"; + ctx.beginPath(); + for (var i = $0; i < $1; i++) { + var x = w * (i - $0) / ($1 - $0); + var y = ((d[i] + 10) / 100 + 1) * h; + if (i === $0) ctx.moveTo(x, h - y);else ctx.lineTo(x, h - y); + } + ctx.lineTo(w, h); + ctx.lineTo(0, h); + ctx.closePath(); + ctx.fill(); + } + static drawOfflineSpectrogram(ctx, d, $) { + var l = d.length; + var h = ctx.canvas.height; + var step = Math.max(1, Math.round(l / h)); + var maxInStep; + ctx.fillStyle = "black"; + ctx.fillRect($, 0, 1, h); + var $h = h / l; + for (var i = 0; i < l; i++) { + var samp = d[i]; + var $step = i % step; + if ($step === 0) maxInStep = samp; + if ($step !== step - 1) { + if ($step !== 0 && samp > maxInStep) maxInStep = samp; + continue; + } + var normalized = Math.min(1, Math.max(0, (maxInStep + 10) / 100 + 1)); + if (normalized === 0) continue; + var hue = (normalized * 180 + 240) % 360; + var lum = normalized * 50; + ctx.fillStyle = "hsl(".concat(hue, ", 100%, ").concat(lum, "%)"); + ctx.fillRect($, (1 - i / l) * h, 1, Math.max(1, $h)); + } + } + static drawSpectrogram(ctx, tempCtx, $, w, h, d, zoom) { + this.drawBackground(ctx, w, h); + this.drawGrid(ctx, w, h); + ctx.save(); + ctx.globalCompositeOperation = "lighter"; + if ($ + 1 < tempCtx.canvas.width) { + var d$ = Math.round($ / tempCtx.canvas.width * w * zoom); + if (d$ < w) ctx.drawImage(tempCtx.canvas, $ + 1, 0, tempCtx.canvas.width - $ - 1, tempCtx.canvas.height, w - w * zoom, 0, w * zoom - d$, h); + if (d$) ctx.drawImage(tempCtx.canvas, 0, 0, $ + 1, tempCtx.canvas.height, w - d$, 0, d$, h); + } else { + ctx.drawImage(tempCtx.canvas, 0, 0, tempCtx.canvas.width, tempCtx.canvas.height, w - w * zoom, 0, w * zoom, h); + } + ctx.restore(); + } + static drawBackground(ctx, w, h) { + ctx.save(); + ctx.fillStyle = "#000000"; + ctx.fillRect(0, 0, w, h); + ctx.restore(); + } + static drawGrid(ctx, w, h) { + ctx.save(); + ctx.beginPath(); + ctx.lineWidth = 1; + ctx.strokeStyle = "#404040"; + for (var i = 0.25; i < 1; i += 0.25) { + ctx.moveTo(w * i, 0); + ctx.lineTo(w * i, h); + ctx.moveTo(0, h * i); + ctx.lineTo(w, h * i); + } + ctx.stroke(); + ctx.restore(); + } + static drawStats(ctx, w, h, freq, samp, rms, zoom, zoomMin, zoomMax) { + ctx.save(); + ctx.fillStyle = "rgba(0, 0, 0, 0.75)"; + ctx.fillRect(w - 50, 0, 50, 50); + if (typeof zoomMin === "number") ctx.fillRect(0, h - 16, 40, 16); + if (typeof zoomMax === "number") ctx.fillRect(w - 40, h - 16, 40, 16); + if (typeof zoom === "number") ctx.fillRect(w / 2 - 20, h - 16, 40, 16); + ctx.fillStyle = "#DDDD99"; + ctx.font = "bold 12px Consolas, monospace"; + if (typeof zoom === "number") { + ctx.textAlign = "center"; + ctx.fillText(zoom.toFixed(1) + "x", w / 2, h - 2, 40); + } + if (typeof zoomMin === "number") { + ctx.textAlign = "left"; + ctx.fillText(zoomMin.toFixed(0), 2, h - 2, 40); + } + ctx.textAlign = "right"; + if (typeof zoomMax === "number") ctx.fillText(zoomMax.toFixed(0), w - 2, h - 2, 40); + ctx.fillText((samp >= 0 ? "@+" : "@") + samp.toFixed(3), w - 2, 15, 50); + ctx.fillText(freq.toFixed(0) + "Hz", w - 2, 30, 50); + ctx.fillText("x̄:" + rms.toFixed(3), w - 2, 45, 50); + ctx.restore(); + } + static getIconClassName(typeIn) { + var prefix = "fas fa-sm "; + if (typeIn === TScopeType.Oscilloscope) return prefix + "fa-wave-square"; + if (typeIn === TScopeType.Spectroscope) return prefix + "fa-chart-bar"; + if (typeIn === TScopeType.Spectrogram) return prefix + "fa-water"; + return prefix; + } + constructor(options) { + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "raf", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "ctx", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "spectTempCtx", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "spectCol$", 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_disabled", false); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_paused", false); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "frame", 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "audioCtx", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "analyser", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "splitter", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_channel", 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "channels", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "container", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "canvas", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnSwitch", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnSize", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnCh", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "iSwitch", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "type", TScopeType.Oscilloscope); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_zoom", 1); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_zoomOffset", 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_size", 2048); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "t", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "ti", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "f", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "drawSpectrogram", false); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "draw", () => { + this.frame++; // Reduce frame rate + if (this.canvas.offsetParent !== null && this.frame % 3 === 0 && this.audioCtx && this.audioCtx.state === "running" && this.analyser) { + var ctx = this.ctx; + var sr = this.audioCtx.sampleRate; + var w = this.container.clientWidth; + var h = Math.floor(Math.min(w * 0.75, this.container.clientHeight)); + this.canvas.width = w; + this.canvas.height = h; + this.analyser.getFloatFrequencyData(this.f); + if (this.analyser.getFloatTimeDomainData) { + this.analyser.getFloatTimeDomainData(this.t); + } else { + // This is for Safari, what a shame + this.analyser.getByteTimeDomainData(this.ti); + this.ti.forEach((v, i) => this.t[i] = v / 128 - 1); + } + var freq = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.estimateFreq)(this.f, sr); + var samp = this.t[this.t.length - 1]; + var rms = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.getRms)(this.t); + if (this.drawSpectrogram) Scope.drawOfflineSpectrogram(this.spectTempCtx, this.f, this.spectCol$); + if (this.type === TScopeType.Oscilloscope) { + Scope.drawOscilloscope(ctx, w, h, this.t, freq, sr, this.zoom, this.zoomOffset); + Scope.drawStats(ctx, w, h, freq, samp, rms, this.zoom); + } else if (this.type === TScopeType.Spectroscope) { + Scope.drawSpectroscope(ctx, w, h, this.f, this.zoom, this.zoomOffset); + Scope.drawStats(ctx, w, h, freq, samp, rms, this.zoom, sr / 2 * this.zoomOffset, sr / 2 / this.zoom + sr / 2 * this.zoomOffset); + } else if (this.type === TScopeType.Spectrogram) { + Scope.drawSpectrogram(ctx, this.spectTempCtx, this.spectCol$, w, h, this.f, this.zoom); + Scope.drawStats(ctx, w, h, freq, samp, rms, this.zoom); + } + this.spectCol$ = (this.spectCol$ + 1) % this.spectTempCtx.canvas.width; + } + this.raf = requestAnimationFrame(this.draw); + return this.raf; + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "drawPause", () => { + var ctx = this.ctx; + var w = this.canvas.width; + var h = this.canvas.height; + ctx.fillStyle = "#00000080"; + ctx.fillRect(0, 0, w, h); + ctx.fillStyle = "#FFFFFF"; + ctx.fillRect(w * 0.38, h * 0.35, w * 0.08, h * 0.3); + ctx.fillRect(w * 0.54, h * 0.35, w * 0.08, h * 0.3); + }); + Object.assign(this, options); + this.t = new Float32Array(this.analyser.fftSize); + this.ti = new Uint8Array(this.analyser.fftSize); + this.f = new Float32Array(this.analyser.frequencyBinCount); + this.getChildren(); + this.bind(); + if (!window.AudioWorklet) this.paused = true;else if (typeof options.paused === "undefined") this.paused = false; + } + getChildren() { + this.spectTempCtx = document.createElement("canvas").getContext("2d"); + this.spectTempCtx.canvas.height = 1024; + this.spectTempCtx.canvas.width = 1024; + var ctrl; + for (var i = 0; i < this.container.children.length; i++) { + var e = this.container.children[i]; + if (e.classList.contains("scope-controller")) ctrl = e; + if (e.classList.contains("scope-canvas")) this.canvas = e; + } + if (!ctrl) { + ctrl = document.createElement("div"); + ctrl.classList.add("scope-controller"); + this.container.appendChild(ctrl); + } + if (!this.canvas) { + var canvas = document.createElement("canvas"); + canvas.classList.add("scope-canvas"); + canvas.setAttribute("data-toggle", "tooltip"); + canvas.setAttribute("data-placement", "left"); + canvas.setAttribute("title", "Input analyser"); + this.container.appendChild(canvas); + this.canvas = canvas; + try { + $(canvas).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + } + this.ctx = this.canvas.getContext("2d"); + for (var _i2 = 0; _i2 < ctrl.children.length; _i2++) { + var _e = ctrl.children[_i2]; + if (_e.classList.contains("scope-btn-switch")) this.btnSwitch = _e; + if (_e.classList.contains("scope-btn-size")) this.btnSize = _e; + if (_e.classList.contains("scope-btn-ch")) this.btnCh = _e; + } + if (!this.btnSwitch) { + var btn = document.createElement("button"); + btn.className = "scope-btn-switch btn btn-outline-light btn-sm btn-overlay btn-overlay-icon"; + btn.setAttribute("data-toggle", "tooltip"); + btn.setAttribute("data-placement", "top"); + btn.setAttribute("title", "Oscilloscope / Spectroscope / Spectrogram"); + ctrl.appendChild(btn); + this.btnSwitch = btn; + try { + $(btn).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + } + if (!this.btnSize) { + var _btn = document.createElement("button"); + _btn.className = "scope-btn-size btn btn-outline-light btn-sm btn-overlay"; + _btn.setAttribute("data-toggle", "tooltip"); + _btn.setAttribute("data-placement", "top"); + _btn.setAttribute("title", "Analyser Size"); + _btn.innerText = this.analyser.fftSize + "samps"; + ctrl.appendChild(_btn); + this.btnSize = _btn; + try { + $(_btn).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + } + if (!this.btnCh) { + var _btn2 = document.createElement("button"); + _btn2.className = "scope-btn-ch btn btn-outline-light btn-sm btn-overlay"; + _btn2.setAttribute("data-toggle", "tooltip"); + _btn2.setAttribute("data-placement", "top"); + _btn2.setAttribute("title", "Current Channel"); + _btn2.innerText = "ch " + (this._channel + 1).toString(); + ctrl.appendChild(_btn2); + this.btnCh = _btn2; + try { + $(_btn2).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + } + for (var _i3 = 0; _i3 < this.btnSwitch.children.length; _i3++) { + var _e2 = this.btnSwitch.children[_i3]; + if (_e2.classList.contains("fas")) this.iSwitch = _e2; + } + if (!this.iSwitch) { + var _i4 = document.createElement("i"); + _i4.className = "fas fa-sm fa-wave-square"; + this.btnSwitch.appendChild(_i4); + this.iSwitch = _i4; + } + } + bind() { + this.btnSwitch.addEventListener("click", () => { + this.zoom = 1; + this.zoomOffset = 0; + this.type = (this.type + 1) % (this.drawSpectrogram ? 3 : 2); + this.iSwitch.className = Scope.getIconClassName(this.type); + }); + this.btnSize.addEventListener("click", () => { + this.zoom = 1; + this.zoomOffset = 0; + this.size = Scope.sizes[(Scope.sizes.indexOf(this.size) + 1) % 4]; + }); + this.btnCh.addEventListener("click", () => { + this.channel = (this.channel + 1) % this.channels; + }); + this.canvas.addEventListener("click", () => { + this.paused = !this.paused; + }); + this.canvas.addEventListener("wheel", e => { + var multiplier = Math.pow(1.5, e.deltaY > 0 ? -1 : 1); + var zoom = this.zoom; + var rect = this.canvas.getBoundingClientRect(); + var center = (e.pageX - rect.left) / rect.width / zoom + this.zoomOffset; + if (e.deltaY !== 0) { + this.zoom *= multiplier; + this.zoomOffset = center - center / this.zoom; + } + if (e.deltaX !== 0) this.zoomOffset += (e.deltaX > 0 ? 1 : -1) * 0.1; + }); + } + get size() { + return this._size; + } + set size(sizeIn) { + this.analyser.fftSize = sizeIn; + this.t = new Float32Array(this.analyser.fftSize); + this.ti = new Uint8Array(this.analyser.fftSize); + this.f = new Float32Array(this.analyser.frequencyBinCount); + this.btnSize.innerText = sizeIn.toString() + " samps"; + this._size = sizeIn; + } + get paused() { + return this._paused; + } + set paused(pausedIn) { + if (pausedIn === this.paused) return; + this._paused = pausedIn; + if (this.disabled) return; + if (this.paused) { + cancelAnimationFrame(this.raf); + this.raf = requestAnimationFrame(this.drawPause); + } else { + this.raf = requestAnimationFrame(this.draw); + } + } + get disabled() { + return this._disabled; + } + set disabled(disabledIn) { + if (disabledIn === this.disabled) return; + this._disabled = disabledIn; + if (this.paused) return; + if (this.disabled) { + cancelAnimationFrame(this.raf); + } else { + this.raf = requestAnimationFrame(this.draw); + } + } + get channel() { + return this._channel; + } + set channel(channelIn) { + if (channelIn >= this.channels) return; + var oldCh = this._channel; + this._channel = channelIn; + this.btnCh.innerText = "ch " + (this._channel + 1).toString(); + if (this._channel === oldCh) return; + this.splitter.connect(this.analyser, this._channel, 0); // Need to be done in the order, or Chrome inspect the graph and disable the analyser. + setTimeout(() => { + try { + this.splitter.disconnect(this.analyser, oldCh, 0); + } catch (_unused) {} // eslint-disable-line no-empty + }, 10); + this._channel = channelIn; + } + get zoom() { + return this._zoom; + } + set zoom(zoomIn) { + this._zoom = Math.min(16, Math.max(1, zoomIn)); + this.zoomOffset = this._zoomOffset; + } + get zoomOffset() { + return this._zoomOffset; + } + set zoomOffset(zoomOffsetIn) { + this._zoomOffset = Math.max(0, Math.min(1 - 1 / this._zoom, zoomOffsetIn)); + } +} +(0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(Scope, "sizes", [128, 512, 2048, 8192]); + +/***/ }), + +/***/ "./src/StaticScope.ts": +/*!****************************!*\ + !*** ./src/StaticScope.ts ***! + \****************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ StaticScope: () => (/* binding */ StaticScope) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); +/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/utils.ts"); +/* harmony import */ var _StaticScope_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./StaticScope.scss */ "./src/StaticScope.scss"); +/* provided dependency */ var $ = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"); + + + +var EScopeMode = /*#__PURE__*/function (EScopeMode) { + EScopeMode[EScopeMode["Data"] = 0] = "Data"; + EScopeMode[EScopeMode["Interleaved"] = 1] = "Interleaved"; + EScopeMode[EScopeMode["Oscilloscope"] = 2] = "Oscilloscope"; + EScopeMode[EScopeMode["Spectroscope"] = 3] = "Spectroscope"; + EScopeMode[EScopeMode["Spectrogram"] = 4] = "Spectrogram"; + return EScopeMode; +}(EScopeMode || {}); +class StaticScope { + static drawInterleaved(ctx, w, h, d, zoom, zoomOffset, vzoom, cursor) { + this.drawBackground(ctx, w, h); + if (!d) return; + var $ = d.$, + t = d.t, + freqEstimated = d.freqEstimated, + sampleRate = d.sampleRate, + drawMode = d.drawMode; + if (!t || !t.length || !t[0].length) return; + var l = t[0].length; + // Fastest way to get min and max to have: 1. max abs value for y scaling, 2. mean value for zero-crossing + var min = t[0][0]; + var max = t[0][0]; + var i = t.length; + var samp; + while (i--) { + var j = l; + while (j--) { + samp = t[i][j]; + if (samp < min) min = samp;else if (samp > max) max = samp; + } + } + var yFactor = Math.max(1, Math.abs(min), Math.abs(max)) * vzoom; + var $0 = 0; // Draw start + var $1 = l - 1; // Draw End + var $zerox = 0; + if (drawMode === "continuous" && l < sampleRate) { + // Stablize when window size < 1 sec + var thresh = (min + max) * 0.5 + 0.001; // the zero-crossing with "offset" + var period = sampleRate / freqEstimated; + var times = Math.floor(l / period) - 1; + while (t[0][(0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($zerox++, $, l)] > thresh && $zerox < l); + if ($zerox >= l - 1) { + $zerox = 0; + } else { + while (t[0][(0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($zerox++, $, l)] < thresh && $zerox < l); + if ($zerox >= l - 1) { + $zerox = 0; + } + } + var drawL = times > 0 && isFinite(period) ? Math.min(period * times, l - $zerox) : l - $zerox; + $0 = Math.round($zerox + drawL * zoomOffset); + $1 = Math.round($zerox + drawL / zoom + drawL * zoomOffset); + } else { + $0 = Math.round(l * zoomOffset); + $1 = Math.round(l / zoom + l * zoomOffset); + } + var left = 50; + var bottom = 20; + var hCh = (h - bottom) / t.length; // Height per channel + var eventsToDraw = this.drawGrid(ctx, w, h, $0 - $zerox, $1 - $zerox, $zerox, yFactor, d, EScopeMode.Interleaved); + var gridX = (w - left) / ($1 - $0 - 1); + var step = Math.max(1, Math.round(1 / gridX)); // horizontal draw step for optimization + ctx.lineWidth = 2; + for (var _i = 0; _i < t.length; _i++) { + ctx.beginPath(); + ctx.strokeStyle = "hsl(".concat(_i * 60, ", 100%, 85%)"); + var maxInStep = void 0; + var minInStep = void 0; + var $j = void 0; + var $step = void 0; + var x = void 0; + var y = void 0; + for (var _j = $0; _j < $1; _j++) { + $j = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(_j, $, l); // True index + samp = t[_i][$j]; + $step = (_j - $0) % step; + if ($step === 0) { + maxInStep = samp; + minInStep = samp; + } else { + if (samp > maxInStep) maxInStep = samp; + if (samp < minInStep) minInStep = samp; + } + if ($step !== step - 1) continue; + x = (_j - $0) * gridX + left; + y = hCh * (_i + 0.5 - maxInStep / yFactor * 0.5); + if (_j === $0) ctx.moveTo(x, y);else ctx.lineTo(x, y); + if (minInStep !== maxInStep) { + y = hCh * (_i + 0.5 - minInStep / yFactor * 0.5); + ctx.lineTo(x, y); + } + } + ctx.stroke(); + } + eventsToDraw.forEach(params => this.drawEvent(ctx, w, h, ...params)); + if (cursor && cursor.x > left && cursor.y < h - bottom) { + var statsToDraw = { + values: [] + }; + var $cursor = Math.round($0 + (cursor.x - left) / gridX); + statsToDraw.values = []; + statsToDraw.x = ($cursor - $0) * gridX + left; + statsToDraw.xLabel = ($cursor - $zerox).toFixed(0); + var _$j = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($cursor, $, l); + for (var _i2 = 0; _i2 < t.length; _i2++) { + var _samp = t[_i2][_$j]; + if (typeof _samp === "number") statsToDraw.values.push(_samp); + } + this.drawStats(ctx, w, h, statsToDraw); + } + } + static drawOscilloscope(ctx, w, h, d, zoom, zoomOffset, vzoom, cursor) { + this.drawBackground(ctx, w, h); + if (!d) return; + var $ = d.$, + t = d.t, + freqEstimated = d.freqEstimated, + sampleRate = d.sampleRate, + drawMode = d.drawMode; + if (!t || !t.length || !t[0].length) return; + var l = t[0].length; + // Fastest way to get min and max to have: 1. max abs value for y scaling, 2. mean value for zero-crossing + var min = t[0][0]; + var max = t[0][0]; + var i = t.length; + var samp; + while (i--) { + var j = l; + while (j--) { + samp = t[i][j]; + if (samp < min) min = samp;else if (samp > max) max = samp; + } + } + var yFactor = Math.max(1, Math.abs(min), Math.abs(max)) * vzoom; + var $0 = 0; // Draw start + var $1 = l - 1; // Draw End + var $zerox = 0; + if (drawMode === "continuous" && l < sampleRate) { + // Stablize when window size < 1 sec + var thresh = (min + max) * 0.5 + 0.001; // the zero-crossing with "offset" + var period = sampleRate / freqEstimated; + var times = Math.floor(l / period) - 1; + while (t[0][(0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($zerox++, $, l)] > thresh && $zerox < l); // Find first raise + if ($zerox >= l - 1) { + // Found nothing, no stablization + $zerox = 0; + } else { + while (t[0][(0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($zerox++, $, l)] < thresh && $zerox < l); // Find first drop + if ($zerox >= l - 1) { + $zerox = 0; + } + } + var drawL = times > 0 && isFinite(period) ? Math.min(period * times, l - $zerox) : l - $zerox; // length to draw + $0 = Math.round($zerox + drawL * zoomOffset); + $1 = Math.round($zerox + drawL / zoom + drawL * zoomOffset); + } else { + $0 = Math.round(l * zoomOffset); + $1 = Math.round(l / zoom + l * zoomOffset); + } + var left = 50; + var bottom = 20; + var eventsToDraw = this.drawGrid(ctx, w, h, $0 - $zerox, $1 - $zerox, $zerox, yFactor, d, EScopeMode.Oscilloscope); + var gridX = (w - left) / ($1 - $0 - 1); + var step = Math.max(1, Math.round(1 / gridX)); + ctx.lineWidth = 2; + for (var _i3 = 0; _i3 < t.length; _i3++) { + ctx.beginPath(); + ctx.strokeStyle = t.length === 1 ? "white" : "hsl(".concat(_i3 * 60, ", 100%, 85%)"); + var maxInStep = void 0; + var minInStep = void 0; + var $j = void 0; + var $step = void 0; + var x = void 0; + var y = void 0; + for (var _j2 = $0; _j2 < $1; _j2++) { + $j = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(_j2, $, l); + samp = t[_i3][$j]; + $step = (_j2 - $0) % step; + if ($step === 0) { + maxInStep = samp; + minInStep = samp; + } else { + if (samp > maxInStep) maxInStep = samp; + if (samp < minInStep) minInStep = samp; + } + if ($step !== step - 1) continue; + x = (_j2 - $0) * gridX + left; + y = (h - bottom) * (0.5 - maxInStep / yFactor * 0.5); + if (_j2 === $0) ctx.moveTo(x, y);else ctx.lineTo(x, y); + if (minInStep !== maxInStep) { + y = (h - bottom) * (0.5 - minInStep / yFactor * 0.5); + ctx.lineTo(x, y); + } + } + ctx.stroke(); + } + eventsToDraw.forEach(params => this.drawEvent(ctx, w, h, ...params)); + if (cursor && cursor.x > left && cursor.y < h - bottom) { + var statsToDraw = { + values: [] + }; + var $cursor = Math.round($0 + (cursor.x - left) / gridX); + statsToDraw.values = []; + statsToDraw.x = ($cursor - $0) * gridX + left; + statsToDraw.xLabel = ($cursor - $zerox).toFixed(0); + var _$j2 = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($cursor, $, l); + for (var _i4 = 0; _i4 < t.length; _i4++) { + var _samp2 = t[_i4][_$j2]; + if (typeof _samp2 === "number") statsToDraw.values.push(_samp2); + } + this.drawStats(ctx, w, h, statsToDraw); + } + } + static drawSpectroscope(ctx, w, h, d, zoom, zoomOffset, cursor) { + this.drawBackground(ctx, w, h); + if (!d) return; + var $ = d.$, + f = d.f, + fftSize = d.fftSize, + fftOverlap = d.fftOverlap; + if (!f || !f.length || !f[0].length) return; + var fftBins = fftSize / 2; + var $f = $ * fftOverlap / 2; + $f -= $f % fftBins; + var l = f[0].length; + var $0 = l - fftBins + Math.round(fftBins * zoomOffset); + var $1 = l - fftBins + Math.round(fftBins / zoom + fftBins * zoomOffset); + var left = 50; + var bottom = 20; + var hCh = (h - bottom) / f.length; + var eventsToDraw = this.drawGrid(ctx, w, h, $0, $1, 0, 1, d, EScopeMode.Spectroscope); + var gridX = (w - left) / ($1 - $0 - 1); + var step = Math.max(1, Math.round(1 / gridX)); + for (var i = 0; i < f.length; i++) { + ctx.beginPath(); + ctx.fillStyle = f.length === 1 ? "white" : "hsl(".concat(i * 60, ", 100%, 85%)"); + var maxInStep = void 0; + for (var j = $0; j < $1; j++) { + var $j = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(j, $f, l); + var samp = f[i][$j]; + var $step = (j - $0) % step; + if ($step === 0) maxInStep = samp; + if ($step !== step - 1) { + if ($step !== 0 && samp > maxInStep) maxInStep = samp; + continue; + } + var x = (j - $0) * gridX + left; + var y = hCh * (i + 1 - Math.min(1, Math.max(0, maxInStep / 100 + 1))); + if (j === $0) ctx.moveTo(x, y);else ctx.lineTo(x, y); + } + ctx.lineTo(w, hCh * (i + 1)); + ctx.lineTo(left, hCh * (i + 1)); + ctx.closePath(); + ctx.fill(); + } + eventsToDraw.forEach(params => this.drawEvent(ctx, w, h, ...params)); + if (cursor && cursor.x > left && cursor.y < h - bottom) { + var statsToDraw = { + values: [] + }; + var $cursor = $0 + Math.round((cursor.x - left) / gridX); + statsToDraw.values = []; + statsToDraw.x = ($cursor - $0) * gridX + left; + statsToDraw.xLabel = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.indexToFreq)($cursor, fftBins, d.sampleRate).toFixed(0); + var _$j3 = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($cursor, $f, l); + for (var _i5 = 0; _i5 < f.length; _i5++) { + var _samp3 = f[_i5][_$j3]; + if (typeof _samp3 === "number") statsToDraw.values.push(_samp3); + } + this.drawStats(ctx, w, h, statsToDraw); + } + } + static drawSpectrogram(ctx, tempCtx, w, h, d, zoom, zoomOffset, cursor) { + this.drawBackground(ctx, w, h); + if (!d) return; + var $ = d.$, + f = d.f, + fftSize = d.fftSize, + fftOverlap = d.fftOverlap; + if (!f || !f.length || !f[0].length) return; + var fftBins = fftSize / 2; + var $f = $ * fftOverlap / 2; + $f -= $f % fftBins; + var l = f[0].length / fftBins; + var $0fft = Math.floor(l * zoomOffset); + var $1fft = Math.ceil(l / zoom + l * zoomOffset); + var $0 = $0fft * fftBins; + var $1 = $1fft * fftBins; + var eventsToDraw = this.drawGrid(ctx, w, h, $0, $1, 0, 1, d, EScopeMode.Spectrogram); + ctx.save(); + ctx.globalCompositeOperation = "lighter"; + ctx.imageSmoothingEnabled = false; + var left = 50; + var bottom = 20; + var $0src = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($0fft, $f / fftBins, l); + var $1src = $0src + $1fft - $0fft; + if ($1src > l) { + var split$ = l - $0src; + ctx.drawImage(tempCtx.canvas, $0src, 0, split$, tempCtx.canvas.height, left, 0, split$ / ($1src - $0src) * (w - left), h - bottom); + ctx.drawImage(tempCtx.canvas, 0, 0, $1src - l - 0.01, tempCtx.canvas.height, split$ / ($1src - $0src) * (w - left) + left, 0, (1 - split$ / ($1src - $0src)) * (w - left), h - bottom); + } else { + ctx.drawImage(tempCtx.canvas, $0src, 0, $1src - $0src, tempCtx.canvas.height, left, 0, w - left, h - bottom); + } + ctx.restore(); + eventsToDraw.forEach(params => this.drawEvent(ctx, w, h, ...params)); + if (cursor && cursor.x > left && cursor.y < h - bottom) { + var statsToDraw = { + values: [] + }; + var gridX = (w - left) / ($1fft - $0fft); + var gridY = (h - bottom) / f.length / fftBins; + var $fft = $0fft + Math.floor((cursor.x - left) / gridX); + var $ch = Math.floor(cursor.y / gridY / fftBins); + var $bin = Math.floor((h - bottom - cursor.y) / gridY) % fftBins; + var $cursor = $fft * fftBins + $bin; + var $j = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($cursor, $f, f[0].length); + var freq = $j % fftBins / fftBins * d.sampleRate / 2; + var samp = f[$ch][$j]; + if (typeof samp === "number") statsToDraw.values = [samp]; + statsToDraw.x = ($fft - $0fft + 0.5) * gridX + left; + statsToDraw.y = (($ch + 1) * fftBins - $bin) * gridY; + statsToDraw.xLabel = $fft.toFixed(0); + statsToDraw.yLabel = freq.toFixed(0); + this.drawStats(ctx, w, h, statsToDraw); + } + } + static drawOfflineSpectrogram(ctx, d, last$) { + if (!d) return last$; + var $ = d.$, + f = d.f, + fftSize = d.fftSize, + fftOverlap = d.fftOverlap; + if (!f || !f.length || !f[0].length) return last$; + var fftBins = fftSize / 2; + var $f = $ * fftOverlap / 2; + $f -= $f % fftBins; + var _ctx$canvas = ctx.canvas, + canvasWidth = _ctx$canvas.width, + h = _ctx$canvas.height; + var l = f[0].length; + var $0 = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(last$, 0, l); + var $1 = $0 >= $f ? $f + l : $f; + if ($1 - $0 < 0) return last$; + var $0fft = Math.floor($0 / fftBins); + var $1fft = Math.ceil($1 / fftBins); + var hCh = h / f.length; + var w = l / fftBins; + var $h = hCh / fftBins; + if (canvasWidth !== w) ctx.canvas.width = w; + var step = Math.max(1, Math.round(fftBins / hCh)); + for (var i = 0; i < f.length; i++) { + for (var j = $0fft; j < $1fft; j++) { + var maxInStep = void 0; + ctx.fillStyle = "black"; + ctx.fillRect(j % w, i * hCh, 1, hCh); + for (var k = 0; k < fftBins; k++) { + var samp = f[i][(0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(k, j * fftBins, l)]; + var $step = k % step; + if ($step === 0) maxInStep = samp; + if ($step !== step - 1) { + if ($step !== 0 && samp > maxInStep) maxInStep = samp; + continue; + } + var normalized = Math.min(1, Math.max(0, (maxInStep + 10) / 100 + 1)); + if (normalized === 0) continue; + var hue = (normalized * 180 + 240) % 360; + var lum = normalized * 50; + ctx.fillStyle = "hsl(".concat(hue, ", 100%, ").concat(lum, "%)"); + ctx.fillRect(j % w, (fftBins - k - 1) * $h + i * hCh, 1, Math.max(1, $h)); + } + } + } + return (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)($1, 0, l); + } + static drawBackground(ctx, w, h) { + ctx.save(); + ctx.fillStyle = "#181818"; + ctx.fillRect(0, 0, w, h); + ctx.restore(); + } + static drawGrid(ctx, w, h, $0, $1, $zerox, yFactor, d, mode) { + ctx.save(); + ctx.setLineDash([]); + ctx.lineWidth = 1; + var t = d.t, + e = d.e, + bufferSize = d.bufferSize, + fftSize = d.fftSize, + fftOverlap = d.fftOverlap, + sampleRate = d.sampleRate; + var inFreqDomain = mode === EScopeMode.Spectrogram || mode === EScopeMode.Spectroscope; + var fftBins = fftSize / 2; + var channels = mode === EScopeMode.Oscilloscope ? 1 : t.length; + var unit = mode === EScopeMode.Spectrogram ? "Hz/frame" : mode === EScopeMode.Spectroscope ? "dB/Hz" : "lvl/samp"; + var eventsToDraw = []; + var $0buffer = $0 / bufferSize / (inFreqDomain ? fftOverlap / 2 : 1); + var $1buffer = $1 / bufferSize / (inFreqDomain ? fftOverlap / 2 : 1); + var hStep = Math.pow(2, Math.ceil(Math.log2($1buffer - $0buffer))) / 8; + $0buffer -= $0buffer % hStep; + $1buffer -= $0buffer % hStep; + var $buffer = (d.$buffer || 0) + Math.round($zerox / bufferSize / (inFreqDomain ? fftOverlap / 2 : 1)); + if (inFreqDomain) $buffer -= $buffer % (fftBins / bufferSize / fftOverlap / 2); + var left = 50; + var bottom = 20; + var eventStrokeStyle = "#ff8800"; + var bufferStrokeStyle = "#004000"; + var normalStrokeStyle = "#404040"; + ctx.fillStyle = "#DDDD99"; + ctx.font = "10px Consolas, monospace"; + ctx.textAlign = "right"; + ctx.textBaseline = "middle"; + ctx.fillText(unit, 45, h - 10, 40); + ctx.textAlign = "center"; + ctx.strokeStyle = "white"; + ctx.beginPath(); + ctx.moveTo(left, 0); + ctx.lineTo(left, h - bottom); + ctx.lineTo(w, h - bottom); + ctx.stroke(); + ctx.strokeStyle = bufferStrokeStyle; + for (var j = $0buffer; j < $1buffer; j += hStep) { + var $fft = j / (fftBins / bufferSize) * fftOverlap / 2; + var x = (j * bufferSize * (inFreqDomain ? fftOverlap / 2 : 1) - $0) / ($1 - $0 - 1) * (w - left) + left; + if (x < left) continue; + ctx.strokeStyle = j % 1 === 0 ? bufferStrokeStyle : normalStrokeStyle; + ctx.beginPath(); + ctx.moveTo(x, 0); + ctx.lineTo(x, h - bottom); + ctx.stroke(); + if (mode === EScopeMode.Spectrogram) { + if ($fft % 1 === 0) ctx.fillText($fft.toFixed(), Math.min(x, w - 20), h - 10); + } else if (mode === EScopeMode.Spectroscope) { + ctx.fillText(($fft % 1 * sampleRate / 2).toFixed(), Math.min(x, w - 20), h - 10); + } else { + ctx.fillText((j * bufferSize).toFixed(), Math.min(x, w - 20), h - 10); + } + } + if (e) { + ctx.strokeStyle = eventStrokeStyle; + for (var _j3 = Math.ceil($0buffer); _j3 < $1buffer; _j3++) { + if (e[$buffer + _j3] && e[$buffer + _j3].length) { + var _x = (_j3 * bufferSize * (inFreqDomain ? fftOverlap / 2 : 1) - $0) / ($1 - $0 - 1) * (w - left) + left; + if (_x < left) continue; + eventsToDraw.push([_x, e[$buffer + _j3]]); + ctx.beginPath(); + ctx.moveTo(_x, 0); + ctx.lineTo(_x, h - bottom); + ctx.stroke(); + } + } + } + ctx.strokeStyle = normalStrokeStyle; + var hCh = (h - bottom) / channels; + var vStep = 0.25; + while (yFactor / vStep > 2) vStep *= 2; // Maximum horizontal grids in channel one side = 2 + ctx.beginPath(); + ctx.textAlign = "right"; + var drawHLine = (y, yLabel) => { + ctx.moveTo(left, y); + ctx.lineTo(w, y); + ctx.fillText(yLabel, 45, Math.max(y, 10)); + }; + var _loop = function _loop() { + var y = (i + 0.5) * hCh; + var $ = 0.5; + var getYLabel = () => mode === EScopeMode.Spectrogram ? (0,_utils__WEBPACK_IMPORTED_MODULE_1__.indexToFreq)(fftBins * $, fftBins, sampleRate).toFixed(0) : mode === EScopeMode.Spectroscope ? (-100 + 100 * $).toFixed(0) : (-yFactor + 2 * yFactor * $).toFixed(2); + var yLabel = getYLabel(); + drawHLine(y, yLabel); + for (var _j4 = vStep; _j4 < yFactor; _j4 += vStep) { + $ = 0.5 - _j4 / yFactor / 2; + y = (i + 0.5 + _j4 / yFactor / 2) * hCh; + yLabel = getYLabel(); + drawHLine(y, yLabel); + $ = 0.5 + _j4 / yFactor / 2; + y = (i + 0.5 - _j4 / yFactor / 2) * hCh; + yLabel = getYLabel(); + drawHLine(y, yLabel); + } + }; + for (var i = 0; i < channels; i++) { + _loop(); + } + ctx.stroke(); + ctx.beginPath(); + ctx.setLineDash([4, 2]); + ctx.strokeStyle = "white"; + for (var _i6 = 1; _i6 < channels; _i6++) { + ctx.moveTo(0, _i6 * hCh); + ctx.lineTo(w, _i6 * hCh); + } + ctx.stroke(); + ctx.restore(); + return eventsToDraw; + } + static drawEvent(ctx, w, h, x, e) { + ctx.save(); + ctx.font = "bold 12px Consolas, monospace"; + ctx.fillStyle = "rgba(0, 0, 0, 0.75)"; + var eStrings = e.map(event => event.data.path ? "".concat(event.data.path, ": ").concat(event.data.value) : "".concat(event.type, ": ").concat(event.data.join(","))); + var textWidth = Math.max(...eStrings.map(s => ctx.measureText(s).width)) + 5; + if (w - x >= textWidth) { + ctx.fillRect(x, 0, textWidth, e.length * 15 + 2); + ctx.textAlign = "left"; + } else { + ctx.fillRect(x - textWidth, 0, textWidth, e.length * 15 + 2); + ctx.textAlign = "right"; + } + ctx.fillStyle = "#DDDD99"; + eStrings.forEach((s, i) => ctx.fillText(s, x, (i + 1) * 15, textWidth)); + ctx.restore(); + } + static drawStats(ctx, w, h, statsToDraw) { + var left = 50; + var bottom = 20; + ctx.save(); + ctx.lineWidth = 1; + ctx.strokeStyle = "#b0b0b0"; + ctx.beginPath(); + var x = statsToDraw.x, + y = statsToDraw.y, + xLabel = statsToDraw.xLabel, + yLabel = statsToDraw.yLabel, + values = statsToDraw.values; + if (x) { + ctx.moveTo(x, 0); + ctx.lineTo(x, h - bottom); + } + if (y) { + ctx.moveTo(left, y); + ctx.lineTo(w, y); + } + ctx.stroke(); + ctx.fillStyle = "rgba(0, 0, 0, 0.5)"; + if (xLabel) ctx.fillRect(Math.min(x - 20, w - 40), h - 18, 40, 16); + if (yLabel) ctx.fillRect(5, Math.max(0, y - 8), 45, 16); + ctx.fillStyle = "#DDDD99"; + ctx.font = "bold 12px Consolas, monospace"; + ctx.textAlign = "center"; + ctx.textBaseline = "middle"; + if (xLabel) ctx.fillText(xLabel, Math.min(x, w - 20), h - 10, 40); + ctx.textAlign = "right"; + if (yLabel) ctx.fillText(yLabel, 40, Math.max(10, y), 40); + ctx.textBaseline = "bottom"; + var right = []; + values.forEach(v => right.push(v.toFixed(7))); + ctx.fillStyle = "rgba(0, 0, 0, 0.75)"; + ctx.fillRect(w - 70, 0, 80, right.length * 15 + 5); + ctx.fillStyle = "#DDDD99"; + right.forEach((s, i) => ctx.fillText(s, w - 2, (i + 1) * 15, 70)); + ctx.restore(); + } + static fillDivData(container, d) { + container.innerHTML = ""; + if (!d) return; + var $ = d.$, + t = d.t, + e = d.e; + if (!t || !t.length || !t[0].length) return; + var l = t[0].length; + for (var i = 0; i < t.length; i++) { + var ch = t[i]; + var divCh = document.createElement("div"); + divCh.classList.add("static-scope-channel"); + divCh.style.backgroundColor = t.length === 1 ? "#181818" : "hsl(".concat(i * 60, ", 100%, 10%)"); + for (var j = 0; j < Math.min(ch.length, 2048); j++) { + var $j = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(j, $, l); + var divCell = document.createElement("div"); + divCell.classList.add("static-scope-cell"); + var $buffer = (d.$buffer || 0) + Math.floor(j / d.bufferSize); + if (e && e[$buffer] && e[$buffer].length && j % d.bufferSize === 0) divCell.classList.add("highlight"); + var spanIndex = document.createElement("span"); + spanIndex.innerText = j.toString(); + var spanSamp = document.createElement("span"); + spanSamp.innerText = ch[$j].toFixed(7); + divCell.appendChild(spanIndex); + divCell.appendChild(spanSamp); + divCh.appendChild(divCell); + } + if (ch.length > 2048) { + var _divCell = document.createElement("div"); + _divCell.classList.add("static-scope-cell"); + var _spanIndex = document.createElement("span"); + _spanIndex.innerText = "..."; + var _spanSamp = document.createElement("span"); + _spanSamp.innerText = "..."; + _divCell.appendChild(_spanIndex); + _divCell.appendChild(_spanSamp); + divCh.appendChild(_divCell); + } + container.appendChild(divCh); + } + } + static getIconClassName(typeIn) { + var prefix = "fas fa-sm "; + if (typeIn === EScopeMode.Data) return prefix + "fa-table"; + if (typeIn === EScopeMode.Interleaved) return prefix + "fa-water"; + if (typeIn === EScopeMode.Oscilloscope) return prefix + "fa-wave-square"; + if (typeIn === EScopeMode.Spectroscope) return prefix + "fa-chart-bar"; + if (typeIn === EScopeMode.Spectrogram) return prefix + "fa-align-justify"; + return prefix; + } + static getModeName(typeIn) { + if (typeIn === EScopeMode.Data) return "Data"; + if (typeIn === EScopeMode.Interleaved) return "Interleaved"; + if (typeIn === EScopeMode.Oscilloscope) return "Oscilloscope"; + if (typeIn === EScopeMode.Spectroscope) return "Spectroscope"; + if (typeIn === EScopeMode.Spectrogram) return "Spectrogram"; + return ""; + } + constructor(options) { + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "raf", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "ctx", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "container", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "canvas", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnSwitch", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnZoomOut", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnZoom", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnZoomIn", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "btnDownload", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "iSwitch", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "spanSwitch", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "divData", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "divDefault", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_mode", EScopeMode.Oscilloscope); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_zoom", { + oscilloscope: 1, + spectroscope: 1, + spectrogram: 1 + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_vzoom", { + oscilloscope: 1, + spectroscope: 1, + spectrogram: 1 + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "_zoomOffset", { + oscilloscope: 0, + spectroscope: 0, + spectrogram: 0 + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "data", { + drawMode: "manual", + t: undefined, + $: 0, + $buffer: 0, + bufferSize: 128, + fftSize: 256, + fftOverlap: 2 + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "cursor", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "dragging", false); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "spectTempCtx", void 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "lastSpect$", 0); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "drawSpectrogram", false); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "newDataArrived", false); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleMouseMove", e => { + if (!this.data || !this.data.t || !this.data.t.length || !this.data.t[0].length) return; + if (this.mode === EScopeMode.Data) return; + var w = this.container.clientWidth; + var h = this.container.clientHeight; + var rect = this.canvas.getBoundingClientRect(); + var x = e instanceof MouseEvent ? e.offsetX : e.touches[0].pageX - rect.left; + x = Math.max(0, Math.min(w, x)); + var y = e instanceof MouseEvent ? e.offsetY : e.touches[0].pageY - rect.top; + y = Math.max(0, Math.min(h, y)); + this.cursor = { + x, + y + }; + // if (this.data.drawMode === "continuous") return; + this.draw(); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleMouseDown", eDown => { + if (!this.data || !this.data.t || !this.data.t.length || !this.data.t[0].length) return; + if (this.mode === EScopeMode.Data) return; + eDown.preventDefault(); + eDown.stopPropagation(); + this.dragging = true; + this.canvas.style.cursor = "grab"; + var origZoom = this.zoom; + var origOffset = this.zoomOffset; + var prevX = eDown instanceof MouseEvent ? eDown.pageX : eDown.touches[0].pageX; + // let prevY = eDown instanceof MouseEvent ? eDown.pageY : eDown.touches[0].pageY; + var handleMouseMove = eMove => { + var x = eMove instanceof MouseEvent ? eMove.pageX : eMove.touches[0].pageX; + // const y = eMove instanceof MouseEvent ? eMove.pageY : eMove.touches[0].pageY; + var dX = x - prevX; + // const dY = y - prevY; + prevX = x; + // prevY = y; + // const multiplier = 1 / 1.015 ** dY; + var offset = -dX / this.zoom / this.canvas.width; + // if (multiplier !== 1) this.zoom *= multiplier; + if (offset !== 0) this.zoomOffset += offset; + if (this.zoom !== origZoom || this.zoomOffset !== origOffset) this.draw(); + }; + var handleMouseUp = () => { + this.dragging = false; + this.canvas.style.cursor = ""; + document.removeEventListener("mousemove", handleMouseMove); + document.removeEventListener("touchmove", handleMouseMove); + document.removeEventListener("mouseup", handleMouseUp); + document.removeEventListener("touchend", handleMouseUp); + }; + document.addEventListener("mousemove", handleMouseMove); + document.addEventListener("touchmove", handleMouseMove); + document.addEventListener("mouseup", handleMouseUp); + document.addEventListener("touchend", handleMouseUp); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "handleMouseLeave", () => { + if (!this.data || !this.data.t || !this.data.t.length || !this.data.t[0].length) return; + if (this.mode === EScopeMode.Data) return; + this.cursor = undefined; + this.draw(); + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "drawCallback", () => { + this.raf = undefined; + if (!this.data || !this.data.t || !this.data.t.length || !this.data.t[0].length) { + if (this.divDefault.style.display === "none") { + this.divDefault.style.display = "block"; + return; + } + } else if (this.divDefault.style.display !== "none") this.divDefault.style.display = "none"; + if (this.data && this.newDataArrived && this.drawSpectrogram) this.lastSpect$ = StaticScope.drawOfflineSpectrogram(this.spectTempCtx, this.data, this.lastSpect$); + if (this.data.drawMode === "continuous" && this.canvas.offsetParent === null) return; // not visible + var w = this.container.clientWidth; + var h = this.container.clientHeight; + if (this.canvas.width !== w) this.canvas.width = w; + if (this.canvas.height !== h) this.canvas.height = h; + if (this.mode === EScopeMode.Data) StaticScope.fillDivData(this.divData, this.data);else if (this.mode === EScopeMode.Interleaved) StaticScope.drawInterleaved(this.ctx, w, h, this.data, this.zoom, this.zoomOffset, this.vzoom, this.cursor);else if (this.mode === EScopeMode.Oscilloscope) StaticScope.drawOscilloscope(this.ctx, w, h, this.data, this.zoom, this.zoomOffset, this.vzoom, this.cursor);else if (this.mode === EScopeMode.Spectroscope) StaticScope.drawSpectroscope(this.ctx, w, h, this.data, this.zoom, this.zoomOffset, this.cursor);else if (this.mode === EScopeMode.Spectrogram) StaticScope.drawSpectrogram(this.ctx, this.spectTempCtx, w, h, this.data, this.zoom, this.zoomOffset, this.cursor); + this.newDataArrived = false; + }); + (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(this, "draw", data => { + if (data) { + this.data = data; + this.newDataArrived = true; + } + if (this.raf) return; + this.raf = requestAnimationFrame(this.drawCallback); + }); + Object.assign(this, options); + this.getChildren(); + this.bind(); + this.mode = EScopeMode.Oscilloscope; + } + getChildren() { + this.spectTempCtx = document.createElement("canvas").getContext("2d"); + this.spectTempCtx.canvas.height = 1024; + var ctrl; + for (var i = 0; i < this.container.children.length; i++) { + var e = this.container.children[i]; + if (e.classList.contains("static-scope-ui-controller")) ctrl = e; + if (e.classList.contains("static-scope-canvas")) this.canvas = e; + if (e.classList.contains("static-scope-data")) this.divData = e; + if (e.classList.contains("static-scope-default")) this.divDefault = e; + } + if (!ctrl) { + ctrl = document.createElement("div"); + ctrl.classList.add("static-scope-ui-controller"); + this.container.appendChild(ctrl); + } + if (!this.canvas) { + var canvas = document.createElement("canvas"); + canvas.classList.add("static-scope-canvas"); + this.container.appendChild(canvas); + this.canvas = canvas; + } + if (!this.divData) { + var divData = document.createElement("div"); + divData.classList.add("static-scope-data"); + this.container.appendChild(divData); + this.divData = divData; + } + if (!this.divDefault) { + var divDefault = document.createElement("div"); + divDefault.classList.add("static-scope-default", "alert", "alert-info"); + divDefault.setAttribute("role", "alert"); + divDefault.innerHTML = "
No Data
"; + this.container.appendChild(divDefault); + this.divDefault = divDefault; + } + this.ctx = this.canvas.getContext("2d"); + for (var _i7 = 0; _i7 < ctrl.children.length; _i7++) { + var _e = ctrl.children[_i7]; + if (_e.classList.contains("static-scope-ui-switch")) this.btnSwitch = _e; + if (_e.classList.contains("static-scope-ui-zoomout")) this.btnZoomOut = _e; + if (_e.classList.contains("static-scope-ui-zoom")) this.btnZoom = _e; + if (_e.classList.contains("static-scope-ui-zoomin")) this.btnZoomIn = _e; + if (_e.classList.contains("static-scope-ui-download")) this.btnDownload = _e; + } + if (!this.btnSwitch) { + var btn = document.createElement("button"); + btn.className = "static-scope-ui-switch btn btn-outline-light btn-sm btn-overlay btn-overlay-icon"; + btn.setAttribute("data-toggle", "tooltip"); + btn.setAttribute("data-placement", "top"); + btn.setAttribute("title", "Interleaved Scope / Stacked Scope / Data"); + ctrl.appendChild(btn); + try { + $(btn).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + this.btnSwitch = btn; + } + if (!this.btnZoomOut) { + var _btn = document.createElement("button"); + _btn.className = "static-scope-ui-zoomout btn btn-outline-light btn-sm btn-overlay btn-overlay-icon"; + _btn.setAttribute("data-toggle", "tooltip"); + _btn.setAttribute("data-placement", "top"); + _btn.setAttribute("title", "Zoom Out"); + _btn.innerHTML = ''; + ctrl.appendChild(_btn); + try { + $(_btn).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + this.btnZoomOut = _btn; + } + if (!this.btnZoom) { + var _btn2 = document.createElement("button"); + _btn2.className = "static-scope-ui-zoom btn btn-outline-light btn-sm btn-overlay"; + _btn2.setAttribute("data-toggle", "tooltip"); + _btn2.setAttribute("data-placement", "top"); + _btn2.setAttribute("title", "Reset Zoom"); + _btn2.innerText = "1.0x"; + ctrl.appendChild(_btn2); + try { + $(_btn2).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + this.btnZoom = _btn2; + } + if (!this.btnZoomIn) { + var _btn3 = document.createElement("button"); + _btn3.className = "static-scope-ui-zoomin btn btn-outline-light btn-sm btn-overlay btn-overlay-icon"; + _btn3.setAttribute("data-toggle", "tooltip"); + _btn3.setAttribute("data-placement", "top"); + _btn3.setAttribute("title", "Zoom In"); + _btn3.innerHTML = ''; + ctrl.appendChild(_btn3); + try { + $(_btn3).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + this.btnZoomIn = _btn3; + } + if (!this.btnDownload) { + var _btn4 = document.createElement("button"); + _btn4.className = "static-scope-ui-download btn btn-outline-light btn-sm btn-overlay btn-overlay-icon"; + _btn4.setAttribute("data-toggle", "tooltip"); + _btn4.setAttribute("data-placement", "top"); + _btn4.setAttribute("title", "Download Data"); + _btn4.innerHTML = ''; + ctrl.appendChild(_btn4); + try { + $(_btn4).tooltip({ + trigger: "hover", + boundary: "viewport" + }); + } catch (e) {} // eslint-disable-line no-empty + this.btnDownload = _btn4; + } + for (var _i8 = 0; _i8 < this.btnSwitch.children.length; _i8++) { + var _e2 = this.btnSwitch.children[_i8]; + if (_e2.classList.contains("fas")) this.iSwitch = _e2; + if (_e2 instanceof HTMLSpanElement) this.spanSwitch = _e2; + } + if (!this.iSwitch) { + var _i9 = document.createElement("i"); + _i9.className = "fas fa-sm fa-wave-square"; + this.btnSwitch.appendChild(_i9); + this.iSwitch = _i9; + } + if (!this.spanSwitch) { + var span = document.createElement("span"); + span.innerText = "Oscilloscope"; + this.btnSwitch.appendChild(span); + this.spanSwitch = span; + } + } + bind() { + this.btnSwitch.addEventListener("click", () => { + var newType = (this.mode + 1) % 5; + if (newType === EScopeMode.Spectrogram && !this.drawSpectrogram) newType = (newType + 1) % 5; + if (newType === EScopeMode.Data && this.data.drawMode === "continuous") newType = (newType + 1) % 5; + if (newType === EScopeMode.Interleaved && this.data.t && this.data.t.length === 1) newType = (newType + 1) % 5; + this.mode = newType; + }); + this.canvas.addEventListener("click", () => {}); + this.canvas.addEventListener("wheel", e => { + var left = 50; + var bottom = 20; + var multiplier = Math.pow(1.5, e.deltaY > 0 ? -1 : 1); + if (e.offsetX < left && e.offsetY < this.canvas.height - bottom) { + if (multiplier !== 1) this.vzoom *= 1 / multiplier; + this.draw(); + } else { + if (multiplier !== 1) this.zoom *= multiplier; + if (e.deltaX !== 0) this.zoomOffset += (e.deltaX > 0 ? 1 : -1) * 0.1; + this.handleMouseMove(e); + } + }); + this.btnZoomOut.addEventListener("click", () => { + this.zoom /= 1.5; + this.draw(); + }); + this.btnZoom.addEventListener("click", () => { + this.zoom = 1; + this.draw(); + }); + this.btnZoomIn.addEventListener("click", () => { + this.zoom *= 1.5; + this.draw(); + }); + this.btnDownload.addEventListener("click", () => { + var data = ""; + if (this.mode === EScopeMode.Data || this.mode === EScopeMode.Interleaved || this.mode === EScopeMode.Oscilloscope) { + if (this.data.t) { + var _this$data = this.data, + t = _this$data.t, + _$ = _this$data.$; + if (!t || !t.length || !t[0].length) return; + var l = t[0].length; + data += new Array(t.length).fill(null).map((v, i) => "channel".concat(i + 1)).join(",") + "\n"; + for (var j = 0; j < l; j++) { + for (var i = 0; i < t.length; i++) { + var $j = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(j, _$, l); + var samp = t[i][$j]; + data += samp + (i === t.length - 1 ? "\n" : ","); + } + } + } + } else if (this.mode === EScopeMode.Spectroscope) { + var _this$data2 = this.data, + _$2 = _this$data2.$, + f = _this$data2.f, + fftSize = _this$data2.fftSize, + fftOverlap = _this$data2.fftOverlap; + if (!f || !f.length || !f[0].length) return; + var fftBins = fftSize / 2; + var $f = _$2 * fftOverlap / 2; + $f -= $f % fftBins; + var _l = f[0].length; + data += new Array(f.length).fill(null).map((v, i) => "channel".concat(i + 1)).join(",") + "\n"; + for (var _j5 = _l - fftBins; _j5 < _l; _j5++) { + for (var _i10 = 0; _i10 < f.length; _i10++) { + var _$j4 = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(_j5, $f, _l); + var _samp4 = f[_i10][_$j4]; + data += _samp4 + (_i10 === f.length - 1 ? "\n" : ","); + } + } + } else if (this.mode === EScopeMode.Spectrogram) { + var _this$data3 = this.data, + _$3 = _this$data3.$, + _f = _this$data3.f, + _fftSize = _this$data3.fftSize, + _fftOverlap = _this$data3.fftOverlap; + if (!_f || !_f.length || !_f[0].length) return; + var _fftBins = _fftSize / 2; + var _$f = _$3 * _fftOverlap / 2; + _$f -= _$f % _fftBins; + var _l2 = _f[0].length; + data += new Array(_l2 / _fftBins).fill(null).map((v, i) => new Array(_f.length).fill(null).map((v, j) => "frame".concat(i + 1, "_channel").concat(j + 1)).join(",")).join(",") + "\n"; + for (var _j6 = 0; _j6 < _fftBins; _j6++) { + for (var h = 0; h < _l2 / _fftBins; h++) { + for (var _i11 = 0; _i11 < _f.length; _i11++) { + var _$j5 = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.wrap)(h * _fftBins + _j6, _$f, _l2); + var _samp5 = _f[_i11][_$j5]; + data += _samp5 + (_i11 === _f.length - 1 && h === _l2 / _fftBins - 1 ? "\n" : ","); + } + } + } + } + if (!data) return; + var blob = new Blob([data]); + var url = URL.createObjectURL(blob); + var a = document.createElement("a"); + a.href = url; + a.download = "data.csv"; + a.target = "_blank"; + a.click(); + }); + this.canvas.addEventListener("mousedown", this.handleMouseDown); + this.canvas.addEventListener("touchstart", this.handleMouseDown); + this.canvas.addEventListener("mousemove", this.handleMouseMove); + this.canvas.addEventListener("touchmove", this.handleMouseMove); + this.canvas.addEventListener("mouseleave", this.handleMouseLeave); + this.canvas.addEventListener("touchend", this.handleMouseLeave); + } + get zoomType() { + return this.mode === EScopeMode.Spectroscope ? "spectroscope" : this.mode === EScopeMode.Spectrogram ? "spectrogram" : "oscilloscope"; + } + get vzoom() { + return this._vzoom[this.zoomType]; + } + set vzoom(zoomIn) { + var maxZoom = 16; + this._vzoom[this.zoomType] = Math.min(maxZoom, Math.max(1, zoomIn)); + } + get zoom() { + return this._zoom[this.zoomType]; + } + set zoom(zoomIn) { + var maxZoom = this.data && this.data.t && this.data.t[0] ? Math.max(16, this.mode === EScopeMode.Spectroscope ? 16 : this.data.t[0].length / (this.inFreqDomain ? this.data.fftSize / 2 : this.data.bufferSize)) : 16; + var w = this.canvas.width; + var cursorIn = 0.5; + var left = 50; + if (this.cursor) cursorIn = Math.max(0, this.cursor.x - left) / (w - left); + var cursor = this.zoomOffset + cursorIn / this.zoom; + this._zoom[this.zoomType] = Math.min(maxZoom, Math.max(1, zoomIn)); + this.zoomOffset = cursor - cursorIn / this.zoom; + this.btnZoom.innerHTML = this.zoom.toFixed(1) + "x"; + } + get zoomOffset() { + return this._zoomOffset[this.zoomType]; + } + set zoomOffset(zoomOffsetIn) { + this._zoomOffset[this.zoomType] = Math.max(0, Math.min(1 - 1 / this.zoom, zoomOffsetIn)); + } + resetZoom() { + this._zoom = { + oscilloscope: 1, + spectroscope: 1, + spectrogram: 1 + }; + this._zoomOffset = { + oscilloscope: 0, + spectroscope: 0, + spectrogram: 0 + }; + } + get mode() { + return this._mode; + } + set mode(modeIn) { + this.iSwitch.className = StaticScope.getIconClassName(modeIn); + this.spanSwitch.innerText = StaticScope.getModeName(modeIn); + this._mode = modeIn; + if (modeIn === EScopeMode.Data) { + this.divData.style.display = ""; + this.canvas.style.display = "none"; + this.btnZoom.style.display = "none"; + this.btnZoomIn.style.display = "none"; + this.btnZoomOut.style.display = "none"; + } else { + this.divData.style.display = "none"; + this.canvas.style.display = ""; + this.btnZoom.style.display = ""; + this.btnZoomIn.style.display = ""; + this.btnZoomOut.style.display = ""; + } + this.draw(); + } + get inFreqDomain() { + return this.mode === EScopeMode.Spectrogram || this.mode === EScopeMode.Spectroscope; + } +} + +/***/ }), + +/***/ "./src/documentation.ts": +/*!******************************!*\ + !*** ./src/documentation.ts ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ docSections: () => (/* binding */ docSections), +/* harmony export */ faustDocURL: () => (/* binding */ faustDocURL) +/* harmony export */ }); +// Definitions related to the libraries documentation system + +var faustDocURL = "https://faustlibraries.grame.fr/libs"; +var docSections = { + aa: "aanl", + an: "analyzers", + ba: "basics", + co: "compressors", + de: "delays", + dm: "demos", + dx: "dx7", + en: "envelopes", + fd: "fds", + fi: "filters", + ho: "hoa", + it: "interpolators", + ma: "maths", + mi: "mi", + ef: "misceffects", + os: "oscillators", + no: "noises", + pf: "phaflangers", + pm: "physmodels", + qu: "quantizers", + rm: "reducemaps", + re: "reverbs", + ro: "routes", + si: "signals", + so: "soundfiles", + sp: "spats", + sy: "synths", + ve: "vaeffects", + vl: "version", + wa: "webaudio", + wd: "wdmodels" +}; + +/***/ }), + +/***/ "./src/monaco-faust/register.ts": +/*!**************************************!*\ + !*** ./src/monaco-faust/register.ts ***! + \**************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ faustLangRegister: () => (/* binding */ faustLangRegister) +/* harmony export */ }); +/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js"); +/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/regenerator */ "./node_modules/@babel/runtime/regenerator/index.js"); +/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_1__); + + +var faustLangRegister = /*#__PURE__*/function () { + var _ref = (0,_babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_0__["default"])( /*#__PURE__*/_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_1___default().mark(function _callee(monacoEditor, libFaust) { + var faustLang, providers; + return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_1___default().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + _context.next = 2; + return Promise.all(/*! import() */[__webpack_require__.e("vendors-include-loader_node_modules_monaco-editor_esm_vs_editor_editor_main_js"), __webpack_require__.e("src_monaco-faust_FaustLang_ts")]).then(__webpack_require__.bind(__webpack_require__, /*! ./FaustLang */ "./src/monaco-faust/FaustLang.ts")); + case 2: + faustLang = _context.sent; + monacoEditor.languages.register(faustLang.language); + monacoEditor.languages.setLanguageConfiguration("faust", faustLang.config); + monacoEditor.editor.defineTheme("vs-dark", faustLang.theme); + _context.next = 8; + return faustLang.getProviders(libFaust); + case 8: + providers = _context.sent; + monacoEditor.languages.registerHoverProvider("faust", providers.hoverProvider); + monacoEditor.languages.setMonarchTokensProvider("faust", providers.tokensProvider); + monacoEditor.languages.registerCompletionItemProvider("faust", providers.completionItemProvider); + return _context.abrupt("return", { + providers, + faustLang + }); + case 13: + case "end": + return _context.stop(); + } + }, _callee); + })); + return function faustLangRegister(_x, _x2) { + return _ref.apply(this, arguments); + }; +}(); + +/***/ }), + +/***/ "./src/utils.ts": +/*!**********************!*\ + !*** ./src/utils.ts ***! + \**********************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ estimateFreq: () => (/* binding */ estimateFreq), +/* harmony export */ fillRectWrap: () => (/* binding */ fillRectWrap), +/* harmony export */ getFrequencyDomainData: () => (/* binding */ getFrequencyDomainData), +/* harmony export */ getRms: () => (/* binding */ getRms), +/* harmony export */ indexToFreq: () => (/* binding */ indexToFreq), +/* harmony export */ mod: () => (/* binding */ mod), +/* harmony export */ safeStorage: () => (/* binding */ safeStorage), +/* harmony export */ setWrap: () => (/* binding */ setWrap), +/* harmony export */ sliceWrap: () => (/* binding */ sliceWrap), +/* harmony export */ wrap: () => (/* binding */ wrap) +/* harmony export */ }); +/* harmony import */ var window_function_apply__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! window-function/apply */ "./node_modules/window-function/apply.js"); +/* harmony import */ var window_function_apply__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(window_function_apply__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var window_function__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! window-function */ "./node_modules/window-function/index.js"); +/* harmony import */ var window_function__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(window_function__WEBPACK_IMPORTED_MODULE_1__); + + + +/* eslint-disable no-param-reassign */ +/** + * Mod support wrapping with negative numbers + * + * @param {number} x + * @param {number} y + */ +var mod = (x, y) => (x % y + y) % y; +var wrap = (i, $, l) => mod(i + $, l); + +/** + * Copy a Float32Array by given offset and length, + * support negative pointer, will be wrapped correctly + * + * @param {Float32Array} src + * @param {number} [$begin] + * @param {number} [length] + * @returns + */ +var sliceWrap = (src, $begin, length) => { + if (typeof $begin === "undefined") $begin = 0; + if (typeof length === "undefined") length = src.length - $begin; + var dest = new Float32Array(length); + length = Math.min(src.length, length); + var $dest = 0; + while (length) { + $begin = mod($begin, src.length); + var amount = Math.min(length, src.length - $begin); + if ($begin === 0 && amount === src.length) dest.set(src, $dest);else dest.set(src.subarray($begin, $begin + amount), $dest); + $begin += amount; + length -= amount; + $dest += amount; + } + return dest; +}; + +/** + * Set a Float32Array with another by given offset, + * support negative pointer, will be wrapped correctly + * + * @param {Float32Array} dest + * @param {Float32Array} src + * @param {number} [$dest] + * @returns + */ +var setWrap = (dest, src, $dest) => { + if (typeof $dest === "undefined") $dest = 0; + var $src = 0; + var length = Math.min(dest.length, src.length); + while (length) { + $dest = mod($dest, dest.length); + var amount = Math.min(length, dest.length - $dest); + if ($src === 0 && amount === src.length) dest.set(src, $dest); + dest.set(sliceWrap(src, $src, amount), $dest); + $src += amount; + $dest += amount; + length -= amount; + } + return dest; +}; + +/** + * CanvasRenderingContext2D.fillRect with wrap + * + * @param {CanvasRenderingContext2D} ctx + * @param {number} x + * @param {number} y + * @param {number} w + * @param {number} h + */ +var fillRectWrap = (ctx, x, y, w, h, canvasWidth, canvasHeight) => { + var width = canvasWidth; + var height = canvasHeight; + if (!width && !height) { + var _ctx$canvas = ctx.canvas; + width = _ctx$canvas.width; + height = _ctx$canvas.height; + } else if (!width) width = ctx.canvas.width;else if (!height) height = ctx.canvas.height; + var $x = 0; + while ($x < w) { + var $y = 0; + var startX = wrap($x + x, 0, width); + var drawW = startX + w < width ? w : width - startX; + while ($y < h) { + var startY = wrap($y + y, 0, height); + var drawH = startY + h < height ? h : height - startY; + ctx.fillRect(startX, startY, drawW, drawH); + $y += drawH; + } + $x += drawW; + } +}; + +/** + * Calcute FFT power, result array is half sized + * + * @param {Float32Array} t + * @param {FFT} fft + * @returns + */ +var getFrequencyDomainData = (t, fft) => { + // eslint-disable-line arrow-body-style + var ffted = fft.forward(window_function_apply__WEBPACK_IMPORTED_MODULE_0___default()(t, window_function__WEBPACK_IMPORTED_MODULE_1__.blackman)); + var f = new Float32Array(t.length / 2); + for (var i = 0; i < f.length; i++) { + f[i] = 20 * Math.log10(Math.pow(Math.pow(ffted[i * 2], 2) + Math.pow(ffted[i * 2 + 1], 2), 0.5) / f.length * 2.38328); + } + return f; +}; +var estimateFreq = (fft, sampleRate) => { + var index = 0; + var max = -Infinity; + var i = fft.length; + while (i-- > 1) { + var cur = fft[i]; + if (cur <= max) continue; + max = cur; + index = i; + } + return sampleRate / 2 * index / fft.length; +}; +var indexToFreq = (i, fftBins, sampleRate) => i % fftBins / fftBins * sampleRate / 2; +var getRms = t => { + var i = t.length; + var squareSum = 0; + while (i--) { + squareSum += Math.pow(t[i], 2); + } + return Math.pow(squareSum / t.length, 0.5); +}; +var safeStorage = (() => { + var tryLocalStorage = function tryLocalStorage(method) { + try { + for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + rest[_key - 1] = arguments[_key]; + } + return localStorage[method](...rest); + } catch (_unused) { + return ""; + } + }; + return { + setItem: (key, val) => tryLocalStorage("setItem", key, val), + removeItem: key => tryLocalStorage("removeItem", key), + getItem: key => tryLocalStorage("getItem", key) + }; +})(); + +/***/ }), + +/***/ "./src/version.js": +/*!************************!*\ + !*** ./src/version.js ***! + \************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +/* eslint-disable @typescript-eslint/no-var-requires */ +var _require = __webpack_require__(/*! ../package.json */ "./package.json"), + version = _require.version; +module.exports = version; + +/***/ }), + +/***/ "./node_modules/bootstrap/js/dist/dropdown.js": +/*!****************************************************!*\ + !*** ./node_modules/bootstrap/js/dist/dropdown.js ***! + \****************************************************/ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*! + * Bootstrap dropdown.js v4.6.2 (https://getbootstrap.com/) + * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ +(function (global, factory) { + true ? module.exports = factory(__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"), __webpack_require__(/*! popper.js */ "./node_modules/popper.js/dist/esm/popper.js"), __webpack_require__(/*! ./util.js */ "./node_modules/bootstrap/js/dist/util.js")) : + 0; +})(this, (function ($, Popper, Util) { 'use strict'; + + function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + + var $__default = /*#__PURE__*/_interopDefaultLegacy($); + var Popper__default = /*#__PURE__*/_interopDefaultLegacy(Popper); + var Util__default = /*#__PURE__*/_interopDefaultLegacy(Util); + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + + function _extends() { + _extends = Object.assign ? Object.assign.bind() : function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + return _extends.apply(this, arguments); + } + + /** + * Constants + */ + + var NAME = 'dropdown'; + var VERSION = '4.6.2'; + var DATA_KEY = 'bs.dropdown'; + var EVENT_KEY = "." + DATA_KEY; + var DATA_API_KEY = '.data-api'; + var JQUERY_NO_CONFLICT = $__default["default"].fn[NAME]; + var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key + + var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key + + var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key + + var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key + + var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key + + var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse) + + var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE); + var CLASS_NAME_DISABLED = 'disabled'; + var CLASS_NAME_SHOW = 'show'; + var CLASS_NAME_DROPUP = 'dropup'; + var CLASS_NAME_DROPRIGHT = 'dropright'; + var CLASS_NAME_DROPLEFT = 'dropleft'; + var CLASS_NAME_MENURIGHT = 'dropdown-menu-right'; + var CLASS_NAME_POSITION_STATIC = 'position-static'; + var EVENT_HIDE = "hide" + EVENT_KEY; + var EVENT_HIDDEN = "hidden" + EVENT_KEY; + var EVENT_SHOW = "show" + EVENT_KEY; + var EVENT_SHOWN = "shown" + EVENT_KEY; + var EVENT_CLICK = "click" + EVENT_KEY; + var EVENT_CLICK_DATA_API = "click" + EVENT_KEY + DATA_API_KEY; + var EVENT_KEYDOWN_DATA_API = "keydown" + EVENT_KEY + DATA_API_KEY; + var EVENT_KEYUP_DATA_API = "keyup" + EVENT_KEY + DATA_API_KEY; + var SELECTOR_DATA_TOGGLE = '[data-toggle="dropdown"]'; + var SELECTOR_FORM_CHILD = '.dropdown form'; + var SELECTOR_MENU = '.dropdown-menu'; + var SELECTOR_NAVBAR_NAV = '.navbar-nav'; + var SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; + var PLACEMENT_TOP = 'top-start'; + var PLACEMENT_TOPEND = 'top-end'; + var PLACEMENT_BOTTOM = 'bottom-start'; + var PLACEMENT_BOTTOMEND = 'bottom-end'; + var PLACEMENT_RIGHT = 'right-start'; + var PLACEMENT_LEFT = 'left-start'; + var Default = { + offset: 0, + flip: true, + boundary: 'scrollParent', + reference: 'toggle', + display: 'dynamic', + popperConfig: null + }; + var DefaultType = { + offset: '(number|string|function)', + flip: 'boolean', + boundary: '(string|element)', + reference: '(string|element)', + display: 'string', + popperConfig: '(null|object)' + }; + /** + * Class definition + */ + + var Dropdown = /*#__PURE__*/function () { + function Dropdown(element, config) { + this._element = element; + this._popper = null; + this._config = this._getConfig(config); + this._menu = this._getMenuElement(); + this._inNavbar = this._detectNavbar(); + + this._addEventListeners(); + } // Getters + + + var _proto = Dropdown.prototype; + + // Public + _proto.toggle = function toggle() { + if (this._element.disabled || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED)) { + return; + } + + var isActive = $__default["default"](this._menu).hasClass(CLASS_NAME_SHOW); + + Dropdown._clearMenus(); + + if (isActive) { + return; + } + + this.show(true); + }; + + _proto.show = function show(usePopper) { + if (usePopper === void 0) { + usePopper = false; + } + + if (this._element.disabled || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED) || $__default["default"](this._menu).hasClass(CLASS_NAME_SHOW)) { + return; + } + + var relatedTarget = { + relatedTarget: this._element + }; + var showEvent = $__default["default"].Event(EVENT_SHOW, relatedTarget); + + var parent = Dropdown._getParentFromElement(this._element); + + $__default["default"](parent).trigger(showEvent); + + if (showEvent.isDefaultPrevented()) { + return; + } // Totally disable Popper for Dropdowns in Navbar + + + if (!this._inNavbar && usePopper) { + // Check for Popper dependency + if (typeof Popper__default["default"] === 'undefined') { + throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)'); + } + + var referenceElement = this._element; + + if (this._config.reference === 'parent') { + referenceElement = parent; + } else if (Util__default["default"].isElement(this._config.reference)) { + referenceElement = this._config.reference; // Check if it's jQuery element + + if (typeof this._config.reference.jquery !== 'undefined') { + referenceElement = this._config.reference[0]; + } + } // If boundary is not `scrollParent`, then set position to `static` + // to allow the menu to "escape" the scroll parent's boundaries + // https://github.com/twbs/bootstrap/issues/24251 + + + if (this._config.boundary !== 'scrollParent') { + $__default["default"](parent).addClass(CLASS_NAME_POSITION_STATIC); + } + + this._popper = new Popper__default["default"](referenceElement, this._menu, this._getPopperConfig()); + } // If this is a touch-enabled device we add extra + // empty mouseover listeners to the body's immediate children; + // only needed because of broken event delegation on iOS + // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html + + + if ('ontouchstart' in document.documentElement && $__default["default"](parent).closest(SELECTOR_NAVBAR_NAV).length === 0) { + $__default["default"](document.body).children().on('mouseover', null, $__default["default"].noop); + } + + this._element.focus(); + + this._element.setAttribute('aria-expanded', true); + + $__default["default"](this._menu).toggleClass(CLASS_NAME_SHOW); + $__default["default"](parent).toggleClass(CLASS_NAME_SHOW).trigger($__default["default"].Event(EVENT_SHOWN, relatedTarget)); + }; + + _proto.hide = function hide() { + if (this._element.disabled || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED) || !$__default["default"](this._menu).hasClass(CLASS_NAME_SHOW)) { + return; + } + + var relatedTarget = { + relatedTarget: this._element + }; + var hideEvent = $__default["default"].Event(EVENT_HIDE, relatedTarget); + + var parent = Dropdown._getParentFromElement(this._element); + + $__default["default"](parent).trigger(hideEvent); + + if (hideEvent.isDefaultPrevented()) { + return; + } + + if (this._popper) { + this._popper.destroy(); + } + + $__default["default"](this._menu).toggleClass(CLASS_NAME_SHOW); + $__default["default"](parent).toggleClass(CLASS_NAME_SHOW).trigger($__default["default"].Event(EVENT_HIDDEN, relatedTarget)); + }; + + _proto.dispose = function dispose() { + $__default["default"].removeData(this._element, DATA_KEY); + $__default["default"](this._element).off(EVENT_KEY); + this._element = null; + this._menu = null; + + if (this._popper !== null) { + this._popper.destroy(); + + this._popper = null; + } + }; + + _proto.update = function update() { + this._inNavbar = this._detectNavbar(); + + if (this._popper !== null) { + this._popper.scheduleUpdate(); + } + } // Private + ; + + _proto._addEventListeners = function _addEventListeners() { + var _this = this; + + $__default["default"](this._element).on(EVENT_CLICK, function (event) { + event.preventDefault(); + event.stopPropagation(); + + _this.toggle(); + }); + }; + + _proto._getConfig = function _getConfig(config) { + config = _extends({}, this.constructor.Default, $__default["default"](this._element).data(), config); + Util__default["default"].typeCheckConfig(NAME, config, this.constructor.DefaultType); + return config; + }; + + _proto._getMenuElement = function _getMenuElement() { + if (!this._menu) { + var parent = Dropdown._getParentFromElement(this._element); + + if (parent) { + this._menu = parent.querySelector(SELECTOR_MENU); + } + } + + return this._menu; + }; + + _proto._getPlacement = function _getPlacement() { + var $parentDropdown = $__default["default"](this._element.parentNode); + var placement = PLACEMENT_BOTTOM; // Handle dropup + + if ($parentDropdown.hasClass(CLASS_NAME_DROPUP)) { + placement = $__default["default"](this._menu).hasClass(CLASS_NAME_MENURIGHT) ? PLACEMENT_TOPEND : PLACEMENT_TOP; + } else if ($parentDropdown.hasClass(CLASS_NAME_DROPRIGHT)) { + placement = PLACEMENT_RIGHT; + } else if ($parentDropdown.hasClass(CLASS_NAME_DROPLEFT)) { + placement = PLACEMENT_LEFT; + } else if ($__default["default"](this._menu).hasClass(CLASS_NAME_MENURIGHT)) { + placement = PLACEMENT_BOTTOMEND; + } + + return placement; + }; + + _proto._detectNavbar = function _detectNavbar() { + return $__default["default"](this._element).closest('.navbar').length > 0; + }; + + _proto._getOffset = function _getOffset() { + var _this2 = this; + + var offset = {}; + + if (typeof this._config.offset === 'function') { + offset.fn = function (data) { + data.offsets = _extends({}, data.offsets, _this2._config.offset(data.offsets, _this2._element)); + return data; + }; + } else { + offset.offset = this._config.offset; + } + + return offset; + }; + + _proto._getPopperConfig = function _getPopperConfig() { + var popperConfig = { + placement: this._getPlacement(), + modifiers: { + offset: this._getOffset(), + flip: { + enabled: this._config.flip + }, + preventOverflow: { + boundariesElement: this._config.boundary + } + } + }; // Disable Popper if we have a static display + + if (this._config.display === 'static') { + popperConfig.modifiers.applyStyle = { + enabled: false + }; + } + + return _extends({}, popperConfig, this._config.popperConfig); + } // Static + ; + + Dropdown._jQueryInterface = function _jQueryInterface(config) { + return this.each(function () { + var data = $__default["default"](this).data(DATA_KEY); + + var _config = typeof config === 'object' ? config : null; + + if (!data) { + data = new Dropdown(this, _config); + $__default["default"](this).data(DATA_KEY, data); + } + + if (typeof config === 'string') { + if (typeof data[config] === 'undefined') { + throw new TypeError("No method named \"" + config + "\""); + } + + data[config](); + } + }); + }; + + Dropdown._clearMenus = function _clearMenus(event) { + if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) { + return; + } + + var toggles = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLE)); + + for (var i = 0, len = toggles.length; i < len; i++) { + var parent = Dropdown._getParentFromElement(toggles[i]); + + var context = $__default["default"](toggles[i]).data(DATA_KEY); + var relatedTarget = { + relatedTarget: toggles[i] + }; + + if (event && event.type === 'click') { + relatedTarget.clickEvent = event; + } + + if (!context) { + continue; + } + + var dropdownMenu = context._menu; + + if (!$__default["default"](parent).hasClass(CLASS_NAME_SHOW)) { + continue; + } + + if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $__default["default"].contains(parent, event.target)) { + continue; + } + + var hideEvent = $__default["default"].Event(EVENT_HIDE, relatedTarget); + $__default["default"](parent).trigger(hideEvent); + + if (hideEvent.isDefaultPrevented()) { + continue; + } // If this is a touch-enabled device we remove the extra + // empty mouseover listeners we added for iOS support + + + if ('ontouchstart' in document.documentElement) { + $__default["default"](document.body).children().off('mouseover', null, $__default["default"].noop); + } + + toggles[i].setAttribute('aria-expanded', 'false'); + + if (context._popper) { + context._popper.destroy(); + } + + $__default["default"](dropdownMenu).removeClass(CLASS_NAME_SHOW); + $__default["default"](parent).removeClass(CLASS_NAME_SHOW).trigger($__default["default"].Event(EVENT_HIDDEN, relatedTarget)); + } + }; + + Dropdown._getParentFromElement = function _getParentFromElement(element) { + var parent; + var selector = Util__default["default"].getSelectorFromElement(element); + + if (selector) { + parent = document.querySelector(selector); + } + + return parent || element.parentNode; + } // eslint-disable-next-line complexity + ; + + Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) { + // If not input/textarea: + // - And not a key in REGEXP_KEYDOWN => not a dropdown command + // If input/textarea: + // - If space key => not a dropdown command + // - If key is other than escape + // - If key is not up or down => not a dropdown command + // - If trigger inside the menu => not a dropdown command + if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $__default["default"](event.target).closest(SELECTOR_MENU).length) : !REGEXP_KEYDOWN.test(event.which)) { + return; + } + + if (this.disabled || $__default["default"](this).hasClass(CLASS_NAME_DISABLED)) { + return; + } + + var parent = Dropdown._getParentFromElement(this); + + var isActive = $__default["default"](parent).hasClass(CLASS_NAME_SHOW); + + if (!isActive && event.which === ESCAPE_KEYCODE) { + return; + } + + event.preventDefault(); + event.stopPropagation(); + + if (!isActive || event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE) { + if (event.which === ESCAPE_KEYCODE) { + $__default["default"](parent.querySelector(SELECTOR_DATA_TOGGLE)).trigger('focus'); + } + + $__default["default"](this).trigger('click'); + return; + } + + var items = [].slice.call(parent.querySelectorAll(SELECTOR_VISIBLE_ITEMS)).filter(function (item) { + return $__default["default"](item).is(':visible'); + }); + + if (items.length === 0) { + return; + } + + var index = items.indexOf(event.target); + + if (event.which === ARROW_UP_KEYCODE && index > 0) { + // Up + index--; + } + + if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { + // Down + index++; + } + + if (index < 0) { + index = 0; + } + + items[index].focus(); + }; + + _createClass(Dropdown, null, [{ + key: "VERSION", + get: function get() { + return VERSION; + } + }, { + key: "Default", + get: function get() { + return Default; + } + }, { + key: "DefaultType", + get: function get() { + return DefaultType; + } + }]); + + return Dropdown; + }(); + /** + * Data API implementation + */ + + + $__default["default"](document).on(EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown._dataApiKeydownHandler).on(EVENT_CLICK_DATA_API + " " + EVENT_KEYUP_DATA_API, Dropdown._clearMenus).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { + event.preventDefault(); + event.stopPropagation(); + + Dropdown._jQueryInterface.call($__default["default"](this), 'toggle'); + }).on(EVENT_CLICK_DATA_API, SELECTOR_FORM_CHILD, function (e) { + e.stopPropagation(); + }); + /** + * jQuery + */ + + $__default["default"].fn[NAME] = Dropdown._jQueryInterface; + $__default["default"].fn[NAME].Constructor = Dropdown; + + $__default["default"].fn[NAME].noConflict = function () { + $__default["default"].fn[NAME] = JQUERY_NO_CONFLICT; + return Dropdown._jQueryInterface; + }; + + return Dropdown; + +})); +//# sourceMappingURL=dropdown.js.map + + +/***/ }), + +/***/ "./node_modules/bootstrap/js/dist/modal.js": +/*!*************************************************!*\ + !*** ./node_modules/bootstrap/js/dist/modal.js ***! + \*************************************************/ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*! + * Bootstrap modal.js v4.6.2 (https://getbootstrap.com/) + * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ +(function (global, factory) { + true ? module.exports = factory(__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"), __webpack_require__(/*! ./util.js */ "./node_modules/bootstrap/js/dist/util.js")) : + 0; +})(this, (function ($, Util) { 'use strict'; + + function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + + var $__default = /*#__PURE__*/_interopDefaultLegacy($); + var Util__default = /*#__PURE__*/_interopDefaultLegacy(Util); + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + + function _extends() { + _extends = Object.assign ? Object.assign.bind() : function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + return _extends.apply(this, arguments); + } + + /** + * Constants + */ + + var NAME = 'modal'; + var VERSION = '4.6.2'; + var DATA_KEY = 'bs.modal'; + var EVENT_KEY = "." + DATA_KEY; + var DATA_API_KEY = '.data-api'; + var JQUERY_NO_CONFLICT = $__default["default"].fn[NAME]; + var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key + + var CLASS_NAME_SCROLLABLE = 'modal-dialog-scrollable'; + var CLASS_NAME_SCROLLBAR_MEASURER = 'modal-scrollbar-measure'; + var CLASS_NAME_BACKDROP = 'modal-backdrop'; + var CLASS_NAME_OPEN = 'modal-open'; + var CLASS_NAME_FADE = 'fade'; + var CLASS_NAME_SHOW = 'show'; + var CLASS_NAME_STATIC = 'modal-static'; + var EVENT_HIDE = "hide" + EVENT_KEY; + var EVENT_HIDE_PREVENTED = "hidePrevented" + EVENT_KEY; + var EVENT_HIDDEN = "hidden" + EVENT_KEY; + var EVENT_SHOW = "show" + EVENT_KEY; + var EVENT_SHOWN = "shown" + EVENT_KEY; + var EVENT_FOCUSIN = "focusin" + EVENT_KEY; + var EVENT_RESIZE = "resize" + EVENT_KEY; + var EVENT_CLICK_DISMISS = "click.dismiss" + EVENT_KEY; + var EVENT_KEYDOWN_DISMISS = "keydown.dismiss" + EVENT_KEY; + var EVENT_MOUSEUP_DISMISS = "mouseup.dismiss" + EVENT_KEY; + var EVENT_MOUSEDOWN_DISMISS = "mousedown.dismiss" + EVENT_KEY; + var EVENT_CLICK_DATA_API = "click" + EVENT_KEY + DATA_API_KEY; + var SELECTOR_DIALOG = '.modal-dialog'; + var SELECTOR_MODAL_BODY = '.modal-body'; + var SELECTOR_DATA_TOGGLE = '[data-toggle="modal"]'; + var SELECTOR_DATA_DISMISS = '[data-dismiss="modal"]'; + var SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; + var SELECTOR_STICKY_CONTENT = '.sticky-top'; + var Default = { + backdrop: true, + keyboard: true, + focus: true, + show: true + }; + var DefaultType = { + backdrop: '(boolean|string)', + keyboard: 'boolean', + focus: 'boolean', + show: 'boolean' + }; + /** + * Class definition + */ + + var Modal = /*#__PURE__*/function () { + function Modal(element, config) { + this._config = this._getConfig(config); + this._element = element; + this._dialog = element.querySelector(SELECTOR_DIALOG); + this._backdrop = null; + this._isShown = false; + this._isBodyOverflowing = false; + this._ignoreBackdropClick = false; + this._isTransitioning = false; + this._scrollbarWidth = 0; + } // Getters + + + var _proto = Modal.prototype; + + // Public + _proto.toggle = function toggle(relatedTarget) { + return this._isShown ? this.hide() : this.show(relatedTarget); + }; + + _proto.show = function show(relatedTarget) { + var _this = this; + + if (this._isShown || this._isTransitioning) { + return; + } + + var showEvent = $__default["default"].Event(EVENT_SHOW, { + relatedTarget: relatedTarget + }); + $__default["default"](this._element).trigger(showEvent); + + if (showEvent.isDefaultPrevented()) { + return; + } + + this._isShown = true; + + if ($__default["default"](this._element).hasClass(CLASS_NAME_FADE)) { + this._isTransitioning = true; + } + + this._checkScrollbar(); + + this._setScrollbar(); + + this._adjustDialog(); + + this._setEscapeEvent(); + + this._setResizeEvent(); + + $__default["default"](this._element).on(EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, function (event) { + return _this.hide(event); + }); + $__default["default"](this._dialog).on(EVENT_MOUSEDOWN_DISMISS, function () { + $__default["default"](_this._element).one(EVENT_MOUSEUP_DISMISS, function (event) { + if ($__default["default"](event.target).is(_this._element)) { + _this._ignoreBackdropClick = true; + } + }); + }); + + this._showBackdrop(function () { + return _this._showElement(relatedTarget); + }); + }; + + _proto.hide = function hide(event) { + var _this2 = this; + + if (event) { + event.preventDefault(); + } + + if (!this._isShown || this._isTransitioning) { + return; + } + + var hideEvent = $__default["default"].Event(EVENT_HIDE); + $__default["default"](this._element).trigger(hideEvent); + + if (!this._isShown || hideEvent.isDefaultPrevented()) { + return; + } + + this._isShown = false; + var transition = $__default["default"](this._element).hasClass(CLASS_NAME_FADE); + + if (transition) { + this._isTransitioning = true; + } + + this._setEscapeEvent(); + + this._setResizeEvent(); + + $__default["default"](document).off(EVENT_FOCUSIN); + $__default["default"](this._element).removeClass(CLASS_NAME_SHOW); + $__default["default"](this._element).off(EVENT_CLICK_DISMISS); + $__default["default"](this._dialog).off(EVENT_MOUSEDOWN_DISMISS); + + if (transition) { + var transitionDuration = Util__default["default"].getTransitionDurationFromElement(this._element); + $__default["default"](this._element).one(Util__default["default"].TRANSITION_END, function (event) { + return _this2._hideModal(event); + }).emulateTransitionEnd(transitionDuration); + } else { + this._hideModal(); + } + }; + + _proto.dispose = function dispose() { + [window, this._element, this._dialog].forEach(function (htmlElement) { + return $__default["default"](htmlElement).off(EVENT_KEY); + }); + /** + * `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API` + * Do not move `document` in `htmlElements` array + * It will remove `EVENT_CLICK_DATA_API` event that should remain + */ + + $__default["default"](document).off(EVENT_FOCUSIN); + $__default["default"].removeData(this._element, DATA_KEY); + this._config = null; + this._element = null; + this._dialog = null; + this._backdrop = null; + this._isShown = null; + this._isBodyOverflowing = null; + this._ignoreBackdropClick = null; + this._isTransitioning = null; + this._scrollbarWidth = null; + }; + + _proto.handleUpdate = function handleUpdate() { + this._adjustDialog(); + } // Private + ; + + _proto._getConfig = function _getConfig(config) { + config = _extends({}, Default, config); + Util__default["default"].typeCheckConfig(NAME, config, DefaultType); + return config; + }; + + _proto._triggerBackdropTransition = function _triggerBackdropTransition() { + var _this3 = this; + + var hideEventPrevented = $__default["default"].Event(EVENT_HIDE_PREVENTED); + $__default["default"](this._element).trigger(hideEventPrevented); + + if (hideEventPrevented.isDefaultPrevented()) { + return; + } + + var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; + + if (!isModalOverflowing) { + this._element.style.overflowY = 'hidden'; + } + + this._element.classList.add(CLASS_NAME_STATIC); + + var modalTransitionDuration = Util__default["default"].getTransitionDurationFromElement(this._dialog); + $__default["default"](this._element).off(Util__default["default"].TRANSITION_END); + $__default["default"](this._element).one(Util__default["default"].TRANSITION_END, function () { + _this3._element.classList.remove(CLASS_NAME_STATIC); + + if (!isModalOverflowing) { + $__default["default"](_this3._element).one(Util__default["default"].TRANSITION_END, function () { + _this3._element.style.overflowY = ''; + }).emulateTransitionEnd(_this3._element, modalTransitionDuration); + } + }).emulateTransitionEnd(modalTransitionDuration); + + this._element.focus(); + }; + + _proto._showElement = function _showElement(relatedTarget) { + var _this4 = this; + + var transition = $__default["default"](this._element).hasClass(CLASS_NAME_FADE); + var modalBody = this._dialog ? this._dialog.querySelector(SELECTOR_MODAL_BODY) : null; + + if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { + // Don't move modal's DOM position + document.body.appendChild(this._element); + } + + this._element.style.display = 'block'; + + this._element.removeAttribute('aria-hidden'); + + this._element.setAttribute('aria-modal', true); + + this._element.setAttribute('role', 'dialog'); + + if ($__default["default"](this._dialog).hasClass(CLASS_NAME_SCROLLABLE) && modalBody) { + modalBody.scrollTop = 0; + } else { + this._element.scrollTop = 0; + } + + if (transition) { + Util__default["default"].reflow(this._element); + } + + $__default["default"](this._element).addClass(CLASS_NAME_SHOW); + + if (this._config.focus) { + this._enforceFocus(); + } + + var shownEvent = $__default["default"].Event(EVENT_SHOWN, { + relatedTarget: relatedTarget + }); + + var transitionComplete = function transitionComplete() { + if (_this4._config.focus) { + _this4._element.focus(); + } + + _this4._isTransitioning = false; + $__default["default"](_this4._element).trigger(shownEvent); + }; + + if (transition) { + var transitionDuration = Util__default["default"].getTransitionDurationFromElement(this._dialog); + $__default["default"](this._dialog).one(Util__default["default"].TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration); + } else { + transitionComplete(); + } + }; + + _proto._enforceFocus = function _enforceFocus() { + var _this5 = this; + + $__default["default"](document).off(EVENT_FOCUSIN) // Guard against infinite focus loop + .on(EVENT_FOCUSIN, function (event) { + if (document !== event.target && _this5._element !== event.target && $__default["default"](_this5._element).has(event.target).length === 0) { + _this5._element.focus(); + } + }); + }; + + _proto._setEscapeEvent = function _setEscapeEvent() { + var _this6 = this; + + if (this._isShown) { + $__default["default"](this._element).on(EVENT_KEYDOWN_DISMISS, function (event) { + if (_this6._config.keyboard && event.which === ESCAPE_KEYCODE) { + event.preventDefault(); + + _this6.hide(); + } else if (!_this6._config.keyboard && event.which === ESCAPE_KEYCODE) { + _this6._triggerBackdropTransition(); + } + }); + } else if (!this._isShown) { + $__default["default"](this._element).off(EVENT_KEYDOWN_DISMISS); + } + }; + + _proto._setResizeEvent = function _setResizeEvent() { + var _this7 = this; + + if (this._isShown) { + $__default["default"](window).on(EVENT_RESIZE, function (event) { + return _this7.handleUpdate(event); + }); + } else { + $__default["default"](window).off(EVENT_RESIZE); + } + }; + + _proto._hideModal = function _hideModal() { + var _this8 = this; + + this._element.style.display = 'none'; + + this._element.setAttribute('aria-hidden', true); + + this._element.removeAttribute('aria-modal'); + + this._element.removeAttribute('role'); + + this._isTransitioning = false; + + this._showBackdrop(function () { + $__default["default"](document.body).removeClass(CLASS_NAME_OPEN); + + _this8._resetAdjustments(); + + _this8._resetScrollbar(); + + $__default["default"](_this8._element).trigger(EVENT_HIDDEN); + }); + }; + + _proto._removeBackdrop = function _removeBackdrop() { + if (this._backdrop) { + $__default["default"](this._backdrop).remove(); + this._backdrop = null; + } + }; + + _proto._showBackdrop = function _showBackdrop(callback) { + var _this9 = this; + + var animate = $__default["default"](this._element).hasClass(CLASS_NAME_FADE) ? CLASS_NAME_FADE : ''; + + if (this._isShown && this._config.backdrop) { + this._backdrop = document.createElement('div'); + this._backdrop.className = CLASS_NAME_BACKDROP; + + if (animate) { + this._backdrop.classList.add(animate); + } + + $__default["default"](this._backdrop).appendTo(document.body); + $__default["default"](this._element).on(EVENT_CLICK_DISMISS, function (event) { + if (_this9._ignoreBackdropClick) { + _this9._ignoreBackdropClick = false; + return; + } + + if (event.target !== event.currentTarget) { + return; + } + + if (_this9._config.backdrop === 'static') { + _this9._triggerBackdropTransition(); + } else { + _this9.hide(); + } + }); + + if (animate) { + Util__default["default"].reflow(this._backdrop); + } + + $__default["default"](this._backdrop).addClass(CLASS_NAME_SHOW); + + if (!callback) { + return; + } + + if (!animate) { + callback(); + return; + } + + var backdropTransitionDuration = Util__default["default"].getTransitionDurationFromElement(this._backdrop); + $__default["default"](this._backdrop).one(Util__default["default"].TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration); + } else if (!this._isShown && this._backdrop) { + $__default["default"](this._backdrop).removeClass(CLASS_NAME_SHOW); + + var callbackRemove = function callbackRemove() { + _this9._removeBackdrop(); + + if (callback) { + callback(); + } + }; + + if ($__default["default"](this._element).hasClass(CLASS_NAME_FADE)) { + var _backdropTransitionDuration = Util__default["default"].getTransitionDurationFromElement(this._backdrop); + + $__default["default"](this._backdrop).one(Util__default["default"].TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration); + } else { + callbackRemove(); + } + } else if (callback) { + callback(); + } + } // ---------------------------------------------------------------------- + // the following methods are used to handle overflowing modals + // todo (fat): these should probably be refactored out of modal.js + // ---------------------------------------------------------------------- + ; + + _proto._adjustDialog = function _adjustDialog() { + var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; + + if (!this._isBodyOverflowing && isModalOverflowing) { + this._element.style.paddingLeft = this._scrollbarWidth + "px"; + } + + if (this._isBodyOverflowing && !isModalOverflowing) { + this._element.style.paddingRight = this._scrollbarWidth + "px"; + } + }; + + _proto._resetAdjustments = function _resetAdjustments() { + this._element.style.paddingLeft = ''; + this._element.style.paddingRight = ''; + }; + + _proto._checkScrollbar = function _checkScrollbar() { + var rect = document.body.getBoundingClientRect(); + this._isBodyOverflowing = Math.round(rect.left + rect.right) < window.innerWidth; + this._scrollbarWidth = this._getScrollbarWidth(); + }; + + _proto._setScrollbar = function _setScrollbar() { + var _this10 = this; + + if (this._isBodyOverflowing) { + // Note: DOMNode.style.paddingRight returns the actual value or '' if not set + // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set + var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); + var stickyContent = [].slice.call(document.querySelectorAll(SELECTOR_STICKY_CONTENT)); // Adjust fixed content padding + + $__default["default"](fixedContent).each(function (index, element) { + var actualPadding = element.style.paddingRight; + var calculatedPadding = $__default["default"](element).css('padding-right'); + $__default["default"](element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this10._scrollbarWidth + "px"); + }); // Adjust sticky content margin + + $__default["default"](stickyContent).each(function (index, element) { + var actualMargin = element.style.marginRight; + var calculatedMargin = $__default["default"](element).css('margin-right'); + $__default["default"](element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this10._scrollbarWidth + "px"); + }); // Adjust body padding + + var actualPadding = document.body.style.paddingRight; + var calculatedPadding = $__default["default"](document.body).css('padding-right'); + $__default["default"](document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px"); + } + + $__default["default"](document.body).addClass(CLASS_NAME_OPEN); + }; + + _proto._resetScrollbar = function _resetScrollbar() { + // Restore fixed content padding + var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); + $__default["default"](fixedContent).each(function (index, element) { + var padding = $__default["default"](element).data('padding-right'); + $__default["default"](element).removeData('padding-right'); + element.style.paddingRight = padding ? padding : ''; + }); // Restore sticky content + + var elements = [].slice.call(document.querySelectorAll("" + SELECTOR_STICKY_CONTENT)); + $__default["default"](elements).each(function (index, element) { + var margin = $__default["default"](element).data('margin-right'); + + if (typeof margin !== 'undefined') { + $__default["default"](element).css('margin-right', margin).removeData('margin-right'); + } + }); // Restore body padding + + var padding = $__default["default"](document.body).data('padding-right'); + $__default["default"](document.body).removeData('padding-right'); + document.body.style.paddingRight = padding ? padding : ''; + }; + + _proto._getScrollbarWidth = function _getScrollbarWidth() { + // thx d.walsh + var scrollDiv = document.createElement('div'); + scrollDiv.className = CLASS_NAME_SCROLLBAR_MEASURER; + document.body.appendChild(scrollDiv); + var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth; + document.body.removeChild(scrollDiv); + return scrollbarWidth; + } // Static + ; + + Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) { + return this.each(function () { + var data = $__default["default"](this).data(DATA_KEY); + + var _config = _extends({}, Default, $__default["default"](this).data(), typeof config === 'object' && config ? config : {}); + + if (!data) { + data = new Modal(this, _config); + $__default["default"](this).data(DATA_KEY, data); + } + + if (typeof config === 'string') { + if (typeof data[config] === 'undefined') { + throw new TypeError("No method named \"" + config + "\""); + } + + data[config](relatedTarget); + } else if (_config.show) { + data.show(relatedTarget); + } + }); + }; + + _createClass(Modal, null, [{ + key: "VERSION", + get: function get() { + return VERSION; + } + }, { + key: "Default", + get: function get() { + return Default; + } + }]); + + return Modal; + }(); + /** + * Data API implementation + */ + + + $__default["default"](document).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { + var _this11 = this; + + var target; + var selector = Util__default["default"].getSelectorFromElement(this); + + if (selector) { + target = document.querySelector(selector); + } + + var config = $__default["default"](target).data(DATA_KEY) ? 'toggle' : _extends({}, $__default["default"](target).data(), $__default["default"](this).data()); + + if (this.tagName === 'A' || this.tagName === 'AREA') { + event.preventDefault(); + } + + var $target = $__default["default"](target).one(EVENT_SHOW, function (showEvent) { + if (showEvent.isDefaultPrevented()) { + // Only register focus restorer if modal will actually get shown + return; + } + + $target.one(EVENT_HIDDEN, function () { + if ($__default["default"](_this11).is(':visible')) { + _this11.focus(); + } + }); + }); + + Modal._jQueryInterface.call($__default["default"](target), config, this); + }); + /** + * jQuery + */ + + $__default["default"].fn[NAME] = Modal._jQueryInterface; + $__default["default"].fn[NAME].Constructor = Modal; + + $__default["default"].fn[NAME].noConflict = function () { + $__default["default"].fn[NAME] = JQUERY_NO_CONFLICT; + return Modal._jQueryInterface; + }; + + return Modal; + +})); +//# sourceMappingURL=modal.js.map + + +/***/ }), + +/***/ "./node_modules/bootstrap/js/dist/tab.js": +/*!***********************************************!*\ + !*** ./node_modules/bootstrap/js/dist/tab.js ***! + \***********************************************/ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*! + * Bootstrap tab.js v4.6.2 (https://getbootstrap.com/) + * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ +(function (global, factory) { + true ? module.exports = factory(__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"), __webpack_require__(/*! ./util.js */ "./node_modules/bootstrap/js/dist/util.js")) : + 0; +})(this, (function ($, Util) { 'use strict'; + + function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + + var $__default = /*#__PURE__*/_interopDefaultLegacy($); + var Util__default = /*#__PURE__*/_interopDefaultLegacy(Util); + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + + /** + * Constants + */ + + var NAME = 'tab'; + var VERSION = '4.6.2'; + var DATA_KEY = 'bs.tab'; + var EVENT_KEY = "." + DATA_KEY; + var DATA_API_KEY = '.data-api'; + var JQUERY_NO_CONFLICT = $__default["default"].fn[NAME]; + var CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu'; + var CLASS_NAME_ACTIVE = 'active'; + var CLASS_NAME_DISABLED = 'disabled'; + var CLASS_NAME_FADE = 'fade'; + var CLASS_NAME_SHOW = 'show'; + var EVENT_HIDE = "hide" + EVENT_KEY; + var EVENT_HIDDEN = "hidden" + EVENT_KEY; + var EVENT_SHOW = "show" + EVENT_KEY; + var EVENT_SHOWN = "shown" + EVENT_KEY; + var EVENT_CLICK_DATA_API = "click" + EVENT_KEY + DATA_API_KEY; + var SELECTOR_DROPDOWN = '.dropdown'; + var SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; + var SELECTOR_ACTIVE = '.active'; + var SELECTOR_ACTIVE_UL = '> li > .active'; + var SELECTOR_DATA_TOGGLE = '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]'; + var SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; + var SELECTOR_DROPDOWN_ACTIVE_CHILD = '> .dropdown-menu .active'; + /** + * Class definition + */ + + var Tab = /*#__PURE__*/function () { + function Tab(element) { + this._element = element; + } // Getters + + + var _proto = Tab.prototype; + + // Public + _proto.show = function show() { + var _this = this; + + if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $__default["default"](this._element).hasClass(CLASS_NAME_ACTIVE) || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED) || this._element.hasAttribute('disabled')) { + return; + } + + var target; + var previous; + var listElement = $__default["default"](this._element).closest(SELECTOR_NAV_LIST_GROUP)[0]; + var selector = Util__default["default"].getSelectorFromElement(this._element); + + if (listElement) { + var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE; + previous = $__default["default"].makeArray($__default["default"](listElement).find(itemSelector)); + previous = previous[previous.length - 1]; + } + + var hideEvent = $__default["default"].Event(EVENT_HIDE, { + relatedTarget: this._element + }); + var showEvent = $__default["default"].Event(EVENT_SHOW, { + relatedTarget: previous + }); + + if (previous) { + $__default["default"](previous).trigger(hideEvent); + } + + $__default["default"](this._element).trigger(showEvent); + + if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { + return; + } + + if (selector) { + target = document.querySelector(selector); + } + + this._activate(this._element, listElement); + + var complete = function complete() { + var hiddenEvent = $__default["default"].Event(EVENT_HIDDEN, { + relatedTarget: _this._element + }); + var shownEvent = $__default["default"].Event(EVENT_SHOWN, { + relatedTarget: previous + }); + $__default["default"](previous).trigger(hiddenEvent); + $__default["default"](_this._element).trigger(shownEvent); + }; + + if (target) { + this._activate(target, target.parentNode, complete); + } else { + complete(); + } + }; + + _proto.dispose = function dispose() { + $__default["default"].removeData(this._element, DATA_KEY); + this._element = null; + } // Private + ; + + _proto._activate = function _activate(element, container, callback) { + var _this2 = this; + + var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? $__default["default"](container).find(SELECTOR_ACTIVE_UL) : $__default["default"](container).children(SELECTOR_ACTIVE); + var active = activeElements[0]; + var isTransitioning = callback && active && $__default["default"](active).hasClass(CLASS_NAME_FADE); + + var complete = function complete() { + return _this2._transitionComplete(element, active, callback); + }; + + if (active && isTransitioning) { + var transitionDuration = Util__default["default"].getTransitionDurationFromElement(active); + $__default["default"](active).removeClass(CLASS_NAME_SHOW).one(Util__default["default"].TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); + } else { + complete(); + } + }; + + _proto._transitionComplete = function _transitionComplete(element, active, callback) { + if (active) { + $__default["default"](active).removeClass(CLASS_NAME_ACTIVE); + var dropdownChild = $__default["default"](active.parentNode).find(SELECTOR_DROPDOWN_ACTIVE_CHILD)[0]; + + if (dropdownChild) { + $__default["default"](dropdownChild).removeClass(CLASS_NAME_ACTIVE); + } + + if (active.getAttribute('role') === 'tab') { + active.setAttribute('aria-selected', false); + } + } + + $__default["default"](element).addClass(CLASS_NAME_ACTIVE); + + if (element.getAttribute('role') === 'tab') { + element.setAttribute('aria-selected', true); + } + + Util__default["default"].reflow(element); + + if (element.classList.contains(CLASS_NAME_FADE)) { + element.classList.add(CLASS_NAME_SHOW); + } + + var parent = element.parentNode; + + if (parent && parent.nodeName === 'LI') { + parent = parent.parentNode; + } + + if (parent && $__default["default"](parent).hasClass(CLASS_NAME_DROPDOWN_MENU)) { + var dropdownElement = $__default["default"](element).closest(SELECTOR_DROPDOWN)[0]; + + if (dropdownElement) { + var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(SELECTOR_DROPDOWN_TOGGLE)); + $__default["default"](dropdownToggleList).addClass(CLASS_NAME_ACTIVE); + } + + element.setAttribute('aria-expanded', true); + } + + if (callback) { + callback(); + } + } // Static + ; + + Tab._jQueryInterface = function _jQueryInterface(config) { + return this.each(function () { + var $this = $__default["default"](this); + var data = $this.data(DATA_KEY); + + if (!data) { + data = new Tab(this); + $this.data(DATA_KEY, data); + } + + if (typeof config === 'string') { + if (typeof data[config] === 'undefined') { + throw new TypeError("No method named \"" + config + "\""); + } + + data[config](); + } + }); + }; + + _createClass(Tab, null, [{ + key: "VERSION", + get: function get() { + return VERSION; + } + }]); + + return Tab; + }(); + /** + * Data API implementation + */ + + + $__default["default"](document).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { + event.preventDefault(); + + Tab._jQueryInterface.call($__default["default"](this), 'show'); + }); + /** + * jQuery + */ + + $__default["default"].fn[NAME] = Tab._jQueryInterface; + $__default["default"].fn[NAME].Constructor = Tab; + + $__default["default"].fn[NAME].noConflict = function () { + $__default["default"].fn[NAME] = JQUERY_NO_CONFLICT; + return Tab._jQueryInterface; + }; + + return Tab; + +})); +//# sourceMappingURL=tab.js.map + + +/***/ }), + +/***/ "./node_modules/bootstrap/js/dist/tooltip.js": +/*!***************************************************!*\ + !*** ./node_modules/bootstrap/js/dist/tooltip.js ***! + \***************************************************/ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*! + * Bootstrap tooltip.js v4.6.2 (https://getbootstrap.com/) + * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ +(function (global, factory) { + true ? module.exports = factory(__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"), __webpack_require__(/*! popper.js */ "./node_modules/popper.js/dist/esm/popper.js"), __webpack_require__(/*! ./util.js */ "./node_modules/bootstrap/js/dist/util.js")) : + 0; +})(this, (function ($, Popper, Util) { 'use strict'; + + function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + + var $__default = /*#__PURE__*/_interopDefaultLegacy($); + var Popper__default = /*#__PURE__*/_interopDefaultLegacy(Popper); + var Util__default = /*#__PURE__*/_interopDefaultLegacy(Util); + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + + function _extends() { + _extends = Object.assign ? Object.assign.bind() : function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + return _extends.apply(this, arguments); + } + + /** + * -------------------------------------------------------------------------- + * Bootstrap (v4.6.2): tools/sanitizer.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']; + var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; + var DefaultWhitelist = { + // Global attributes allowed on any supplied element below. + '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], + a: ['target', 'href', 'title', 'rel'], + area: [], + b: [], + br: [], + col: [], + code: [], + div: [], + em: [], + hr: [], + h1: [], + h2: [], + h3: [], + h4: [], + h5: [], + h6: [], + i: [], + img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], + li: [], + ol: [], + p: [], + pre: [], + s: [], + small: [], + span: [], + sub: [], + sup: [], + strong: [], + u: [], + ul: [] + }; + /** + * A pattern that recognizes a commonly useful subset of URLs that are safe. + * + * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts + */ + + var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i; + /** + * A pattern that matches safe data URLs. Only matches image, video and audio types. + * + * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts + */ + + var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i; + + function allowedAttribute(attr, allowedAttributeList) { + var attrName = attr.nodeName.toLowerCase(); + + if (allowedAttributeList.indexOf(attrName) !== -1) { + if (uriAttrs.indexOf(attrName) !== -1) { + return Boolean(SAFE_URL_PATTERN.test(attr.nodeValue) || DATA_URL_PATTERN.test(attr.nodeValue)); + } + + return true; + } + + var regExp = allowedAttributeList.filter(function (attrRegex) { + return attrRegex instanceof RegExp; + }); // Check if a regular expression validates the attribute. + + for (var i = 0, len = regExp.length; i < len; i++) { + if (regExp[i].test(attrName)) { + return true; + } + } + + return false; + } + + function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) { + if (unsafeHtml.length === 0) { + return unsafeHtml; + } + + if (sanitizeFn && typeof sanitizeFn === 'function') { + return sanitizeFn(unsafeHtml); + } + + var domParser = new window.DOMParser(); + var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); + var whitelistKeys = Object.keys(whiteList); + var elements = [].slice.call(createdDocument.body.querySelectorAll('*')); + + var _loop = function _loop(i, len) { + var el = elements[i]; + var elName = el.nodeName.toLowerCase(); + + if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) { + el.parentNode.removeChild(el); + return "continue"; + } + + var attributeList = [].slice.call(el.attributes); // eslint-disable-next-line unicorn/prefer-spread + + var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []); + attributeList.forEach(function (attr) { + if (!allowedAttribute(attr, whitelistedAttributes)) { + el.removeAttribute(attr.nodeName); + } + }); + }; + + for (var i = 0, len = elements.length; i < len; i++) { + var _ret = _loop(i); + + if (_ret === "continue") continue; + } + + return createdDocument.body.innerHTML; + } + + /** + * Constants + */ + + var NAME = 'tooltip'; + var VERSION = '4.6.2'; + var DATA_KEY = 'bs.tooltip'; + var EVENT_KEY = "." + DATA_KEY; + var JQUERY_NO_CONFLICT = $__default["default"].fn[NAME]; + var CLASS_PREFIX = 'bs-tooltip'; + var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g'); + var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn']; + var CLASS_NAME_FADE = 'fade'; + var CLASS_NAME_SHOW = 'show'; + var HOVER_STATE_SHOW = 'show'; + var HOVER_STATE_OUT = 'out'; + var SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; + var SELECTOR_ARROW = '.arrow'; + var TRIGGER_HOVER = 'hover'; + var TRIGGER_FOCUS = 'focus'; + var TRIGGER_CLICK = 'click'; + var TRIGGER_MANUAL = 'manual'; + var AttachmentMap = { + AUTO: 'auto', + TOP: 'top', + RIGHT: 'right', + BOTTOM: 'bottom', + LEFT: 'left' + }; + var Default = { + animation: true, + template: '', + trigger: 'hover focus', + title: '', + delay: 0, + html: false, + selector: false, + placement: 'top', + offset: 0, + container: false, + fallbackPlacement: 'flip', + boundary: 'scrollParent', + customClass: '', + sanitize: true, + sanitizeFn: null, + whiteList: DefaultWhitelist, + popperConfig: null + }; + var DefaultType = { + animation: 'boolean', + template: 'string', + title: '(string|element|function)', + trigger: 'string', + delay: '(number|object)', + html: 'boolean', + selector: '(string|boolean)', + placement: '(string|function)', + offset: '(number|string|function)', + container: '(string|element|boolean)', + fallbackPlacement: '(string|array)', + boundary: '(string|element)', + customClass: '(string|function)', + sanitize: 'boolean', + sanitizeFn: '(null|function)', + whiteList: 'object', + popperConfig: '(null|object)' + }; + var Event = { + HIDE: "hide" + EVENT_KEY, + HIDDEN: "hidden" + EVENT_KEY, + SHOW: "show" + EVENT_KEY, + SHOWN: "shown" + EVENT_KEY, + INSERTED: "inserted" + EVENT_KEY, + CLICK: "click" + EVENT_KEY, + FOCUSIN: "focusin" + EVENT_KEY, + FOCUSOUT: "focusout" + EVENT_KEY, + MOUSEENTER: "mouseenter" + EVENT_KEY, + MOUSELEAVE: "mouseleave" + EVENT_KEY + }; + /** + * Class definition + */ + + var Tooltip = /*#__PURE__*/function () { + function Tooltip(element, config) { + if (typeof Popper__default["default"] === 'undefined') { + throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); + } // Private + + + this._isEnabled = true; + this._timeout = 0; + this._hoverState = ''; + this._activeTrigger = {}; + this._popper = null; // Protected + + this.element = element; + this.config = this._getConfig(config); + this.tip = null; + + this._setListeners(); + } // Getters + + + var _proto = Tooltip.prototype; + + // Public + _proto.enable = function enable() { + this._isEnabled = true; + }; + + _proto.disable = function disable() { + this._isEnabled = false; + }; + + _proto.toggleEnabled = function toggleEnabled() { + this._isEnabled = !this._isEnabled; + }; + + _proto.toggle = function toggle(event) { + if (!this._isEnabled) { + return; + } + + if (event) { + var dataKey = this.constructor.DATA_KEY; + var context = $__default["default"](event.currentTarget).data(dataKey); + + if (!context) { + context = new this.constructor(event.currentTarget, this._getDelegateConfig()); + $__default["default"](event.currentTarget).data(dataKey, context); + } + + context._activeTrigger.click = !context._activeTrigger.click; + + if (context._isWithActiveTrigger()) { + context._enter(null, context); + } else { + context._leave(null, context); + } + } else { + if ($__default["default"](this.getTipElement()).hasClass(CLASS_NAME_SHOW)) { + this._leave(null, this); + + return; + } + + this._enter(null, this); + } + }; + + _proto.dispose = function dispose() { + clearTimeout(this._timeout); + $__default["default"].removeData(this.element, this.constructor.DATA_KEY); + $__default["default"](this.element).off(this.constructor.EVENT_KEY); + $__default["default"](this.element).closest('.modal').off('hide.bs.modal', this._hideModalHandler); + + if (this.tip) { + $__default["default"](this.tip).remove(); + } + + this._isEnabled = null; + this._timeout = null; + this._hoverState = null; + this._activeTrigger = null; + + if (this._popper) { + this._popper.destroy(); + } + + this._popper = null; + this.element = null; + this.config = null; + this.tip = null; + }; + + _proto.show = function show() { + var _this = this; + + if ($__default["default"](this.element).css('display') === 'none') { + throw new Error('Please use show on visible elements'); + } + + var showEvent = $__default["default"].Event(this.constructor.Event.SHOW); + + if (this.isWithContent() && this._isEnabled) { + $__default["default"](this.element).trigger(showEvent); + var shadowRoot = Util__default["default"].findShadowRoot(this.element); + var isInTheDom = $__default["default"].contains(shadowRoot !== null ? shadowRoot : this.element.ownerDocument.documentElement, this.element); + + if (showEvent.isDefaultPrevented() || !isInTheDom) { + return; + } + + var tip = this.getTipElement(); + var tipId = Util__default["default"].getUID(this.constructor.NAME); + tip.setAttribute('id', tipId); + this.element.setAttribute('aria-describedby', tipId); + this.setContent(); + + if (this.config.animation) { + $__default["default"](tip).addClass(CLASS_NAME_FADE); + } + + var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement; + + var attachment = this._getAttachment(placement); + + this.addAttachmentClass(attachment); + + var container = this._getContainer(); + + $__default["default"](tip).data(this.constructor.DATA_KEY, this); + + if (!$__default["default"].contains(this.element.ownerDocument.documentElement, this.tip)) { + $__default["default"](tip).appendTo(container); + } + + $__default["default"](this.element).trigger(this.constructor.Event.INSERTED); + this._popper = new Popper__default["default"](this.element, tip, this._getPopperConfig(attachment)); + $__default["default"](tip).addClass(CLASS_NAME_SHOW); + $__default["default"](tip).addClass(this.config.customClass); // If this is a touch-enabled device we add extra + // empty mouseover listeners to the body's immediate children; + // only needed because of broken event delegation on iOS + // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html + + if ('ontouchstart' in document.documentElement) { + $__default["default"](document.body).children().on('mouseover', null, $__default["default"].noop); + } + + var complete = function complete() { + if (_this.config.animation) { + _this._fixTransition(); + } + + var prevHoverState = _this._hoverState; + _this._hoverState = null; + $__default["default"](_this.element).trigger(_this.constructor.Event.SHOWN); + + if (prevHoverState === HOVER_STATE_OUT) { + _this._leave(null, _this); + } + }; + + if ($__default["default"](this.tip).hasClass(CLASS_NAME_FADE)) { + var transitionDuration = Util__default["default"].getTransitionDurationFromElement(this.tip); + $__default["default"](this.tip).one(Util__default["default"].TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); + } else { + complete(); + } + } + }; + + _proto.hide = function hide(callback) { + var _this2 = this; + + var tip = this.getTipElement(); + var hideEvent = $__default["default"].Event(this.constructor.Event.HIDE); + + var complete = function complete() { + if (_this2._hoverState !== HOVER_STATE_SHOW && tip.parentNode) { + tip.parentNode.removeChild(tip); + } + + _this2._cleanTipClass(); + + _this2.element.removeAttribute('aria-describedby'); + + $__default["default"](_this2.element).trigger(_this2.constructor.Event.HIDDEN); + + if (_this2._popper !== null) { + _this2._popper.destroy(); + } + + if (callback) { + callback(); + } + }; + + $__default["default"](this.element).trigger(hideEvent); + + if (hideEvent.isDefaultPrevented()) { + return; + } + + $__default["default"](tip).removeClass(CLASS_NAME_SHOW); // If this is a touch-enabled device we remove the extra + // empty mouseover listeners we added for iOS support + + if ('ontouchstart' in document.documentElement) { + $__default["default"](document.body).children().off('mouseover', null, $__default["default"].noop); + } + + this._activeTrigger[TRIGGER_CLICK] = false; + this._activeTrigger[TRIGGER_FOCUS] = false; + this._activeTrigger[TRIGGER_HOVER] = false; + + if ($__default["default"](this.tip).hasClass(CLASS_NAME_FADE)) { + var transitionDuration = Util__default["default"].getTransitionDurationFromElement(tip); + $__default["default"](tip).one(Util__default["default"].TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); + } else { + complete(); + } + + this._hoverState = ''; + }; + + _proto.update = function update() { + if (this._popper !== null) { + this._popper.scheduleUpdate(); + } + } // Protected + ; + + _proto.isWithContent = function isWithContent() { + return Boolean(this.getTitle()); + }; + + _proto.addAttachmentClass = function addAttachmentClass(attachment) { + $__default["default"](this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment); + }; + + _proto.getTipElement = function getTipElement() { + this.tip = this.tip || $__default["default"](this.config.template)[0]; + return this.tip; + }; + + _proto.setContent = function setContent() { + var tip = this.getTipElement(); + this.setElementContent($__default["default"](tip.querySelectorAll(SELECTOR_TOOLTIP_INNER)), this.getTitle()); + $__default["default"](tip).removeClass(CLASS_NAME_FADE + " " + CLASS_NAME_SHOW); + }; + + _proto.setElementContent = function setElementContent($element, content) { + if (typeof content === 'object' && (content.nodeType || content.jquery)) { + // Content is a DOM node or a jQuery + if (this.config.html) { + if (!$__default["default"](content).parent().is($element)) { + $element.empty().append(content); + } + } else { + $element.text($__default["default"](content).text()); + } + + return; + } + + if (this.config.html) { + if (this.config.sanitize) { + content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn); + } + + $element.html(content); + } else { + $element.text(content); + } + }; + + _proto.getTitle = function getTitle() { + var title = this.element.getAttribute('data-original-title'); + + if (!title) { + title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title; + } + + return title; + } // Private + ; + + _proto._getPopperConfig = function _getPopperConfig(attachment) { + var _this3 = this; + + var defaultBsConfig = { + placement: attachment, + modifiers: { + offset: this._getOffset(), + flip: { + behavior: this.config.fallbackPlacement + }, + arrow: { + element: SELECTOR_ARROW + }, + preventOverflow: { + boundariesElement: this.config.boundary + } + }, + onCreate: function onCreate(data) { + if (data.originalPlacement !== data.placement) { + _this3._handlePopperPlacementChange(data); + } + }, + onUpdate: function onUpdate(data) { + return _this3._handlePopperPlacementChange(data); + } + }; + return _extends({}, defaultBsConfig, this.config.popperConfig); + }; + + _proto._getOffset = function _getOffset() { + var _this4 = this; + + var offset = {}; + + if (typeof this.config.offset === 'function') { + offset.fn = function (data) { + data.offsets = _extends({}, data.offsets, _this4.config.offset(data.offsets, _this4.element)); + return data; + }; + } else { + offset.offset = this.config.offset; + } + + return offset; + }; + + _proto._getContainer = function _getContainer() { + if (this.config.container === false) { + return document.body; + } + + if (Util__default["default"].isElement(this.config.container)) { + return $__default["default"](this.config.container); + } + + return $__default["default"](document).find(this.config.container); + }; + + _proto._getAttachment = function _getAttachment(placement) { + return AttachmentMap[placement.toUpperCase()]; + }; + + _proto._setListeners = function _setListeners() { + var _this5 = this; + + var triggers = this.config.trigger.split(' '); + triggers.forEach(function (trigger) { + if (trigger === 'click') { + $__default["default"](_this5.element).on(_this5.constructor.Event.CLICK, _this5.config.selector, function (event) { + return _this5.toggle(event); + }); + } else if (trigger !== TRIGGER_MANUAL) { + var eventIn = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSEENTER : _this5.constructor.Event.FOCUSIN; + var eventOut = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSELEAVE : _this5.constructor.Event.FOCUSOUT; + $__default["default"](_this5.element).on(eventIn, _this5.config.selector, function (event) { + return _this5._enter(event); + }).on(eventOut, _this5.config.selector, function (event) { + return _this5._leave(event); + }); + } + }); + + this._hideModalHandler = function () { + if (_this5.element) { + _this5.hide(); + } + }; + + $__default["default"](this.element).closest('.modal').on('hide.bs.modal', this._hideModalHandler); + + if (this.config.selector) { + this.config = _extends({}, this.config, { + trigger: 'manual', + selector: '' + }); + } else { + this._fixTitle(); + } + }; + + _proto._fixTitle = function _fixTitle() { + var titleType = typeof this.element.getAttribute('data-original-title'); + + if (this.element.getAttribute('title') || titleType !== 'string') { + this.element.setAttribute('data-original-title', this.element.getAttribute('title') || ''); + this.element.setAttribute('title', ''); + } + }; + + _proto._enter = function _enter(event, context) { + var dataKey = this.constructor.DATA_KEY; + context = context || $__default["default"](event.currentTarget).data(dataKey); + + if (!context) { + context = new this.constructor(event.currentTarget, this._getDelegateConfig()); + $__default["default"](event.currentTarget).data(dataKey, context); + } + + if (event) { + context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; + } + + if ($__default["default"](context.getTipElement()).hasClass(CLASS_NAME_SHOW) || context._hoverState === HOVER_STATE_SHOW) { + context._hoverState = HOVER_STATE_SHOW; + return; + } + + clearTimeout(context._timeout); + context._hoverState = HOVER_STATE_SHOW; + + if (!context.config.delay || !context.config.delay.show) { + context.show(); + return; + } + + context._timeout = setTimeout(function () { + if (context._hoverState === HOVER_STATE_SHOW) { + context.show(); + } + }, context.config.delay.show); + }; + + _proto._leave = function _leave(event, context) { + var dataKey = this.constructor.DATA_KEY; + context = context || $__default["default"](event.currentTarget).data(dataKey); + + if (!context) { + context = new this.constructor(event.currentTarget, this._getDelegateConfig()); + $__default["default"](event.currentTarget).data(dataKey, context); + } + + if (event) { + context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = false; + } + + if (context._isWithActiveTrigger()) { + return; + } + + clearTimeout(context._timeout); + context._hoverState = HOVER_STATE_OUT; + + if (!context.config.delay || !context.config.delay.hide) { + context.hide(); + return; + } + + context._timeout = setTimeout(function () { + if (context._hoverState === HOVER_STATE_OUT) { + context.hide(); + } + }, context.config.delay.hide); + }; + + _proto._isWithActiveTrigger = function _isWithActiveTrigger() { + for (var trigger in this._activeTrigger) { + if (this._activeTrigger[trigger]) { + return true; + } + } + + return false; + }; + + _proto._getConfig = function _getConfig(config) { + var dataAttributes = $__default["default"](this.element).data(); + Object.keys(dataAttributes).forEach(function (dataAttr) { + if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) { + delete dataAttributes[dataAttr]; + } + }); + config = _extends({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {}); + + if (typeof config.delay === 'number') { + config.delay = { + show: config.delay, + hide: config.delay + }; + } + + if (typeof config.title === 'number') { + config.title = config.title.toString(); + } + + if (typeof config.content === 'number') { + config.content = config.content.toString(); + } + + Util__default["default"].typeCheckConfig(NAME, config, this.constructor.DefaultType); + + if (config.sanitize) { + config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn); + } + + return config; + }; + + _proto._getDelegateConfig = function _getDelegateConfig() { + var config = {}; + + if (this.config) { + for (var key in this.config) { + if (this.constructor.Default[key] !== this.config[key]) { + config[key] = this.config[key]; + } + } + } + + return config; + }; + + _proto._cleanTipClass = function _cleanTipClass() { + var $tip = $__default["default"](this.getTipElement()); + var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX); + + if (tabClass !== null && tabClass.length) { + $tip.removeClass(tabClass.join('')); + } + }; + + _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) { + this.tip = popperData.instance.popper; + + this._cleanTipClass(); + + this.addAttachmentClass(this._getAttachment(popperData.placement)); + }; + + _proto._fixTransition = function _fixTransition() { + var tip = this.getTipElement(); + var initConfigAnimation = this.config.animation; + + if (tip.getAttribute('x-placement') !== null) { + return; + } + + $__default["default"](tip).removeClass(CLASS_NAME_FADE); + this.config.animation = false; + this.hide(); + this.show(); + this.config.animation = initConfigAnimation; + } // Static + ; + + Tooltip._jQueryInterface = function _jQueryInterface(config) { + return this.each(function () { + var $element = $__default["default"](this); + var data = $element.data(DATA_KEY); + + var _config = typeof config === 'object' && config; + + if (!data && /dispose|hide/.test(config)) { + return; + } + + if (!data) { + data = new Tooltip(this, _config); + $element.data(DATA_KEY, data); + } + + if (typeof config === 'string') { + if (typeof data[config] === 'undefined') { + throw new TypeError("No method named \"" + config + "\""); + } + + data[config](); + } + }); + }; + + _createClass(Tooltip, null, [{ + key: "VERSION", + get: function get() { + return VERSION; + } + }, { + key: "Default", + get: function get() { + return Default; + } + }, { + key: "NAME", + get: function get() { + return NAME; + } + }, { + key: "DATA_KEY", + get: function get() { + return DATA_KEY; + } + }, { + key: "Event", + get: function get() { + return Event; + } + }, { + key: "EVENT_KEY", + get: function get() { + return EVENT_KEY; + } + }, { + key: "DefaultType", + get: function get() { + return DefaultType; + } + }]); + + return Tooltip; + }(); + /** + * jQuery + */ + + + $__default["default"].fn[NAME] = Tooltip._jQueryInterface; + $__default["default"].fn[NAME].Constructor = Tooltip; + + $__default["default"].fn[NAME].noConflict = function () { + $__default["default"].fn[NAME] = JQUERY_NO_CONFLICT; + return Tooltip._jQueryInterface; + }; + + return Tooltip; + +})); +//# sourceMappingURL=tooltip.js.map + + +/***/ }), + +/***/ "./node_modules/bootstrap/js/dist/util.js": +/*!************************************************!*\ + !*** ./node_modules/bootstrap/js/dist/util.js ***! + \************************************************/ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*! + * Bootstrap util.js v4.6.2 (https://getbootstrap.com/) + * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ +(function (global, factory) { + true ? module.exports = factory(__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js")) : + 0; +})(this, (function ($) { 'use strict'; + + function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + + var $__default = /*#__PURE__*/_interopDefaultLegacy($); + + /** + * -------------------------------------------------------------------------- + * Bootstrap (v4.6.2): util.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** + * Private TransitionEnd Helpers + */ + + var TRANSITION_END = 'transitionend'; + var MAX_UID = 1000000; + var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp) + + function toType(obj) { + if (obj === null || typeof obj === 'undefined') { + return "" + obj; + } + + return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); + } + + function getSpecialTransitionEndEvent() { + return { + bindType: TRANSITION_END, + delegateType: TRANSITION_END, + handle: function handle(event) { + if ($__default["default"](event.target).is(this)) { + return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params + } + + return undefined; + } + }; + } + + function transitionEndEmulator(duration) { + var _this = this; + + var called = false; + $__default["default"](this).one(Util.TRANSITION_END, function () { + called = true; + }); + setTimeout(function () { + if (!called) { + Util.triggerTransitionEnd(_this); + } + }, duration); + return this; + } + + function setTransitionEndSupport() { + $__default["default"].fn.emulateTransitionEnd = transitionEndEmulator; + $__default["default"].event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent(); + } + /** + * Public Util API + */ + + + var Util = { + TRANSITION_END: 'bsTransitionEnd', + getUID: function getUID(prefix) { + do { + // eslint-disable-next-line no-bitwise + prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here + } while (document.getElementById(prefix)); + + return prefix; + }, + getSelectorFromElement: function getSelectorFromElement(element) { + var selector = element.getAttribute('data-target'); + + if (!selector || selector === '#') { + var hrefAttr = element.getAttribute('href'); + selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''; + } + + try { + return document.querySelector(selector) ? selector : null; + } catch (_) { + return null; + } + }, + getTransitionDurationFromElement: function getTransitionDurationFromElement(element) { + if (!element) { + return 0; + } // Get transition-duration of the element + + + var transitionDuration = $__default["default"](element).css('transition-duration'); + var transitionDelay = $__default["default"](element).css('transition-delay'); + var floatTransitionDuration = parseFloat(transitionDuration); + var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found + + if (!floatTransitionDuration && !floatTransitionDelay) { + return 0; + } // If multiple durations are defined, take the first + + + transitionDuration = transitionDuration.split(',')[0]; + transitionDelay = transitionDelay.split(',')[0]; + return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; + }, + reflow: function reflow(element) { + return element.offsetHeight; + }, + triggerTransitionEnd: function triggerTransitionEnd(element) { + $__default["default"](element).trigger(TRANSITION_END); + }, + supportsTransitionEnd: function supportsTransitionEnd() { + return Boolean(TRANSITION_END); + }, + isElement: function isElement(obj) { + return (obj[0] || obj).nodeType; + }, + typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) { + for (var property in configTypes) { + if (Object.prototype.hasOwnProperty.call(configTypes, property)) { + var expectedTypes = configTypes[property]; + var value = config[property]; + var valueType = value && Util.isElement(value) ? 'element' : toType(value); + + if (!new RegExp(expectedTypes).test(valueType)) { + throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\".")); + } + } + } + }, + findShadowRoot: function findShadowRoot(element) { + if (!document.documentElement.attachShadow) { + return null; + } // Can find the shadow root otherwise it'll return the document + + + if (typeof element.getRootNode === 'function') { + var root = element.getRootNode(); + return root instanceof ShadowRoot ? root : null; + } + + if (element instanceof ShadowRoot) { + return element; + } // when we don't find a shadow root + + + if (!element.parentNode) { + return null; + } + + return Util.findShadowRoot(element.parentNode); + }, + jQueryDetection: function jQueryDetection() { + if (typeof $__default["default"] === 'undefined') { + throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.'); + } + + var version = $__default["default"].fn.jquery.split(' ')[0].split('.'); + var minMajor = 1; + var ltMajor = 2; + var minMinor = 9; + var minPatch = 1; + var maxMajor = 4; + + if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) { + throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0'); + } + } + }; + Util.jQueryDetection(); + setTransitionEndSupport(); + + return Util; + +})); +//# sourceMappingURL=util.js.map + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/@fortawesome/fontawesome-free/css/all.css": +/*!******************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/@fortawesome/fontawesome-free/css/all.css ***! + \******************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../css-loader/dist/runtime/getUrl.js */ "./node_modules/css-loader/dist/runtime/getUrl.js"); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__); +// Imports + + + +var ___CSS_LOADER_URL_IMPORT_0___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-brands-400.eot */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-brands-400.eot"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_1___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-brands-400.woff2 */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-brands-400.woff2"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_2___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-brands-400.woff */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-brands-400.woff"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_3___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-brands-400.ttf */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-brands-400.ttf"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_4___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-brands-400.svg */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-brands-400.svg"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_5___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-regular-400.eot */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-regular-400.eot"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_6___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-regular-400.woff2 */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-regular-400.woff2"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_7___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-regular-400.woff */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-regular-400.woff"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_8___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-regular-400.ttf */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-regular-400.ttf"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_9___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-regular-400.svg */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-regular-400.svg"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_10___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-solid-900.eot */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-solid-900.eot"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_11___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-solid-900.woff2 */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-solid-900.woff2"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_12___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-solid-900.woff */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-solid-900.woff"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_13___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-solid-900.ttf */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-solid-900.ttf"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_14___ = new URL(/* asset import */ __webpack_require__(/*! ../webfonts/fa-solid-900.svg */ "./node_modules/@fortawesome/fontawesome-free/webfonts/fa-solid-900.svg"), __webpack_require__.b); +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +var ___CSS_LOADER_URL_REPLACEMENT_0___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_0___); +var ___CSS_LOADER_URL_REPLACEMENT_1___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_0___, { hash: "?#iefix" }); +var ___CSS_LOADER_URL_REPLACEMENT_2___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_1___); +var ___CSS_LOADER_URL_REPLACEMENT_3___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_2___); +var ___CSS_LOADER_URL_REPLACEMENT_4___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_3___); +var ___CSS_LOADER_URL_REPLACEMENT_5___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_4___, { hash: "#fontawesome" }); +var ___CSS_LOADER_URL_REPLACEMENT_6___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_5___); +var ___CSS_LOADER_URL_REPLACEMENT_7___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_5___, { hash: "?#iefix" }); +var ___CSS_LOADER_URL_REPLACEMENT_8___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_6___); +var ___CSS_LOADER_URL_REPLACEMENT_9___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_7___); +var ___CSS_LOADER_URL_REPLACEMENT_10___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_8___); +var ___CSS_LOADER_URL_REPLACEMENT_11___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_9___, { hash: "#fontawesome" }); +var ___CSS_LOADER_URL_REPLACEMENT_12___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_10___); +var ___CSS_LOADER_URL_REPLACEMENT_13___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_10___, { hash: "?#iefix" }); +var ___CSS_LOADER_URL_REPLACEMENT_14___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_11___); +var ___CSS_LOADER_URL_REPLACEMENT_15___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_12___); +var ___CSS_LOADER_URL_REPLACEMENT_16___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_13___); +var ___CSS_LOADER_URL_REPLACEMENT_17___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_14___, { hash: "#fontawesome" }); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*! + * Font Awesome Free 5.15.4 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.fa, +.fas, +.far, +.fal, +.fad, +.fab { + -moz-osx-font-smoothing: grayscale; + -webkit-font-smoothing: antialiased; + display: inline-block; + font-style: normal; + font-variant: normal; + text-rendering: auto; + line-height: 1; } + +.fa-lg { + font-size: 1.33333em; + line-height: 0.75em; + vertical-align: -.0667em; } + +.fa-xs { + font-size: .75em; } + +.fa-sm { + font-size: .875em; } + +.fa-1x { + font-size: 1em; } + +.fa-2x { + font-size: 2em; } + +.fa-3x { + font-size: 3em; } + +.fa-4x { + font-size: 4em; } + +.fa-5x { + font-size: 5em; } + +.fa-6x { + font-size: 6em; } + +.fa-7x { + font-size: 7em; } + +.fa-8x { + font-size: 8em; } + +.fa-9x { + font-size: 9em; } + +.fa-10x { + font-size: 10em; } + +.fa-fw { + text-align: center; + width: 1.25em; } + +.fa-ul { + list-style-type: none; + margin-left: 2.5em; + padding-left: 0; } + .fa-ul > li { + position: relative; } + +.fa-li { + left: -2em; + position: absolute; + text-align: center; + width: 2em; + line-height: inherit; } + +.fa-border { + border: solid 0.08em #eee; + border-radius: .1em; + padding: .2em .25em .15em; } + +.fa-pull-left { + float: left; } + +.fa-pull-right { + float: right; } + +.fa.fa-pull-left, +.fas.fa-pull-left, +.far.fa-pull-left, +.fal.fa-pull-left, +.fab.fa-pull-left { + margin-right: .3em; } + +.fa.fa-pull-right, +.fas.fa-pull-right, +.far.fa-pull-right, +.fal.fa-pull-right, +.fab.fa-pull-right { + margin-left: .3em; } + +.fa-spin { + -webkit-animation: fa-spin 2s infinite linear; + animation: fa-spin 2s infinite linear; } + +.fa-pulse { + -webkit-animation: fa-spin 1s infinite steps(8); + animation: fa-spin 1s infinite steps(8); } + +@-webkit-keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +@keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +.fa-rotate-90 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=1)"; + -webkit-transform: rotate(90deg); + transform: rotate(90deg); } + +.fa-rotate-180 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2)"; + -webkit-transform: rotate(180deg); + transform: rotate(180deg); } + +.fa-rotate-270 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=3)"; + -webkit-transform: rotate(270deg); + transform: rotate(270deg); } + +.fa-flip-horizontal { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)"; + -webkit-transform: scale(-1, 1); + transform: scale(-1, 1); } + +.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(1, -1); + transform: scale(1, -1); } + +.fa-flip-both, .fa-flip-horizontal.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(-1, -1); + transform: scale(-1, -1); } + +:root .fa-rotate-90, +:root .fa-rotate-180, +:root .fa-rotate-270, +:root .fa-flip-horizontal, +:root .fa-flip-vertical, +:root .fa-flip-both { + -webkit-filter: none; + filter: none; } + +.fa-stack { + display: inline-block; + height: 2em; + line-height: 2em; + position: relative; + vertical-align: middle; + width: 2.5em; } + +.fa-stack-1x, +.fa-stack-2x { + left: 0; + position: absolute; + text-align: center; + width: 100%; } + +.fa-stack-1x { + line-height: inherit; } + +.fa-stack-2x { + font-size: 2em; } + +.fa-inverse { + color: #fff; } + +/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen +readers do not read off random characters that represent icons */ +.fa-500px:before { + content: "\\f26e"; } + +.fa-accessible-icon:before { + content: "\\f368"; } + +.fa-accusoft:before { + content: "\\f369"; } + +.fa-acquisitions-incorporated:before { + content: "\\f6af"; } + +.fa-ad:before { + content: "\\f641"; } + +.fa-address-book:before { + content: "\\f2b9"; } + +.fa-address-card:before { + content: "\\f2bb"; } + +.fa-adjust:before { + content: "\\f042"; } + +.fa-adn:before { + content: "\\f170"; } + +.fa-adversal:before { + content: "\\f36a"; } + +.fa-affiliatetheme:before { + content: "\\f36b"; } + +.fa-air-freshener:before { + content: "\\f5d0"; } + +.fa-airbnb:before { + content: "\\f834"; } + +.fa-algolia:before { + content: "\\f36c"; } + +.fa-align-center:before { + content: "\\f037"; } + +.fa-align-justify:before { + content: "\\f039"; } + +.fa-align-left:before { + content: "\\f036"; } + +.fa-align-right:before { + content: "\\f038"; } + +.fa-alipay:before { + content: "\\f642"; } + +.fa-allergies:before { + content: "\\f461"; } + +.fa-amazon:before { + content: "\\f270"; } + +.fa-amazon-pay:before { + content: "\\f42c"; } + +.fa-ambulance:before { + content: "\\f0f9"; } + +.fa-american-sign-language-interpreting:before { + content: "\\f2a3"; } + +.fa-amilia:before { + content: "\\f36d"; } + +.fa-anchor:before { + content: "\\f13d"; } + +.fa-android:before { + content: "\\f17b"; } + +.fa-angellist:before { + content: "\\f209"; } + +.fa-angle-double-down:before { + content: "\\f103"; } + +.fa-angle-double-left:before { + content: "\\f100"; } + +.fa-angle-double-right:before { + content: "\\f101"; } + +.fa-angle-double-up:before { + content: "\\f102"; } + +.fa-angle-down:before { + content: "\\f107"; } + +.fa-angle-left:before { + content: "\\f104"; } + +.fa-angle-right:before { + content: "\\f105"; } + +.fa-angle-up:before { + content: "\\f106"; } + +.fa-angry:before { + content: "\\f556"; } + +.fa-angrycreative:before { + content: "\\f36e"; } + +.fa-angular:before { + content: "\\f420"; } + +.fa-ankh:before { + content: "\\f644"; } + +.fa-app-store:before { + content: "\\f36f"; } + +.fa-app-store-ios:before { + content: "\\f370"; } + +.fa-apper:before { + content: "\\f371"; } + +.fa-apple:before { + content: "\\f179"; } + +.fa-apple-alt:before { + content: "\\f5d1"; } + +.fa-apple-pay:before { + content: "\\f415"; } + +.fa-archive:before { + content: "\\f187"; } + +.fa-archway:before { + content: "\\f557"; } + +.fa-arrow-alt-circle-down:before { + content: "\\f358"; } + +.fa-arrow-alt-circle-left:before { + content: "\\f359"; } + +.fa-arrow-alt-circle-right:before { + content: "\\f35a"; } + +.fa-arrow-alt-circle-up:before { + content: "\\f35b"; } + +.fa-arrow-circle-down:before { + content: "\\f0ab"; } + +.fa-arrow-circle-left:before { + content: "\\f0a8"; } + +.fa-arrow-circle-right:before { + content: "\\f0a9"; } + +.fa-arrow-circle-up:before { + content: "\\f0aa"; } + +.fa-arrow-down:before { + content: "\\f063"; } + +.fa-arrow-left:before { + content: "\\f060"; } + +.fa-arrow-right:before { + content: "\\f061"; } + +.fa-arrow-up:before { + content: "\\f062"; } + +.fa-arrows-alt:before { + content: "\\f0b2"; } + +.fa-arrows-alt-h:before { + content: "\\f337"; } + +.fa-arrows-alt-v:before { + content: "\\f338"; } + +.fa-artstation:before { + content: "\\f77a"; } + +.fa-assistive-listening-systems:before { + content: "\\f2a2"; } + +.fa-asterisk:before { + content: "\\f069"; } + +.fa-asymmetrik:before { + content: "\\f372"; } + +.fa-at:before { + content: "\\f1fa"; } + +.fa-atlas:before { + content: "\\f558"; } + +.fa-atlassian:before { + content: "\\f77b"; } + +.fa-atom:before { + content: "\\f5d2"; } + +.fa-audible:before { + content: "\\f373"; } + +.fa-audio-description:before { + content: "\\f29e"; } + +.fa-autoprefixer:before { + content: "\\f41c"; } + +.fa-avianex:before { + content: "\\f374"; } + +.fa-aviato:before { + content: "\\f421"; } + +.fa-award:before { + content: "\\f559"; } + +.fa-aws:before { + content: "\\f375"; } + +.fa-baby:before { + content: "\\f77c"; } + +.fa-baby-carriage:before { + content: "\\f77d"; } + +.fa-backspace:before { + content: "\\f55a"; } + +.fa-backward:before { + content: "\\f04a"; } + +.fa-bacon:before { + content: "\\f7e5"; } + +.fa-bacteria:before { + content: "\\e059"; } + +.fa-bacterium:before { + content: "\\e05a"; } + +.fa-bahai:before { + content: "\\f666"; } + +.fa-balance-scale:before { + content: "\\f24e"; } + +.fa-balance-scale-left:before { + content: "\\f515"; } + +.fa-balance-scale-right:before { + content: "\\f516"; } + +.fa-ban:before { + content: "\\f05e"; } + +.fa-band-aid:before { + content: "\\f462"; } + +.fa-bandcamp:before { + content: "\\f2d5"; } + +.fa-barcode:before { + content: "\\f02a"; } + +.fa-bars:before { + content: "\\f0c9"; } + +.fa-baseball-ball:before { + content: "\\f433"; } + +.fa-basketball-ball:before { + content: "\\f434"; } + +.fa-bath:before { + content: "\\f2cd"; } + +.fa-battery-empty:before { + content: "\\f244"; } + +.fa-battery-full:before { + content: "\\f240"; } + +.fa-battery-half:before { + content: "\\f242"; } + +.fa-battery-quarter:before { + content: "\\f243"; } + +.fa-battery-three-quarters:before { + content: "\\f241"; } + +.fa-battle-net:before { + content: "\\f835"; } + +.fa-bed:before { + content: "\\f236"; } + +.fa-beer:before { + content: "\\f0fc"; } + +.fa-behance:before { + content: "\\f1b4"; } + +.fa-behance-square:before { + content: "\\f1b5"; } + +.fa-bell:before { + content: "\\f0f3"; } + +.fa-bell-slash:before { + content: "\\f1f6"; } + +.fa-bezier-curve:before { + content: "\\f55b"; } + +.fa-bible:before { + content: "\\f647"; } + +.fa-bicycle:before { + content: "\\f206"; } + +.fa-biking:before { + content: "\\f84a"; } + +.fa-bimobject:before { + content: "\\f378"; } + +.fa-binoculars:before { + content: "\\f1e5"; } + +.fa-biohazard:before { + content: "\\f780"; } + +.fa-birthday-cake:before { + content: "\\f1fd"; } + +.fa-bitbucket:before { + content: "\\f171"; } + +.fa-bitcoin:before { + content: "\\f379"; } + +.fa-bity:before { + content: "\\f37a"; } + +.fa-black-tie:before { + content: "\\f27e"; } + +.fa-blackberry:before { + content: "\\f37b"; } + +.fa-blender:before { + content: "\\f517"; } + +.fa-blender-phone:before { + content: "\\f6b6"; } + +.fa-blind:before { + content: "\\f29d"; } + +.fa-blog:before { + content: "\\f781"; } + +.fa-blogger:before { + content: "\\f37c"; } + +.fa-blogger-b:before { + content: "\\f37d"; } + +.fa-bluetooth:before { + content: "\\f293"; } + +.fa-bluetooth-b:before { + content: "\\f294"; } + +.fa-bold:before { + content: "\\f032"; } + +.fa-bolt:before { + content: "\\f0e7"; } + +.fa-bomb:before { + content: "\\f1e2"; } + +.fa-bone:before { + content: "\\f5d7"; } + +.fa-bong:before { + content: "\\f55c"; } + +.fa-book:before { + content: "\\f02d"; } + +.fa-book-dead:before { + content: "\\f6b7"; } + +.fa-book-medical:before { + content: "\\f7e6"; } + +.fa-book-open:before { + content: "\\f518"; } + +.fa-book-reader:before { + content: "\\f5da"; } + +.fa-bookmark:before { + content: "\\f02e"; } + +.fa-bootstrap:before { + content: "\\f836"; } + +.fa-border-all:before { + content: "\\f84c"; } + +.fa-border-none:before { + content: "\\f850"; } + +.fa-border-style:before { + content: "\\f853"; } + +.fa-bowling-ball:before { + content: "\\f436"; } + +.fa-box:before { + content: "\\f466"; } + +.fa-box-open:before { + content: "\\f49e"; } + +.fa-box-tissue:before { + content: "\\e05b"; } + +.fa-boxes:before { + content: "\\f468"; } + +.fa-braille:before { + content: "\\f2a1"; } + +.fa-brain:before { + content: "\\f5dc"; } + +.fa-bread-slice:before { + content: "\\f7ec"; } + +.fa-briefcase:before { + content: "\\f0b1"; } + +.fa-briefcase-medical:before { + content: "\\f469"; } + +.fa-broadcast-tower:before { + content: "\\f519"; } + +.fa-broom:before { + content: "\\f51a"; } + +.fa-brush:before { + content: "\\f55d"; } + +.fa-btc:before { + content: "\\f15a"; } + +.fa-buffer:before { + content: "\\f837"; } + +.fa-bug:before { + content: "\\f188"; } + +.fa-building:before { + content: "\\f1ad"; } + +.fa-bullhorn:before { + content: "\\f0a1"; } + +.fa-bullseye:before { + content: "\\f140"; } + +.fa-burn:before { + content: "\\f46a"; } + +.fa-buromobelexperte:before { + content: "\\f37f"; } + +.fa-bus:before { + content: "\\f207"; } + +.fa-bus-alt:before { + content: "\\f55e"; } + +.fa-business-time:before { + content: "\\f64a"; } + +.fa-buy-n-large:before { + content: "\\f8a6"; } + +.fa-buysellads:before { + content: "\\f20d"; } + +.fa-calculator:before { + content: "\\f1ec"; } + +.fa-calendar:before { + content: "\\f133"; } + +.fa-calendar-alt:before { + content: "\\f073"; } + +.fa-calendar-check:before { + content: "\\f274"; } + +.fa-calendar-day:before { + content: "\\f783"; } + +.fa-calendar-minus:before { + content: "\\f272"; } + +.fa-calendar-plus:before { + content: "\\f271"; } + +.fa-calendar-times:before { + content: "\\f273"; } + +.fa-calendar-week:before { + content: "\\f784"; } + +.fa-camera:before { + content: "\\f030"; } + +.fa-camera-retro:before { + content: "\\f083"; } + +.fa-campground:before { + content: "\\f6bb"; } + +.fa-canadian-maple-leaf:before { + content: "\\f785"; } + +.fa-candy-cane:before { + content: "\\f786"; } + +.fa-cannabis:before { + content: "\\f55f"; } + +.fa-capsules:before { + content: "\\f46b"; } + +.fa-car:before { + content: "\\f1b9"; } + +.fa-car-alt:before { + content: "\\f5de"; } + +.fa-car-battery:before { + content: "\\f5df"; } + +.fa-car-crash:before { + content: "\\f5e1"; } + +.fa-car-side:before { + content: "\\f5e4"; } + +.fa-caravan:before { + content: "\\f8ff"; } + +.fa-caret-down:before { + content: "\\f0d7"; } + +.fa-caret-left:before { + content: "\\f0d9"; } + +.fa-caret-right:before { + content: "\\f0da"; } + +.fa-caret-square-down:before { + content: "\\f150"; } + +.fa-caret-square-left:before { + content: "\\f191"; } + +.fa-caret-square-right:before { + content: "\\f152"; } + +.fa-caret-square-up:before { + content: "\\f151"; } + +.fa-caret-up:before { + content: "\\f0d8"; } + +.fa-carrot:before { + content: "\\f787"; } + +.fa-cart-arrow-down:before { + content: "\\f218"; } + +.fa-cart-plus:before { + content: "\\f217"; } + +.fa-cash-register:before { + content: "\\f788"; } + +.fa-cat:before { + content: "\\f6be"; } + +.fa-cc-amazon-pay:before { + content: "\\f42d"; } + +.fa-cc-amex:before { + content: "\\f1f3"; } + +.fa-cc-apple-pay:before { + content: "\\f416"; } + +.fa-cc-diners-club:before { + content: "\\f24c"; } + +.fa-cc-discover:before { + content: "\\f1f2"; } + +.fa-cc-jcb:before { + content: "\\f24b"; } + +.fa-cc-mastercard:before { + content: "\\f1f1"; } + +.fa-cc-paypal:before { + content: "\\f1f4"; } + +.fa-cc-stripe:before { + content: "\\f1f5"; } + +.fa-cc-visa:before { + content: "\\f1f0"; } + +.fa-centercode:before { + content: "\\f380"; } + +.fa-centos:before { + content: "\\f789"; } + +.fa-certificate:before { + content: "\\f0a3"; } + +.fa-chair:before { + content: "\\f6c0"; } + +.fa-chalkboard:before { + content: "\\f51b"; } + +.fa-chalkboard-teacher:before { + content: "\\f51c"; } + +.fa-charging-station:before { + content: "\\f5e7"; } + +.fa-chart-area:before { + content: "\\f1fe"; } + +.fa-chart-bar:before { + content: "\\f080"; } + +.fa-chart-line:before { + content: "\\f201"; } + +.fa-chart-pie:before { + content: "\\f200"; } + +.fa-check:before { + content: "\\f00c"; } + +.fa-check-circle:before { + content: "\\f058"; } + +.fa-check-double:before { + content: "\\f560"; } + +.fa-check-square:before { + content: "\\f14a"; } + +.fa-cheese:before { + content: "\\f7ef"; } + +.fa-chess:before { + content: "\\f439"; } + +.fa-chess-bishop:before { + content: "\\f43a"; } + +.fa-chess-board:before { + content: "\\f43c"; } + +.fa-chess-king:before { + content: "\\f43f"; } + +.fa-chess-knight:before { + content: "\\f441"; } + +.fa-chess-pawn:before { + content: "\\f443"; } + +.fa-chess-queen:before { + content: "\\f445"; } + +.fa-chess-rook:before { + content: "\\f447"; } + +.fa-chevron-circle-down:before { + content: "\\f13a"; } + +.fa-chevron-circle-left:before { + content: "\\f137"; } + +.fa-chevron-circle-right:before { + content: "\\f138"; } + +.fa-chevron-circle-up:before { + content: "\\f139"; } + +.fa-chevron-down:before { + content: "\\f078"; } + +.fa-chevron-left:before { + content: "\\f053"; } + +.fa-chevron-right:before { + content: "\\f054"; } + +.fa-chevron-up:before { + content: "\\f077"; } + +.fa-child:before { + content: "\\f1ae"; } + +.fa-chrome:before { + content: "\\f268"; } + +.fa-chromecast:before { + content: "\\f838"; } + +.fa-church:before { + content: "\\f51d"; } + +.fa-circle:before { + content: "\\f111"; } + +.fa-circle-notch:before { + content: "\\f1ce"; } + +.fa-city:before { + content: "\\f64f"; } + +.fa-clinic-medical:before { + content: "\\f7f2"; } + +.fa-clipboard:before { + content: "\\f328"; } + +.fa-clipboard-check:before { + content: "\\f46c"; } + +.fa-clipboard-list:before { + content: "\\f46d"; } + +.fa-clock:before { + content: "\\f017"; } + +.fa-clone:before { + content: "\\f24d"; } + +.fa-closed-captioning:before { + content: "\\f20a"; } + +.fa-cloud:before { + content: "\\f0c2"; } + +.fa-cloud-download-alt:before { + content: "\\f381"; } + +.fa-cloud-meatball:before { + content: "\\f73b"; } + +.fa-cloud-moon:before { + content: "\\f6c3"; } + +.fa-cloud-moon-rain:before { + content: "\\f73c"; } + +.fa-cloud-rain:before { + content: "\\f73d"; } + +.fa-cloud-showers-heavy:before { + content: "\\f740"; } + +.fa-cloud-sun:before { + content: "\\f6c4"; } + +.fa-cloud-sun-rain:before { + content: "\\f743"; } + +.fa-cloud-upload-alt:before { + content: "\\f382"; } + +.fa-cloudflare:before { + content: "\\e07d"; } + +.fa-cloudscale:before { + content: "\\f383"; } + +.fa-cloudsmith:before { + content: "\\f384"; } + +.fa-cloudversify:before { + content: "\\f385"; } + +.fa-cocktail:before { + content: "\\f561"; } + +.fa-code:before { + content: "\\f121"; } + +.fa-code-branch:before { + content: "\\f126"; } + +.fa-codepen:before { + content: "\\f1cb"; } + +.fa-codiepie:before { + content: "\\f284"; } + +.fa-coffee:before { + content: "\\f0f4"; } + +.fa-cog:before { + content: "\\f013"; } + +.fa-cogs:before { + content: "\\f085"; } + +.fa-coins:before { + content: "\\f51e"; } + +.fa-columns:before { + content: "\\f0db"; } + +.fa-comment:before { + content: "\\f075"; } + +.fa-comment-alt:before { + content: "\\f27a"; } + +.fa-comment-dollar:before { + content: "\\f651"; } + +.fa-comment-dots:before { + content: "\\f4ad"; } + +.fa-comment-medical:before { + content: "\\f7f5"; } + +.fa-comment-slash:before { + content: "\\f4b3"; } + +.fa-comments:before { + content: "\\f086"; } + +.fa-comments-dollar:before { + content: "\\f653"; } + +.fa-compact-disc:before { + content: "\\f51f"; } + +.fa-compass:before { + content: "\\f14e"; } + +.fa-compress:before { + content: "\\f066"; } + +.fa-compress-alt:before { + content: "\\f422"; } + +.fa-compress-arrows-alt:before { + content: "\\f78c"; } + +.fa-concierge-bell:before { + content: "\\f562"; } + +.fa-confluence:before { + content: "\\f78d"; } + +.fa-connectdevelop:before { + content: "\\f20e"; } + +.fa-contao:before { + content: "\\f26d"; } + +.fa-cookie:before { + content: "\\f563"; } + +.fa-cookie-bite:before { + content: "\\f564"; } + +.fa-copy:before { + content: "\\f0c5"; } + +.fa-copyright:before { + content: "\\f1f9"; } + +.fa-cotton-bureau:before { + content: "\\f89e"; } + +.fa-couch:before { + content: "\\f4b8"; } + +.fa-cpanel:before { + content: "\\f388"; } + +.fa-creative-commons:before { + content: "\\f25e"; } + +.fa-creative-commons-by:before { + content: "\\f4e7"; } + +.fa-creative-commons-nc:before { + content: "\\f4e8"; } + +.fa-creative-commons-nc-eu:before { + content: "\\f4e9"; } + +.fa-creative-commons-nc-jp:before { + content: "\\f4ea"; } + +.fa-creative-commons-nd:before { + content: "\\f4eb"; } + +.fa-creative-commons-pd:before { + content: "\\f4ec"; } + +.fa-creative-commons-pd-alt:before { + content: "\\f4ed"; } + +.fa-creative-commons-remix:before { + content: "\\f4ee"; } + +.fa-creative-commons-sa:before { + content: "\\f4ef"; } + +.fa-creative-commons-sampling:before { + content: "\\f4f0"; } + +.fa-creative-commons-sampling-plus:before { + content: "\\f4f1"; } + +.fa-creative-commons-share:before { + content: "\\f4f2"; } + +.fa-creative-commons-zero:before { + content: "\\f4f3"; } + +.fa-credit-card:before { + content: "\\f09d"; } + +.fa-critical-role:before { + content: "\\f6c9"; } + +.fa-crop:before { + content: "\\f125"; } + +.fa-crop-alt:before { + content: "\\f565"; } + +.fa-cross:before { + content: "\\f654"; } + +.fa-crosshairs:before { + content: "\\f05b"; } + +.fa-crow:before { + content: "\\f520"; } + +.fa-crown:before { + content: "\\f521"; } + +.fa-crutch:before { + content: "\\f7f7"; } + +.fa-css3:before { + content: "\\f13c"; } + +.fa-css3-alt:before { + content: "\\f38b"; } + +.fa-cube:before { + content: "\\f1b2"; } + +.fa-cubes:before { + content: "\\f1b3"; } + +.fa-cut:before { + content: "\\f0c4"; } + +.fa-cuttlefish:before { + content: "\\f38c"; } + +.fa-d-and-d:before { + content: "\\f38d"; } + +.fa-d-and-d-beyond:before { + content: "\\f6ca"; } + +.fa-dailymotion:before { + content: "\\e052"; } + +.fa-dashcube:before { + content: "\\f210"; } + +.fa-database:before { + content: "\\f1c0"; } + +.fa-deaf:before { + content: "\\f2a4"; } + +.fa-deezer:before { + content: "\\e077"; } + +.fa-delicious:before { + content: "\\f1a5"; } + +.fa-democrat:before { + content: "\\f747"; } + +.fa-deploydog:before { + content: "\\f38e"; } + +.fa-deskpro:before { + content: "\\f38f"; } + +.fa-desktop:before { + content: "\\f108"; } + +.fa-dev:before { + content: "\\f6cc"; } + +.fa-deviantart:before { + content: "\\f1bd"; } + +.fa-dharmachakra:before { + content: "\\f655"; } + +.fa-dhl:before { + content: "\\f790"; } + +.fa-diagnoses:before { + content: "\\f470"; } + +.fa-diaspora:before { + content: "\\f791"; } + +.fa-dice:before { + content: "\\f522"; } + +.fa-dice-d20:before { + content: "\\f6cf"; } + +.fa-dice-d6:before { + content: "\\f6d1"; } + +.fa-dice-five:before { + content: "\\f523"; } + +.fa-dice-four:before { + content: "\\f524"; } + +.fa-dice-one:before { + content: "\\f525"; } + +.fa-dice-six:before { + content: "\\f526"; } + +.fa-dice-three:before { + content: "\\f527"; } + +.fa-dice-two:before { + content: "\\f528"; } + +.fa-digg:before { + content: "\\f1a6"; } + +.fa-digital-ocean:before { + content: "\\f391"; } + +.fa-digital-tachograph:before { + content: "\\f566"; } + +.fa-directions:before { + content: "\\f5eb"; } + +.fa-discord:before { + content: "\\f392"; } + +.fa-discourse:before { + content: "\\f393"; } + +.fa-disease:before { + content: "\\f7fa"; } + +.fa-divide:before { + content: "\\f529"; } + +.fa-dizzy:before { + content: "\\f567"; } + +.fa-dna:before { + content: "\\f471"; } + +.fa-dochub:before { + content: "\\f394"; } + +.fa-docker:before { + content: "\\f395"; } + +.fa-dog:before { + content: "\\f6d3"; } + +.fa-dollar-sign:before { + content: "\\f155"; } + +.fa-dolly:before { + content: "\\f472"; } + +.fa-dolly-flatbed:before { + content: "\\f474"; } + +.fa-donate:before { + content: "\\f4b9"; } + +.fa-door-closed:before { + content: "\\f52a"; } + +.fa-door-open:before { + content: "\\f52b"; } + +.fa-dot-circle:before { + content: "\\f192"; } + +.fa-dove:before { + content: "\\f4ba"; } + +.fa-download:before { + content: "\\f019"; } + +.fa-draft2digital:before { + content: "\\f396"; } + +.fa-drafting-compass:before { + content: "\\f568"; } + +.fa-dragon:before { + content: "\\f6d5"; } + +.fa-draw-polygon:before { + content: "\\f5ee"; } + +.fa-dribbble:before { + content: "\\f17d"; } + +.fa-dribbble-square:before { + content: "\\f397"; } + +.fa-dropbox:before { + content: "\\f16b"; } + +.fa-drum:before { + content: "\\f569"; } + +.fa-drum-steelpan:before { + content: "\\f56a"; } + +.fa-drumstick-bite:before { + content: "\\f6d7"; } + +.fa-drupal:before { + content: "\\f1a9"; } + +.fa-dumbbell:before { + content: "\\f44b"; } + +.fa-dumpster:before { + content: "\\f793"; } + +.fa-dumpster-fire:before { + content: "\\f794"; } + +.fa-dungeon:before { + content: "\\f6d9"; } + +.fa-dyalog:before { + content: "\\f399"; } + +.fa-earlybirds:before { + content: "\\f39a"; } + +.fa-ebay:before { + content: "\\f4f4"; } + +.fa-edge:before { + content: "\\f282"; } + +.fa-edge-legacy:before { + content: "\\e078"; } + +.fa-edit:before { + content: "\\f044"; } + +.fa-egg:before { + content: "\\f7fb"; } + +.fa-eject:before { + content: "\\f052"; } + +.fa-elementor:before { + content: "\\f430"; } + +.fa-ellipsis-h:before { + content: "\\f141"; } + +.fa-ellipsis-v:before { + content: "\\f142"; } + +.fa-ello:before { + content: "\\f5f1"; } + +.fa-ember:before { + content: "\\f423"; } + +.fa-empire:before { + content: "\\f1d1"; } + +.fa-envelope:before { + content: "\\f0e0"; } + +.fa-envelope-open:before { + content: "\\f2b6"; } + +.fa-envelope-open-text:before { + content: "\\f658"; } + +.fa-envelope-square:before { + content: "\\f199"; } + +.fa-envira:before { + content: "\\f299"; } + +.fa-equals:before { + content: "\\f52c"; } + +.fa-eraser:before { + content: "\\f12d"; } + +.fa-erlang:before { + content: "\\f39d"; } + +.fa-ethereum:before { + content: "\\f42e"; } + +.fa-ethernet:before { + content: "\\f796"; } + +.fa-etsy:before { + content: "\\f2d7"; } + +.fa-euro-sign:before { + content: "\\f153"; } + +.fa-evernote:before { + content: "\\f839"; } + +.fa-exchange-alt:before { + content: "\\f362"; } + +.fa-exclamation:before { + content: "\\f12a"; } + +.fa-exclamation-circle:before { + content: "\\f06a"; } + +.fa-exclamation-triangle:before { + content: "\\f071"; } + +.fa-expand:before { + content: "\\f065"; } + +.fa-expand-alt:before { + content: "\\f424"; } + +.fa-expand-arrows-alt:before { + content: "\\f31e"; } + +.fa-expeditedssl:before { + content: "\\f23e"; } + +.fa-external-link-alt:before { + content: "\\f35d"; } + +.fa-external-link-square-alt:before { + content: "\\f360"; } + +.fa-eye:before { + content: "\\f06e"; } + +.fa-eye-dropper:before { + content: "\\f1fb"; } + +.fa-eye-slash:before { + content: "\\f070"; } + +.fa-facebook:before { + content: "\\f09a"; } + +.fa-facebook-f:before { + content: "\\f39e"; } + +.fa-facebook-messenger:before { + content: "\\f39f"; } + +.fa-facebook-square:before { + content: "\\f082"; } + +.fa-fan:before { + content: "\\f863"; } + +.fa-fantasy-flight-games:before { + content: "\\f6dc"; } + +.fa-fast-backward:before { + content: "\\f049"; } + +.fa-fast-forward:before { + content: "\\f050"; } + +.fa-faucet:before { + content: "\\e005"; } + +.fa-fax:before { + content: "\\f1ac"; } + +.fa-feather:before { + content: "\\f52d"; } + +.fa-feather-alt:before { + content: "\\f56b"; } + +.fa-fedex:before { + content: "\\f797"; } + +.fa-fedora:before { + content: "\\f798"; } + +.fa-female:before { + content: "\\f182"; } + +.fa-fighter-jet:before { + content: "\\f0fb"; } + +.fa-figma:before { + content: "\\f799"; } + +.fa-file:before { + content: "\\f15b"; } + +.fa-file-alt:before { + content: "\\f15c"; } + +.fa-file-archive:before { + content: "\\f1c6"; } + +.fa-file-audio:before { + content: "\\f1c7"; } + +.fa-file-code:before { + content: "\\f1c9"; } + +.fa-file-contract:before { + content: "\\f56c"; } + +.fa-file-csv:before { + content: "\\f6dd"; } + +.fa-file-download:before { + content: "\\f56d"; } + +.fa-file-excel:before { + content: "\\f1c3"; } + +.fa-file-export:before { + content: "\\f56e"; } + +.fa-file-image:before { + content: "\\f1c5"; } + +.fa-file-import:before { + content: "\\f56f"; } + +.fa-file-invoice:before { + content: "\\f570"; } + +.fa-file-invoice-dollar:before { + content: "\\f571"; } + +.fa-file-medical:before { + content: "\\f477"; } + +.fa-file-medical-alt:before { + content: "\\f478"; } + +.fa-file-pdf:before { + content: "\\f1c1"; } + +.fa-file-powerpoint:before { + content: "\\f1c4"; } + +.fa-file-prescription:before { + content: "\\f572"; } + +.fa-file-signature:before { + content: "\\f573"; } + +.fa-file-upload:before { + content: "\\f574"; } + +.fa-file-video:before { + content: "\\f1c8"; } + +.fa-file-word:before { + content: "\\f1c2"; } + +.fa-fill:before { + content: "\\f575"; } + +.fa-fill-drip:before { + content: "\\f576"; } + +.fa-film:before { + content: "\\f008"; } + +.fa-filter:before { + content: "\\f0b0"; } + +.fa-fingerprint:before { + content: "\\f577"; } + +.fa-fire:before { + content: "\\f06d"; } + +.fa-fire-alt:before { + content: "\\f7e4"; } + +.fa-fire-extinguisher:before { + content: "\\f134"; } + +.fa-firefox:before { + content: "\\f269"; } + +.fa-firefox-browser:before { + content: "\\e007"; } + +.fa-first-aid:before { + content: "\\f479"; } + +.fa-first-order:before { + content: "\\f2b0"; } + +.fa-first-order-alt:before { + content: "\\f50a"; } + +.fa-firstdraft:before { + content: "\\f3a1"; } + +.fa-fish:before { + content: "\\f578"; } + +.fa-fist-raised:before { + content: "\\f6de"; } + +.fa-flag:before { + content: "\\f024"; } + +.fa-flag-checkered:before { + content: "\\f11e"; } + +.fa-flag-usa:before { + content: "\\f74d"; } + +.fa-flask:before { + content: "\\f0c3"; } + +.fa-flickr:before { + content: "\\f16e"; } + +.fa-flipboard:before { + content: "\\f44d"; } + +.fa-flushed:before { + content: "\\f579"; } + +.fa-fly:before { + content: "\\f417"; } + +.fa-folder:before { + content: "\\f07b"; } + +.fa-folder-minus:before { + content: "\\f65d"; } + +.fa-folder-open:before { + content: "\\f07c"; } + +.fa-folder-plus:before { + content: "\\f65e"; } + +.fa-font:before { + content: "\\f031"; } + +.fa-font-awesome:before { + content: "\\f2b4"; } + +.fa-font-awesome-alt:before { + content: "\\f35c"; } + +.fa-font-awesome-flag:before { + content: "\\f425"; } + +.fa-font-awesome-logo-full:before { + content: "\\f4e6"; } + +.fa-fonticons:before { + content: "\\f280"; } + +.fa-fonticons-fi:before { + content: "\\f3a2"; } + +.fa-football-ball:before { + content: "\\f44e"; } + +.fa-fort-awesome:before { + content: "\\f286"; } + +.fa-fort-awesome-alt:before { + content: "\\f3a3"; } + +.fa-forumbee:before { + content: "\\f211"; } + +.fa-forward:before { + content: "\\f04e"; } + +.fa-foursquare:before { + content: "\\f180"; } + +.fa-free-code-camp:before { + content: "\\f2c5"; } + +.fa-freebsd:before { + content: "\\f3a4"; } + +.fa-frog:before { + content: "\\f52e"; } + +.fa-frown:before { + content: "\\f119"; } + +.fa-frown-open:before { + content: "\\f57a"; } + +.fa-fulcrum:before { + content: "\\f50b"; } + +.fa-funnel-dollar:before { + content: "\\f662"; } + +.fa-futbol:before { + content: "\\f1e3"; } + +.fa-galactic-republic:before { + content: "\\f50c"; } + +.fa-galactic-senate:before { + content: "\\f50d"; } + +.fa-gamepad:before { + content: "\\f11b"; } + +.fa-gas-pump:before { + content: "\\f52f"; } + +.fa-gavel:before { + content: "\\f0e3"; } + +.fa-gem:before { + content: "\\f3a5"; } + +.fa-genderless:before { + content: "\\f22d"; } + +.fa-get-pocket:before { + content: "\\f265"; } + +.fa-gg:before { + content: "\\f260"; } + +.fa-gg-circle:before { + content: "\\f261"; } + +.fa-ghost:before { + content: "\\f6e2"; } + +.fa-gift:before { + content: "\\f06b"; } + +.fa-gifts:before { + content: "\\f79c"; } + +.fa-git:before { + content: "\\f1d3"; } + +.fa-git-alt:before { + content: "\\f841"; } + +.fa-git-square:before { + content: "\\f1d2"; } + +.fa-github:before { + content: "\\f09b"; } + +.fa-github-alt:before { + content: "\\f113"; } + +.fa-github-square:before { + content: "\\f092"; } + +.fa-gitkraken:before { + content: "\\f3a6"; } + +.fa-gitlab:before { + content: "\\f296"; } + +.fa-gitter:before { + content: "\\f426"; } + +.fa-glass-cheers:before { + content: "\\f79f"; } + +.fa-glass-martini:before { + content: "\\f000"; } + +.fa-glass-martini-alt:before { + content: "\\f57b"; } + +.fa-glass-whiskey:before { + content: "\\f7a0"; } + +.fa-glasses:before { + content: "\\f530"; } + +.fa-glide:before { + content: "\\f2a5"; } + +.fa-glide-g:before { + content: "\\f2a6"; } + +.fa-globe:before { + content: "\\f0ac"; } + +.fa-globe-africa:before { + content: "\\f57c"; } + +.fa-globe-americas:before { + content: "\\f57d"; } + +.fa-globe-asia:before { + content: "\\f57e"; } + +.fa-globe-europe:before { + content: "\\f7a2"; } + +.fa-gofore:before { + content: "\\f3a7"; } + +.fa-golf-ball:before { + content: "\\f450"; } + +.fa-goodreads:before { + content: "\\f3a8"; } + +.fa-goodreads-g:before { + content: "\\f3a9"; } + +.fa-google:before { + content: "\\f1a0"; } + +.fa-google-drive:before { + content: "\\f3aa"; } + +.fa-google-pay:before { + content: "\\e079"; } + +.fa-google-play:before { + content: "\\f3ab"; } + +.fa-google-plus:before { + content: "\\f2b3"; } + +.fa-google-plus-g:before { + content: "\\f0d5"; } + +.fa-google-plus-square:before { + content: "\\f0d4"; } + +.fa-google-wallet:before { + content: "\\f1ee"; } + +.fa-gopuram:before { + content: "\\f664"; } + +.fa-graduation-cap:before { + content: "\\f19d"; } + +.fa-gratipay:before { + content: "\\f184"; } + +.fa-grav:before { + content: "\\f2d6"; } + +.fa-greater-than:before { + content: "\\f531"; } + +.fa-greater-than-equal:before { + content: "\\f532"; } + +.fa-grimace:before { + content: "\\f57f"; } + +.fa-grin:before { + content: "\\f580"; } + +.fa-grin-alt:before { + content: "\\f581"; } + +.fa-grin-beam:before { + content: "\\f582"; } + +.fa-grin-beam-sweat:before { + content: "\\f583"; } + +.fa-grin-hearts:before { + content: "\\f584"; } + +.fa-grin-squint:before { + content: "\\f585"; } + +.fa-grin-squint-tears:before { + content: "\\f586"; } + +.fa-grin-stars:before { + content: "\\f587"; } + +.fa-grin-tears:before { + content: "\\f588"; } + +.fa-grin-tongue:before { + content: "\\f589"; } + +.fa-grin-tongue-squint:before { + content: "\\f58a"; } + +.fa-grin-tongue-wink:before { + content: "\\f58b"; } + +.fa-grin-wink:before { + content: "\\f58c"; } + +.fa-grip-horizontal:before { + content: "\\f58d"; } + +.fa-grip-lines:before { + content: "\\f7a4"; } + +.fa-grip-lines-vertical:before { + content: "\\f7a5"; } + +.fa-grip-vertical:before { + content: "\\f58e"; } + +.fa-gripfire:before { + content: "\\f3ac"; } + +.fa-grunt:before { + content: "\\f3ad"; } + +.fa-guilded:before { + content: "\\e07e"; } + +.fa-guitar:before { + content: "\\f7a6"; } + +.fa-gulp:before { + content: "\\f3ae"; } + +.fa-h-square:before { + content: "\\f0fd"; } + +.fa-hacker-news:before { + content: "\\f1d4"; } + +.fa-hacker-news-square:before { + content: "\\f3af"; } + +.fa-hackerrank:before { + content: "\\f5f7"; } + +.fa-hamburger:before { + content: "\\f805"; } + +.fa-hammer:before { + content: "\\f6e3"; } + +.fa-hamsa:before { + content: "\\f665"; } + +.fa-hand-holding:before { + content: "\\f4bd"; } + +.fa-hand-holding-heart:before { + content: "\\f4be"; } + +.fa-hand-holding-medical:before { + content: "\\e05c"; } + +.fa-hand-holding-usd:before { + content: "\\f4c0"; } + +.fa-hand-holding-water:before { + content: "\\f4c1"; } + +.fa-hand-lizard:before { + content: "\\f258"; } + +.fa-hand-middle-finger:before { + content: "\\f806"; } + +.fa-hand-paper:before { + content: "\\f256"; } + +.fa-hand-peace:before { + content: "\\f25b"; } + +.fa-hand-point-down:before { + content: "\\f0a7"; } + +.fa-hand-point-left:before { + content: "\\f0a5"; } + +.fa-hand-point-right:before { + content: "\\f0a4"; } + +.fa-hand-point-up:before { + content: "\\f0a6"; } + +.fa-hand-pointer:before { + content: "\\f25a"; } + +.fa-hand-rock:before { + content: "\\f255"; } + +.fa-hand-scissors:before { + content: "\\f257"; } + +.fa-hand-sparkles:before { + content: "\\e05d"; } + +.fa-hand-spock:before { + content: "\\f259"; } + +.fa-hands:before { + content: "\\f4c2"; } + +.fa-hands-helping:before { + content: "\\f4c4"; } + +.fa-hands-wash:before { + content: "\\e05e"; } + +.fa-handshake:before { + content: "\\f2b5"; } + +.fa-handshake-alt-slash:before { + content: "\\e05f"; } + +.fa-handshake-slash:before { + content: "\\e060"; } + +.fa-hanukiah:before { + content: "\\f6e6"; } + +.fa-hard-hat:before { + content: "\\f807"; } + +.fa-hashtag:before { + content: "\\f292"; } + +.fa-hat-cowboy:before { + content: "\\f8c0"; } + +.fa-hat-cowboy-side:before { + content: "\\f8c1"; } + +.fa-hat-wizard:before { + content: "\\f6e8"; } + +.fa-hdd:before { + content: "\\f0a0"; } + +.fa-head-side-cough:before { + content: "\\e061"; } + +.fa-head-side-cough-slash:before { + content: "\\e062"; } + +.fa-head-side-mask:before { + content: "\\e063"; } + +.fa-head-side-virus:before { + content: "\\e064"; } + +.fa-heading:before { + content: "\\f1dc"; } + +.fa-headphones:before { + content: "\\f025"; } + +.fa-headphones-alt:before { + content: "\\f58f"; } + +.fa-headset:before { + content: "\\f590"; } + +.fa-heart:before { + content: "\\f004"; } + +.fa-heart-broken:before { + content: "\\f7a9"; } + +.fa-heartbeat:before { + content: "\\f21e"; } + +.fa-helicopter:before { + content: "\\f533"; } + +.fa-highlighter:before { + content: "\\f591"; } + +.fa-hiking:before { + content: "\\f6ec"; } + +.fa-hippo:before { + content: "\\f6ed"; } + +.fa-hips:before { + content: "\\f452"; } + +.fa-hire-a-helper:before { + content: "\\f3b0"; } + +.fa-history:before { + content: "\\f1da"; } + +.fa-hive:before { + content: "\\e07f"; } + +.fa-hockey-puck:before { + content: "\\f453"; } + +.fa-holly-berry:before { + content: "\\f7aa"; } + +.fa-home:before { + content: "\\f015"; } + +.fa-hooli:before { + content: "\\f427"; } + +.fa-hornbill:before { + content: "\\f592"; } + +.fa-horse:before { + content: "\\f6f0"; } + +.fa-horse-head:before { + content: "\\f7ab"; } + +.fa-hospital:before { + content: "\\f0f8"; } + +.fa-hospital-alt:before { + content: "\\f47d"; } + +.fa-hospital-symbol:before { + content: "\\f47e"; } + +.fa-hospital-user:before { + content: "\\f80d"; } + +.fa-hot-tub:before { + content: "\\f593"; } + +.fa-hotdog:before { + content: "\\f80f"; } + +.fa-hotel:before { + content: "\\f594"; } + +.fa-hotjar:before { + content: "\\f3b1"; } + +.fa-hourglass:before { + content: "\\f254"; } + +.fa-hourglass-end:before { + content: "\\f253"; } + +.fa-hourglass-half:before { + content: "\\f252"; } + +.fa-hourglass-start:before { + content: "\\f251"; } + +.fa-house-damage:before { + content: "\\f6f1"; } + +.fa-house-user:before { + content: "\\e065"; } + +.fa-houzz:before { + content: "\\f27c"; } + +.fa-hryvnia:before { + content: "\\f6f2"; } + +.fa-html5:before { + content: "\\f13b"; } + +.fa-hubspot:before { + content: "\\f3b2"; } + +.fa-i-cursor:before { + content: "\\f246"; } + +.fa-ice-cream:before { + content: "\\f810"; } + +.fa-icicles:before { + content: "\\f7ad"; } + +.fa-icons:before { + content: "\\f86d"; } + +.fa-id-badge:before { + content: "\\f2c1"; } + +.fa-id-card:before { + content: "\\f2c2"; } + +.fa-id-card-alt:before { + content: "\\f47f"; } + +.fa-ideal:before { + content: "\\e013"; } + +.fa-igloo:before { + content: "\\f7ae"; } + +.fa-image:before { + content: "\\f03e"; } + +.fa-images:before { + content: "\\f302"; } + +.fa-imdb:before { + content: "\\f2d8"; } + +.fa-inbox:before { + content: "\\f01c"; } + +.fa-indent:before { + content: "\\f03c"; } + +.fa-industry:before { + content: "\\f275"; } + +.fa-infinity:before { + content: "\\f534"; } + +.fa-info:before { + content: "\\f129"; } + +.fa-info-circle:before { + content: "\\f05a"; } + +.fa-innosoft:before { + content: "\\e080"; } + +.fa-instagram:before { + content: "\\f16d"; } + +.fa-instagram-square:before { + content: "\\e055"; } + +.fa-instalod:before { + content: "\\e081"; } + +.fa-intercom:before { + content: "\\f7af"; } + +.fa-internet-explorer:before { + content: "\\f26b"; } + +.fa-invision:before { + content: "\\f7b0"; } + +.fa-ioxhost:before { + content: "\\f208"; } + +.fa-italic:before { + content: "\\f033"; } + +.fa-itch-io:before { + content: "\\f83a"; } + +.fa-itunes:before { + content: "\\f3b4"; } + +.fa-itunes-note:before { + content: "\\f3b5"; } + +.fa-java:before { + content: "\\f4e4"; } + +.fa-jedi:before { + content: "\\f669"; } + +.fa-jedi-order:before { + content: "\\f50e"; } + +.fa-jenkins:before { + content: "\\f3b6"; } + +.fa-jira:before { + content: "\\f7b1"; } + +.fa-joget:before { + content: "\\f3b7"; } + +.fa-joint:before { + content: "\\f595"; } + +.fa-joomla:before { + content: "\\f1aa"; } + +.fa-journal-whills:before { + content: "\\f66a"; } + +.fa-js:before { + content: "\\f3b8"; } + +.fa-js-square:before { + content: "\\f3b9"; } + +.fa-jsfiddle:before { + content: "\\f1cc"; } + +.fa-kaaba:before { + content: "\\f66b"; } + +.fa-kaggle:before { + content: "\\f5fa"; } + +.fa-key:before { + content: "\\f084"; } + +.fa-keybase:before { + content: "\\f4f5"; } + +.fa-keyboard:before { + content: "\\f11c"; } + +.fa-keycdn:before { + content: "\\f3ba"; } + +.fa-khanda:before { + content: "\\f66d"; } + +.fa-kickstarter:before { + content: "\\f3bb"; } + +.fa-kickstarter-k:before { + content: "\\f3bc"; } + +.fa-kiss:before { + content: "\\f596"; } + +.fa-kiss-beam:before { + content: "\\f597"; } + +.fa-kiss-wink-heart:before { + content: "\\f598"; } + +.fa-kiwi-bird:before { + content: "\\f535"; } + +.fa-korvue:before { + content: "\\f42f"; } + +.fa-landmark:before { + content: "\\f66f"; } + +.fa-language:before { + content: "\\f1ab"; } + +.fa-laptop:before { + content: "\\f109"; } + +.fa-laptop-code:before { + content: "\\f5fc"; } + +.fa-laptop-house:before { + content: "\\e066"; } + +.fa-laptop-medical:before { + content: "\\f812"; } + +.fa-laravel:before { + content: "\\f3bd"; } + +.fa-lastfm:before { + content: "\\f202"; } + +.fa-lastfm-square:before { + content: "\\f203"; } + +.fa-laugh:before { + content: "\\f599"; } + +.fa-laugh-beam:before { + content: "\\f59a"; } + +.fa-laugh-squint:before { + content: "\\f59b"; } + +.fa-laugh-wink:before { + content: "\\f59c"; } + +.fa-layer-group:before { + content: "\\f5fd"; } + +.fa-leaf:before { + content: "\\f06c"; } + +.fa-leanpub:before { + content: "\\f212"; } + +.fa-lemon:before { + content: "\\f094"; } + +.fa-less:before { + content: "\\f41d"; } + +.fa-less-than:before { + content: "\\f536"; } + +.fa-less-than-equal:before { + content: "\\f537"; } + +.fa-level-down-alt:before { + content: "\\f3be"; } + +.fa-level-up-alt:before { + content: "\\f3bf"; } + +.fa-life-ring:before { + content: "\\f1cd"; } + +.fa-lightbulb:before { + content: "\\f0eb"; } + +.fa-line:before { + content: "\\f3c0"; } + +.fa-link:before { + content: "\\f0c1"; } + +.fa-linkedin:before { + content: "\\f08c"; } + +.fa-linkedin-in:before { + content: "\\f0e1"; } + +.fa-linode:before { + content: "\\f2b8"; } + +.fa-linux:before { + content: "\\f17c"; } + +.fa-lira-sign:before { + content: "\\f195"; } + +.fa-list:before { + content: "\\f03a"; } + +.fa-list-alt:before { + content: "\\f022"; } + +.fa-list-ol:before { + content: "\\f0cb"; } + +.fa-list-ul:before { + content: "\\f0ca"; } + +.fa-location-arrow:before { + content: "\\f124"; } + +.fa-lock:before { + content: "\\f023"; } + +.fa-lock-open:before { + content: "\\f3c1"; } + +.fa-long-arrow-alt-down:before { + content: "\\f309"; } + +.fa-long-arrow-alt-left:before { + content: "\\f30a"; } + +.fa-long-arrow-alt-right:before { + content: "\\f30b"; } + +.fa-long-arrow-alt-up:before { + content: "\\f30c"; } + +.fa-low-vision:before { + content: "\\f2a8"; } + +.fa-luggage-cart:before { + content: "\\f59d"; } + +.fa-lungs:before { + content: "\\f604"; } + +.fa-lungs-virus:before { + content: "\\e067"; } + +.fa-lyft:before { + content: "\\f3c3"; } + +.fa-magento:before { + content: "\\f3c4"; } + +.fa-magic:before { + content: "\\f0d0"; } + +.fa-magnet:before { + content: "\\f076"; } + +.fa-mail-bulk:before { + content: "\\f674"; } + +.fa-mailchimp:before { + content: "\\f59e"; } + +.fa-male:before { + content: "\\f183"; } + +.fa-mandalorian:before { + content: "\\f50f"; } + +.fa-map:before { + content: "\\f279"; } + +.fa-map-marked:before { + content: "\\f59f"; } + +.fa-map-marked-alt:before { + content: "\\f5a0"; } + +.fa-map-marker:before { + content: "\\f041"; } + +.fa-map-marker-alt:before { + content: "\\f3c5"; } + +.fa-map-pin:before { + content: "\\f276"; } + +.fa-map-signs:before { + content: "\\f277"; } + +.fa-markdown:before { + content: "\\f60f"; } + +.fa-marker:before { + content: "\\f5a1"; } + +.fa-mars:before { + content: "\\f222"; } + +.fa-mars-double:before { + content: "\\f227"; } + +.fa-mars-stroke:before { + content: "\\f229"; } + +.fa-mars-stroke-h:before { + content: "\\f22b"; } + +.fa-mars-stroke-v:before { + content: "\\f22a"; } + +.fa-mask:before { + content: "\\f6fa"; } + +.fa-mastodon:before { + content: "\\f4f6"; } + +.fa-maxcdn:before { + content: "\\f136"; } + +.fa-mdb:before { + content: "\\f8ca"; } + +.fa-medal:before { + content: "\\f5a2"; } + +.fa-medapps:before { + content: "\\f3c6"; } + +.fa-medium:before { + content: "\\f23a"; } + +.fa-medium-m:before { + content: "\\f3c7"; } + +.fa-medkit:before { + content: "\\f0fa"; } + +.fa-medrt:before { + content: "\\f3c8"; } + +.fa-meetup:before { + content: "\\f2e0"; } + +.fa-megaport:before { + content: "\\f5a3"; } + +.fa-meh:before { + content: "\\f11a"; } + +.fa-meh-blank:before { + content: "\\f5a4"; } + +.fa-meh-rolling-eyes:before { + content: "\\f5a5"; } + +.fa-memory:before { + content: "\\f538"; } + +.fa-mendeley:before { + content: "\\f7b3"; } + +.fa-menorah:before { + content: "\\f676"; } + +.fa-mercury:before { + content: "\\f223"; } + +.fa-meteor:before { + content: "\\f753"; } + +.fa-microblog:before { + content: "\\e01a"; } + +.fa-microchip:before { + content: "\\f2db"; } + +.fa-microphone:before { + content: "\\f130"; } + +.fa-microphone-alt:before { + content: "\\f3c9"; } + +.fa-microphone-alt-slash:before { + content: "\\f539"; } + +.fa-microphone-slash:before { + content: "\\f131"; } + +.fa-microscope:before { + content: "\\f610"; } + +.fa-microsoft:before { + content: "\\f3ca"; } + +.fa-minus:before { + content: "\\f068"; } + +.fa-minus-circle:before { + content: "\\f056"; } + +.fa-minus-square:before { + content: "\\f146"; } + +.fa-mitten:before { + content: "\\f7b5"; } + +.fa-mix:before { + content: "\\f3cb"; } + +.fa-mixcloud:before { + content: "\\f289"; } + +.fa-mixer:before { + content: "\\e056"; } + +.fa-mizuni:before { + content: "\\f3cc"; } + +.fa-mobile:before { + content: "\\f10b"; } + +.fa-mobile-alt:before { + content: "\\f3cd"; } + +.fa-modx:before { + content: "\\f285"; } + +.fa-monero:before { + content: "\\f3d0"; } + +.fa-money-bill:before { + content: "\\f0d6"; } + +.fa-money-bill-alt:before { + content: "\\f3d1"; } + +.fa-money-bill-wave:before { + content: "\\f53a"; } + +.fa-money-bill-wave-alt:before { + content: "\\f53b"; } + +.fa-money-check:before { + content: "\\f53c"; } + +.fa-money-check-alt:before { + content: "\\f53d"; } + +.fa-monument:before { + content: "\\f5a6"; } + +.fa-moon:before { + content: "\\f186"; } + +.fa-mortar-pestle:before { + content: "\\f5a7"; } + +.fa-mosque:before { + content: "\\f678"; } + +.fa-motorcycle:before { + content: "\\f21c"; } + +.fa-mountain:before { + content: "\\f6fc"; } + +.fa-mouse:before { + content: "\\f8cc"; } + +.fa-mouse-pointer:before { + content: "\\f245"; } + +.fa-mug-hot:before { + content: "\\f7b6"; } + +.fa-music:before { + content: "\\f001"; } + +.fa-napster:before { + content: "\\f3d2"; } + +.fa-neos:before { + content: "\\f612"; } + +.fa-network-wired:before { + content: "\\f6ff"; } + +.fa-neuter:before { + content: "\\f22c"; } + +.fa-newspaper:before { + content: "\\f1ea"; } + +.fa-nimblr:before { + content: "\\f5a8"; } + +.fa-node:before { + content: "\\f419"; } + +.fa-node-js:before { + content: "\\f3d3"; } + +.fa-not-equal:before { + content: "\\f53e"; } + +.fa-notes-medical:before { + content: "\\f481"; } + +.fa-npm:before { + content: "\\f3d4"; } + +.fa-ns8:before { + content: "\\f3d5"; } + +.fa-nutritionix:before { + content: "\\f3d6"; } + +.fa-object-group:before { + content: "\\f247"; } + +.fa-object-ungroup:before { + content: "\\f248"; } + +.fa-octopus-deploy:before { + content: "\\e082"; } + +.fa-odnoklassniki:before { + content: "\\f263"; } + +.fa-odnoklassniki-square:before { + content: "\\f264"; } + +.fa-oil-can:before { + content: "\\f613"; } + +.fa-old-republic:before { + content: "\\f510"; } + +.fa-om:before { + content: "\\f679"; } + +.fa-opencart:before { + content: "\\f23d"; } + +.fa-openid:before { + content: "\\f19b"; } + +.fa-opera:before { + content: "\\f26a"; } + +.fa-optin-monster:before { + content: "\\f23c"; } + +.fa-orcid:before { + content: "\\f8d2"; } + +.fa-osi:before { + content: "\\f41a"; } + +.fa-otter:before { + content: "\\f700"; } + +.fa-outdent:before { + content: "\\f03b"; } + +.fa-page4:before { + content: "\\f3d7"; } + +.fa-pagelines:before { + content: "\\f18c"; } + +.fa-pager:before { + content: "\\f815"; } + +.fa-paint-brush:before { + content: "\\f1fc"; } + +.fa-paint-roller:before { + content: "\\f5aa"; } + +.fa-palette:before { + content: "\\f53f"; } + +.fa-palfed:before { + content: "\\f3d8"; } + +.fa-pallet:before { + content: "\\f482"; } + +.fa-paper-plane:before { + content: "\\f1d8"; } + +.fa-paperclip:before { + content: "\\f0c6"; } + +.fa-parachute-box:before { + content: "\\f4cd"; } + +.fa-paragraph:before { + content: "\\f1dd"; } + +.fa-parking:before { + content: "\\f540"; } + +.fa-passport:before { + content: "\\f5ab"; } + +.fa-pastafarianism:before { + content: "\\f67b"; } + +.fa-paste:before { + content: "\\f0ea"; } + +.fa-patreon:before { + content: "\\f3d9"; } + +.fa-pause:before { + content: "\\f04c"; } + +.fa-pause-circle:before { + content: "\\f28b"; } + +.fa-paw:before { + content: "\\f1b0"; } + +.fa-paypal:before { + content: "\\f1ed"; } + +.fa-peace:before { + content: "\\f67c"; } + +.fa-pen:before { + content: "\\f304"; } + +.fa-pen-alt:before { + content: "\\f305"; } + +.fa-pen-fancy:before { + content: "\\f5ac"; } + +.fa-pen-nib:before { + content: "\\f5ad"; } + +.fa-pen-square:before { + content: "\\f14b"; } + +.fa-pencil-alt:before { + content: "\\f303"; } + +.fa-pencil-ruler:before { + content: "\\f5ae"; } + +.fa-penny-arcade:before { + content: "\\f704"; } + +.fa-people-arrows:before { + content: "\\e068"; } + +.fa-people-carry:before { + content: "\\f4ce"; } + +.fa-pepper-hot:before { + content: "\\f816"; } + +.fa-perbyte:before { + content: "\\e083"; } + +.fa-percent:before { + content: "\\f295"; } + +.fa-percentage:before { + content: "\\f541"; } + +.fa-periscope:before { + content: "\\f3da"; } + +.fa-person-booth:before { + content: "\\f756"; } + +.fa-phabricator:before { + content: "\\f3db"; } + +.fa-phoenix-framework:before { + content: "\\f3dc"; } + +.fa-phoenix-squadron:before { + content: "\\f511"; } + +.fa-phone:before { + content: "\\f095"; } + +.fa-phone-alt:before { + content: "\\f879"; } + +.fa-phone-slash:before { + content: "\\f3dd"; } + +.fa-phone-square:before { + content: "\\f098"; } + +.fa-phone-square-alt:before { + content: "\\f87b"; } + +.fa-phone-volume:before { + content: "\\f2a0"; } + +.fa-photo-video:before { + content: "\\f87c"; } + +.fa-php:before { + content: "\\f457"; } + +.fa-pied-piper:before { + content: "\\f2ae"; } + +.fa-pied-piper-alt:before { + content: "\\f1a8"; } + +.fa-pied-piper-hat:before { + content: "\\f4e5"; } + +.fa-pied-piper-pp:before { + content: "\\f1a7"; } + +.fa-pied-piper-square:before { + content: "\\e01e"; } + +.fa-piggy-bank:before { + content: "\\f4d3"; } + +.fa-pills:before { + content: "\\f484"; } + +.fa-pinterest:before { + content: "\\f0d2"; } + +.fa-pinterest-p:before { + content: "\\f231"; } + +.fa-pinterest-square:before { + content: "\\f0d3"; } + +.fa-pizza-slice:before { + content: "\\f818"; } + +.fa-place-of-worship:before { + content: "\\f67f"; } + +.fa-plane:before { + content: "\\f072"; } + +.fa-plane-arrival:before { + content: "\\f5af"; } + +.fa-plane-departure:before { + content: "\\f5b0"; } + +.fa-plane-slash:before { + content: "\\e069"; } + +.fa-play:before { + content: "\\f04b"; } + +.fa-play-circle:before { + content: "\\f144"; } + +.fa-playstation:before { + content: "\\f3df"; } + +.fa-plug:before { + content: "\\f1e6"; } + +.fa-plus:before { + content: "\\f067"; } + +.fa-plus-circle:before { + content: "\\f055"; } + +.fa-plus-square:before { + content: "\\f0fe"; } + +.fa-podcast:before { + content: "\\f2ce"; } + +.fa-poll:before { + content: "\\f681"; } + +.fa-poll-h:before { + content: "\\f682"; } + +.fa-poo:before { + content: "\\f2fe"; } + +.fa-poo-storm:before { + content: "\\f75a"; } + +.fa-poop:before { + content: "\\f619"; } + +.fa-portrait:before { + content: "\\f3e0"; } + +.fa-pound-sign:before { + content: "\\f154"; } + +.fa-power-off:before { + content: "\\f011"; } + +.fa-pray:before { + content: "\\f683"; } + +.fa-praying-hands:before { + content: "\\f684"; } + +.fa-prescription:before { + content: "\\f5b1"; } + +.fa-prescription-bottle:before { + content: "\\f485"; } + +.fa-prescription-bottle-alt:before { + content: "\\f486"; } + +.fa-print:before { + content: "\\f02f"; } + +.fa-procedures:before { + content: "\\f487"; } + +.fa-product-hunt:before { + content: "\\f288"; } + +.fa-project-diagram:before { + content: "\\f542"; } + +.fa-pump-medical:before { + content: "\\e06a"; } + +.fa-pump-soap:before { + content: "\\e06b"; } + +.fa-pushed:before { + content: "\\f3e1"; } + +.fa-puzzle-piece:before { + content: "\\f12e"; } + +.fa-python:before { + content: "\\f3e2"; } + +.fa-qq:before { + content: "\\f1d6"; } + +.fa-qrcode:before { + content: "\\f029"; } + +.fa-question:before { + content: "\\f128"; } + +.fa-question-circle:before { + content: "\\f059"; } + +.fa-quidditch:before { + content: "\\f458"; } + +.fa-quinscape:before { + content: "\\f459"; } + +.fa-quora:before { + content: "\\f2c4"; } + +.fa-quote-left:before { + content: "\\f10d"; } + +.fa-quote-right:before { + content: "\\f10e"; } + +.fa-quran:before { + content: "\\f687"; } + +.fa-r-project:before { + content: "\\f4f7"; } + +.fa-radiation:before { + content: "\\f7b9"; } + +.fa-radiation-alt:before { + content: "\\f7ba"; } + +.fa-rainbow:before { + content: "\\f75b"; } + +.fa-random:before { + content: "\\f074"; } + +.fa-raspberry-pi:before { + content: "\\f7bb"; } + +.fa-ravelry:before { + content: "\\f2d9"; } + +.fa-react:before { + content: "\\f41b"; } + +.fa-reacteurope:before { + content: "\\f75d"; } + +.fa-readme:before { + content: "\\f4d5"; } + +.fa-rebel:before { + content: "\\f1d0"; } + +.fa-receipt:before { + content: "\\f543"; } + +.fa-record-vinyl:before { + content: "\\f8d9"; } + +.fa-recycle:before { + content: "\\f1b8"; } + +.fa-red-river:before { + content: "\\f3e3"; } + +.fa-reddit:before { + content: "\\f1a1"; } + +.fa-reddit-alien:before { + content: "\\f281"; } + +.fa-reddit-square:before { + content: "\\f1a2"; } + +.fa-redhat:before { + content: "\\f7bc"; } + +.fa-redo:before { + content: "\\f01e"; } + +.fa-redo-alt:before { + content: "\\f2f9"; } + +.fa-registered:before { + content: "\\f25d"; } + +.fa-remove-format:before { + content: "\\f87d"; } + +.fa-renren:before { + content: "\\f18b"; } + +.fa-reply:before { + content: "\\f3e5"; } + +.fa-reply-all:before { + content: "\\f122"; } + +.fa-replyd:before { + content: "\\f3e6"; } + +.fa-republican:before { + content: "\\f75e"; } + +.fa-researchgate:before { + content: "\\f4f8"; } + +.fa-resolving:before { + content: "\\f3e7"; } + +.fa-restroom:before { + content: "\\f7bd"; } + +.fa-retweet:before { + content: "\\f079"; } + +.fa-rev:before { + content: "\\f5b2"; } + +.fa-ribbon:before { + content: "\\f4d6"; } + +.fa-ring:before { + content: "\\f70b"; } + +.fa-road:before { + content: "\\f018"; } + +.fa-robot:before { + content: "\\f544"; } + +.fa-rocket:before { + content: "\\f135"; } + +.fa-rocketchat:before { + content: "\\f3e8"; } + +.fa-rockrms:before { + content: "\\f3e9"; } + +.fa-route:before { + content: "\\f4d7"; } + +.fa-rss:before { + content: "\\f09e"; } + +.fa-rss-square:before { + content: "\\f143"; } + +.fa-ruble-sign:before { + content: "\\f158"; } + +.fa-ruler:before { + content: "\\f545"; } + +.fa-ruler-combined:before { + content: "\\f546"; } + +.fa-ruler-horizontal:before { + content: "\\f547"; } + +.fa-ruler-vertical:before { + content: "\\f548"; } + +.fa-running:before { + content: "\\f70c"; } + +.fa-rupee-sign:before { + content: "\\f156"; } + +.fa-rust:before { + content: "\\e07a"; } + +.fa-sad-cry:before { + content: "\\f5b3"; } + +.fa-sad-tear:before { + content: "\\f5b4"; } + +.fa-safari:before { + content: "\\f267"; } + +.fa-salesforce:before { + content: "\\f83b"; } + +.fa-sass:before { + content: "\\f41e"; } + +.fa-satellite:before { + content: "\\f7bf"; } + +.fa-satellite-dish:before { + content: "\\f7c0"; } + +.fa-save:before { + content: "\\f0c7"; } + +.fa-schlix:before { + content: "\\f3ea"; } + +.fa-school:before { + content: "\\f549"; } + +.fa-screwdriver:before { + content: "\\f54a"; } + +.fa-scribd:before { + content: "\\f28a"; } + +.fa-scroll:before { + content: "\\f70e"; } + +.fa-sd-card:before { + content: "\\f7c2"; } + +.fa-search:before { + content: "\\f002"; } + +.fa-search-dollar:before { + content: "\\f688"; } + +.fa-search-location:before { + content: "\\f689"; } + +.fa-search-minus:before { + content: "\\f010"; } + +.fa-search-plus:before { + content: "\\f00e"; } + +.fa-searchengin:before { + content: "\\f3eb"; } + +.fa-seedling:before { + content: "\\f4d8"; } + +.fa-sellcast:before { + content: "\\f2da"; } + +.fa-sellsy:before { + content: "\\f213"; } + +.fa-server:before { + content: "\\f233"; } + +.fa-servicestack:before { + content: "\\f3ec"; } + +.fa-shapes:before { + content: "\\f61f"; } + +.fa-share:before { + content: "\\f064"; } + +.fa-share-alt:before { + content: "\\f1e0"; } + +.fa-share-alt-square:before { + content: "\\f1e1"; } + +.fa-share-square:before { + content: "\\f14d"; } + +.fa-shekel-sign:before { + content: "\\f20b"; } + +.fa-shield-alt:before { + content: "\\f3ed"; } + +.fa-shield-virus:before { + content: "\\e06c"; } + +.fa-ship:before { + content: "\\f21a"; } + +.fa-shipping-fast:before { + content: "\\f48b"; } + +.fa-shirtsinbulk:before { + content: "\\f214"; } + +.fa-shoe-prints:before { + content: "\\f54b"; } + +.fa-shopify:before { + content: "\\e057"; } + +.fa-shopping-bag:before { + content: "\\f290"; } + +.fa-shopping-basket:before { + content: "\\f291"; } + +.fa-shopping-cart:before { + content: "\\f07a"; } + +.fa-shopware:before { + content: "\\f5b5"; } + +.fa-shower:before { + content: "\\f2cc"; } + +.fa-shuttle-van:before { + content: "\\f5b6"; } + +.fa-sign:before { + content: "\\f4d9"; } + +.fa-sign-in-alt:before { + content: "\\f2f6"; } + +.fa-sign-language:before { + content: "\\f2a7"; } + +.fa-sign-out-alt:before { + content: "\\f2f5"; } + +.fa-signal:before { + content: "\\f012"; } + +.fa-signature:before { + content: "\\f5b7"; } + +.fa-sim-card:before { + content: "\\f7c4"; } + +.fa-simplybuilt:before { + content: "\\f215"; } + +.fa-sink:before { + content: "\\e06d"; } + +.fa-sistrix:before { + content: "\\f3ee"; } + +.fa-sitemap:before { + content: "\\f0e8"; } + +.fa-sith:before { + content: "\\f512"; } + +.fa-skating:before { + content: "\\f7c5"; } + +.fa-sketch:before { + content: "\\f7c6"; } + +.fa-skiing:before { + content: "\\f7c9"; } + +.fa-skiing-nordic:before { + content: "\\f7ca"; } + +.fa-skull:before { + content: "\\f54c"; } + +.fa-skull-crossbones:before { + content: "\\f714"; } + +.fa-skyatlas:before { + content: "\\f216"; } + +.fa-skype:before { + content: "\\f17e"; } + +.fa-slack:before { + content: "\\f198"; } + +.fa-slack-hash:before { + content: "\\f3ef"; } + +.fa-slash:before { + content: "\\f715"; } + +.fa-sleigh:before { + content: "\\f7cc"; } + +.fa-sliders-h:before { + content: "\\f1de"; } + +.fa-slideshare:before { + content: "\\f1e7"; } + +.fa-smile:before { + content: "\\f118"; } + +.fa-smile-beam:before { + content: "\\f5b8"; } + +.fa-smile-wink:before { + content: "\\f4da"; } + +.fa-smog:before { + content: "\\f75f"; } + +.fa-smoking:before { + content: "\\f48d"; } + +.fa-smoking-ban:before { + content: "\\f54d"; } + +.fa-sms:before { + content: "\\f7cd"; } + +.fa-snapchat:before { + content: "\\f2ab"; } + +.fa-snapchat-ghost:before { + content: "\\f2ac"; } + +.fa-snapchat-square:before { + content: "\\f2ad"; } + +.fa-snowboarding:before { + content: "\\f7ce"; } + +.fa-snowflake:before { + content: "\\f2dc"; } + +.fa-snowman:before { + content: "\\f7d0"; } + +.fa-snowplow:before { + content: "\\f7d2"; } + +.fa-soap:before { + content: "\\e06e"; } + +.fa-socks:before { + content: "\\f696"; } + +.fa-solar-panel:before { + content: "\\f5ba"; } + +.fa-sort:before { + content: "\\f0dc"; } + +.fa-sort-alpha-down:before { + content: "\\f15d"; } + +.fa-sort-alpha-down-alt:before { + content: "\\f881"; } + +.fa-sort-alpha-up:before { + content: "\\f15e"; } + +.fa-sort-alpha-up-alt:before { + content: "\\f882"; } + +.fa-sort-amount-down:before { + content: "\\f160"; } + +.fa-sort-amount-down-alt:before { + content: "\\f884"; } + +.fa-sort-amount-up:before { + content: "\\f161"; } + +.fa-sort-amount-up-alt:before { + content: "\\f885"; } + +.fa-sort-down:before { + content: "\\f0dd"; } + +.fa-sort-numeric-down:before { + content: "\\f162"; } + +.fa-sort-numeric-down-alt:before { + content: "\\f886"; } + +.fa-sort-numeric-up:before { + content: "\\f163"; } + +.fa-sort-numeric-up-alt:before { + content: "\\f887"; } + +.fa-sort-up:before { + content: "\\f0de"; } + +.fa-soundcloud:before { + content: "\\f1be"; } + +.fa-sourcetree:before { + content: "\\f7d3"; } + +.fa-spa:before { + content: "\\f5bb"; } + +.fa-space-shuttle:before { + content: "\\f197"; } + +.fa-speakap:before { + content: "\\f3f3"; } + +.fa-speaker-deck:before { + content: "\\f83c"; } + +.fa-spell-check:before { + content: "\\f891"; } + +.fa-spider:before { + content: "\\f717"; } + +.fa-spinner:before { + content: "\\f110"; } + +.fa-splotch:before { + content: "\\f5bc"; } + +.fa-spotify:before { + content: "\\f1bc"; } + +.fa-spray-can:before { + content: "\\f5bd"; } + +.fa-square:before { + content: "\\f0c8"; } + +.fa-square-full:before { + content: "\\f45c"; } + +.fa-square-root-alt:before { + content: "\\f698"; } + +.fa-squarespace:before { + content: "\\f5be"; } + +.fa-stack-exchange:before { + content: "\\f18d"; } + +.fa-stack-overflow:before { + content: "\\f16c"; } + +.fa-stackpath:before { + content: "\\f842"; } + +.fa-stamp:before { + content: "\\f5bf"; } + +.fa-star:before { + content: "\\f005"; } + +.fa-star-and-crescent:before { + content: "\\f699"; } + +.fa-star-half:before { + content: "\\f089"; } + +.fa-star-half-alt:before { + content: "\\f5c0"; } + +.fa-star-of-david:before { + content: "\\f69a"; } + +.fa-star-of-life:before { + content: "\\f621"; } + +.fa-staylinked:before { + content: "\\f3f5"; } + +.fa-steam:before { + content: "\\f1b6"; } + +.fa-steam-square:before { + content: "\\f1b7"; } + +.fa-steam-symbol:before { + content: "\\f3f6"; } + +.fa-step-backward:before { + content: "\\f048"; } + +.fa-step-forward:before { + content: "\\f051"; } + +.fa-stethoscope:before { + content: "\\f0f1"; } + +.fa-sticker-mule:before { + content: "\\f3f7"; } + +.fa-sticky-note:before { + content: "\\f249"; } + +.fa-stop:before { + content: "\\f04d"; } + +.fa-stop-circle:before { + content: "\\f28d"; } + +.fa-stopwatch:before { + content: "\\f2f2"; } + +.fa-stopwatch-20:before { + content: "\\e06f"; } + +.fa-store:before { + content: "\\f54e"; } + +.fa-store-alt:before { + content: "\\f54f"; } + +.fa-store-alt-slash:before { + content: "\\e070"; } + +.fa-store-slash:before { + content: "\\e071"; } + +.fa-strava:before { + content: "\\f428"; } + +.fa-stream:before { + content: "\\f550"; } + +.fa-street-view:before { + content: "\\f21d"; } + +.fa-strikethrough:before { + content: "\\f0cc"; } + +.fa-stripe:before { + content: "\\f429"; } + +.fa-stripe-s:before { + content: "\\f42a"; } + +.fa-stroopwafel:before { + content: "\\f551"; } + +.fa-studiovinari:before { + content: "\\f3f8"; } + +.fa-stumbleupon:before { + content: "\\f1a4"; } + +.fa-stumbleupon-circle:before { + content: "\\f1a3"; } + +.fa-subscript:before { + content: "\\f12c"; } + +.fa-subway:before { + content: "\\f239"; } + +.fa-suitcase:before { + content: "\\f0f2"; } + +.fa-suitcase-rolling:before { + content: "\\f5c1"; } + +.fa-sun:before { + content: "\\f185"; } + +.fa-superpowers:before { + content: "\\f2dd"; } + +.fa-superscript:before { + content: "\\f12b"; } + +.fa-supple:before { + content: "\\f3f9"; } + +.fa-surprise:before { + content: "\\f5c2"; } + +.fa-suse:before { + content: "\\f7d6"; } + +.fa-swatchbook:before { + content: "\\f5c3"; } + +.fa-swift:before { + content: "\\f8e1"; } + +.fa-swimmer:before { + content: "\\f5c4"; } + +.fa-swimming-pool:before { + content: "\\f5c5"; } + +.fa-symfony:before { + content: "\\f83d"; } + +.fa-synagogue:before { + content: "\\f69b"; } + +.fa-sync:before { + content: "\\f021"; } + +.fa-sync-alt:before { + content: "\\f2f1"; } + +.fa-syringe:before { + content: "\\f48e"; } + +.fa-table:before { + content: "\\f0ce"; } + +.fa-table-tennis:before { + content: "\\f45d"; } + +.fa-tablet:before { + content: "\\f10a"; } + +.fa-tablet-alt:before { + content: "\\f3fa"; } + +.fa-tablets:before { + content: "\\f490"; } + +.fa-tachometer-alt:before { + content: "\\f3fd"; } + +.fa-tag:before { + content: "\\f02b"; } + +.fa-tags:before { + content: "\\f02c"; } + +.fa-tape:before { + content: "\\f4db"; } + +.fa-tasks:before { + content: "\\f0ae"; } + +.fa-taxi:before { + content: "\\f1ba"; } + +.fa-teamspeak:before { + content: "\\f4f9"; } + +.fa-teeth:before { + content: "\\f62e"; } + +.fa-teeth-open:before { + content: "\\f62f"; } + +.fa-telegram:before { + content: "\\f2c6"; } + +.fa-telegram-plane:before { + content: "\\f3fe"; } + +.fa-temperature-high:before { + content: "\\f769"; } + +.fa-temperature-low:before { + content: "\\f76b"; } + +.fa-tencent-weibo:before { + content: "\\f1d5"; } + +.fa-tenge:before { + content: "\\f7d7"; } + +.fa-terminal:before { + content: "\\f120"; } + +.fa-text-height:before { + content: "\\f034"; } + +.fa-text-width:before { + content: "\\f035"; } + +.fa-th:before { + content: "\\f00a"; } + +.fa-th-large:before { + content: "\\f009"; } + +.fa-th-list:before { + content: "\\f00b"; } + +.fa-the-red-yeti:before { + content: "\\f69d"; } + +.fa-theater-masks:before { + content: "\\f630"; } + +.fa-themeco:before { + content: "\\f5c6"; } + +.fa-themeisle:before { + content: "\\f2b2"; } + +.fa-thermometer:before { + content: "\\f491"; } + +.fa-thermometer-empty:before { + content: "\\f2cb"; } + +.fa-thermometer-full:before { + content: "\\f2c7"; } + +.fa-thermometer-half:before { + content: "\\f2c9"; } + +.fa-thermometer-quarter:before { + content: "\\f2ca"; } + +.fa-thermometer-three-quarters:before { + content: "\\f2c8"; } + +.fa-think-peaks:before { + content: "\\f731"; } + +.fa-thumbs-down:before { + content: "\\f165"; } + +.fa-thumbs-up:before { + content: "\\f164"; } + +.fa-thumbtack:before { + content: "\\f08d"; } + +.fa-ticket-alt:before { + content: "\\f3ff"; } + +.fa-tiktok:before { + content: "\\e07b"; } + +.fa-times:before { + content: "\\f00d"; } + +.fa-times-circle:before { + content: "\\f057"; } + +.fa-tint:before { + content: "\\f043"; } + +.fa-tint-slash:before { + content: "\\f5c7"; } + +.fa-tired:before { + content: "\\f5c8"; } + +.fa-toggle-off:before { + content: "\\f204"; } + +.fa-toggle-on:before { + content: "\\f205"; } + +.fa-toilet:before { + content: "\\f7d8"; } + +.fa-toilet-paper:before { + content: "\\f71e"; } + +.fa-toilet-paper-slash:before { + content: "\\e072"; } + +.fa-toolbox:before { + content: "\\f552"; } + +.fa-tools:before { + content: "\\f7d9"; } + +.fa-tooth:before { + content: "\\f5c9"; } + +.fa-torah:before { + content: "\\f6a0"; } + +.fa-torii-gate:before { + content: "\\f6a1"; } + +.fa-tractor:before { + content: "\\f722"; } + +.fa-trade-federation:before { + content: "\\f513"; } + +.fa-trademark:before { + content: "\\f25c"; } + +.fa-traffic-light:before { + content: "\\f637"; } + +.fa-trailer:before { + content: "\\e041"; } + +.fa-train:before { + content: "\\f238"; } + +.fa-tram:before { + content: "\\f7da"; } + +.fa-transgender:before { + content: "\\f224"; } + +.fa-transgender-alt:before { + content: "\\f225"; } + +.fa-trash:before { + content: "\\f1f8"; } + +.fa-trash-alt:before { + content: "\\f2ed"; } + +.fa-trash-restore:before { + content: "\\f829"; } + +.fa-trash-restore-alt:before { + content: "\\f82a"; } + +.fa-tree:before { + content: "\\f1bb"; } + +.fa-trello:before { + content: "\\f181"; } + +.fa-trophy:before { + content: "\\f091"; } + +.fa-truck:before { + content: "\\f0d1"; } + +.fa-truck-loading:before { + content: "\\f4de"; } + +.fa-truck-monster:before { + content: "\\f63b"; } + +.fa-truck-moving:before { + content: "\\f4df"; } + +.fa-truck-pickup:before { + content: "\\f63c"; } + +.fa-tshirt:before { + content: "\\f553"; } + +.fa-tty:before { + content: "\\f1e4"; } + +.fa-tumblr:before { + content: "\\f173"; } + +.fa-tumblr-square:before { + content: "\\f174"; } + +.fa-tv:before { + content: "\\f26c"; } + +.fa-twitch:before { + content: "\\f1e8"; } + +.fa-twitter:before { + content: "\\f099"; } + +.fa-twitter-square:before { + content: "\\f081"; } + +.fa-typo3:before { + content: "\\f42b"; } + +.fa-uber:before { + content: "\\f402"; } + +.fa-ubuntu:before { + content: "\\f7df"; } + +.fa-uikit:before { + content: "\\f403"; } + +.fa-umbraco:before { + content: "\\f8e8"; } + +.fa-umbrella:before { + content: "\\f0e9"; } + +.fa-umbrella-beach:before { + content: "\\f5ca"; } + +.fa-uncharted:before { + content: "\\e084"; } + +.fa-underline:before { + content: "\\f0cd"; } + +.fa-undo:before { + content: "\\f0e2"; } + +.fa-undo-alt:before { + content: "\\f2ea"; } + +.fa-uniregistry:before { + content: "\\f404"; } + +.fa-unity:before { + content: "\\e049"; } + +.fa-universal-access:before { + content: "\\f29a"; } + +.fa-university:before { + content: "\\f19c"; } + +.fa-unlink:before { + content: "\\f127"; } + +.fa-unlock:before { + content: "\\f09c"; } + +.fa-unlock-alt:before { + content: "\\f13e"; } + +.fa-unsplash:before { + content: "\\e07c"; } + +.fa-untappd:before { + content: "\\f405"; } + +.fa-upload:before { + content: "\\f093"; } + +.fa-ups:before { + content: "\\f7e0"; } + +.fa-usb:before { + content: "\\f287"; } + +.fa-user:before { + content: "\\f007"; } + +.fa-user-alt:before { + content: "\\f406"; } + +.fa-user-alt-slash:before { + content: "\\f4fa"; } + +.fa-user-astronaut:before { + content: "\\f4fb"; } + +.fa-user-check:before { + content: "\\f4fc"; } + +.fa-user-circle:before { + content: "\\f2bd"; } + +.fa-user-clock:before { + content: "\\f4fd"; } + +.fa-user-cog:before { + content: "\\f4fe"; } + +.fa-user-edit:before { + content: "\\f4ff"; } + +.fa-user-friends:before { + content: "\\f500"; } + +.fa-user-graduate:before { + content: "\\f501"; } + +.fa-user-injured:before { + content: "\\f728"; } + +.fa-user-lock:before { + content: "\\f502"; } + +.fa-user-md:before { + content: "\\f0f0"; } + +.fa-user-minus:before { + content: "\\f503"; } + +.fa-user-ninja:before { + content: "\\f504"; } + +.fa-user-nurse:before { + content: "\\f82f"; } + +.fa-user-plus:before { + content: "\\f234"; } + +.fa-user-secret:before { + content: "\\f21b"; } + +.fa-user-shield:before { + content: "\\f505"; } + +.fa-user-slash:before { + content: "\\f506"; } + +.fa-user-tag:before { + content: "\\f507"; } + +.fa-user-tie:before { + content: "\\f508"; } + +.fa-user-times:before { + content: "\\f235"; } + +.fa-users:before { + content: "\\f0c0"; } + +.fa-users-cog:before { + content: "\\f509"; } + +.fa-users-slash:before { + content: "\\e073"; } + +.fa-usps:before { + content: "\\f7e1"; } + +.fa-ussunnah:before { + content: "\\f407"; } + +.fa-utensil-spoon:before { + content: "\\f2e5"; } + +.fa-utensils:before { + content: "\\f2e7"; } + +.fa-vaadin:before { + content: "\\f408"; } + +.fa-vector-square:before { + content: "\\f5cb"; } + +.fa-venus:before { + content: "\\f221"; } + +.fa-venus-double:before { + content: "\\f226"; } + +.fa-venus-mars:before { + content: "\\f228"; } + +.fa-vest:before { + content: "\\e085"; } + +.fa-vest-patches:before { + content: "\\e086"; } + +.fa-viacoin:before { + content: "\\f237"; } + +.fa-viadeo:before { + content: "\\f2a9"; } + +.fa-viadeo-square:before { + content: "\\f2aa"; } + +.fa-vial:before { + content: "\\f492"; } + +.fa-vials:before { + content: "\\f493"; } + +.fa-viber:before { + content: "\\f409"; } + +.fa-video:before { + content: "\\f03d"; } + +.fa-video-slash:before { + content: "\\f4e2"; } + +.fa-vihara:before { + content: "\\f6a7"; } + +.fa-vimeo:before { + content: "\\f40a"; } + +.fa-vimeo-square:before { + content: "\\f194"; } + +.fa-vimeo-v:before { + content: "\\f27d"; } + +.fa-vine:before { + content: "\\f1ca"; } + +.fa-virus:before { + content: "\\e074"; } + +.fa-virus-slash:before { + content: "\\e075"; } + +.fa-viruses:before { + content: "\\e076"; } + +.fa-vk:before { + content: "\\f189"; } + +.fa-vnv:before { + content: "\\f40b"; } + +.fa-voicemail:before { + content: "\\f897"; } + +.fa-volleyball-ball:before { + content: "\\f45f"; } + +.fa-volume-down:before { + content: "\\f027"; } + +.fa-volume-mute:before { + content: "\\f6a9"; } + +.fa-volume-off:before { + content: "\\f026"; } + +.fa-volume-up:before { + content: "\\f028"; } + +.fa-vote-yea:before { + content: "\\f772"; } + +.fa-vr-cardboard:before { + content: "\\f729"; } + +.fa-vuejs:before { + content: "\\f41f"; } + +.fa-walking:before { + content: "\\f554"; } + +.fa-wallet:before { + content: "\\f555"; } + +.fa-warehouse:before { + content: "\\f494"; } + +.fa-watchman-monitoring:before { + content: "\\e087"; } + +.fa-water:before { + content: "\\f773"; } + +.fa-wave-square:before { + content: "\\f83e"; } + +.fa-waze:before { + content: "\\f83f"; } + +.fa-weebly:before { + content: "\\f5cc"; } + +.fa-weibo:before { + content: "\\f18a"; } + +.fa-weight:before { + content: "\\f496"; } + +.fa-weight-hanging:before { + content: "\\f5cd"; } + +.fa-weixin:before { + content: "\\f1d7"; } + +.fa-whatsapp:before { + content: "\\f232"; } + +.fa-whatsapp-square:before { + content: "\\f40c"; } + +.fa-wheelchair:before { + content: "\\f193"; } + +.fa-whmcs:before { + content: "\\f40d"; } + +.fa-wifi:before { + content: "\\f1eb"; } + +.fa-wikipedia-w:before { + content: "\\f266"; } + +.fa-wind:before { + content: "\\f72e"; } + +.fa-window-close:before { + content: "\\f410"; } + +.fa-window-maximize:before { + content: "\\f2d0"; } + +.fa-window-minimize:before { + content: "\\f2d1"; } + +.fa-window-restore:before { + content: "\\f2d2"; } + +.fa-windows:before { + content: "\\f17a"; } + +.fa-wine-bottle:before { + content: "\\f72f"; } + +.fa-wine-glass:before { + content: "\\f4e3"; } + +.fa-wine-glass-alt:before { + content: "\\f5ce"; } + +.fa-wix:before { + content: "\\f5cf"; } + +.fa-wizards-of-the-coast:before { + content: "\\f730"; } + +.fa-wodu:before { + content: "\\e088"; } + +.fa-wolf-pack-battalion:before { + content: "\\f514"; } + +.fa-won-sign:before { + content: "\\f159"; } + +.fa-wordpress:before { + content: "\\f19a"; } + +.fa-wordpress-simple:before { + content: "\\f411"; } + +.fa-wpbeginner:before { + content: "\\f297"; } + +.fa-wpexplorer:before { + content: "\\f2de"; } + +.fa-wpforms:before { + content: "\\f298"; } + +.fa-wpressr:before { + content: "\\f3e4"; } + +.fa-wrench:before { + content: "\\f0ad"; } + +.fa-x-ray:before { + content: "\\f497"; } + +.fa-xbox:before { + content: "\\f412"; } + +.fa-xing:before { + content: "\\f168"; } + +.fa-xing-square:before { + content: "\\f169"; } + +.fa-y-combinator:before { + content: "\\f23b"; } + +.fa-yahoo:before { + content: "\\f19e"; } + +.fa-yammer:before { + content: "\\f840"; } + +.fa-yandex:before { + content: "\\f413"; } + +.fa-yandex-international:before { + content: "\\f414"; } + +.fa-yarn:before { + content: "\\f7e3"; } + +.fa-yelp:before { + content: "\\f1e9"; } + +.fa-yen-sign:before { + content: "\\f157"; } + +.fa-yin-yang:before { + content: "\\f6ad"; } + +.fa-yoast:before { + content: "\\f2b1"; } + +.fa-youtube:before { + content: "\\f167"; } + +.fa-youtube-square:before { + content: "\\f431"; } + +.fa-zhihu:before { + content: "\\f63f"; } + +.sr-only { + border: 0; + clip: rect(0, 0, 0, 0); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; } + +.sr-only-focusable:active, .sr-only-focusable:focus { + clip: auto; + height: auto; + margin: 0; + overflow: visible; + position: static; + width: auto; } +@font-face { + font-family: 'Font Awesome 5 Brands'; + font-style: normal; + font-weight: 400; + font-display: block; + src: url(${___CSS_LOADER_URL_REPLACEMENT_0___}); + src: url(${___CSS_LOADER_URL_REPLACEMENT_1___}) format("embedded-opentype"), url(${___CSS_LOADER_URL_REPLACEMENT_2___}) format("woff2"), url(${___CSS_LOADER_URL_REPLACEMENT_3___}) format("woff"), url(${___CSS_LOADER_URL_REPLACEMENT_4___}) format("truetype"), url(${___CSS_LOADER_URL_REPLACEMENT_5___}) format("svg"); } + +.fab { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } +@font-face { + font-family: 'Font Awesome 5 Free'; + font-style: normal; + font-weight: 400; + font-display: block; + src: url(${___CSS_LOADER_URL_REPLACEMENT_6___}); + src: url(${___CSS_LOADER_URL_REPLACEMENT_7___}) format("embedded-opentype"), url(${___CSS_LOADER_URL_REPLACEMENT_8___}) format("woff2"), url(${___CSS_LOADER_URL_REPLACEMENT_9___}) format("woff"), url(${___CSS_LOADER_URL_REPLACEMENT_10___}) format("truetype"), url(${___CSS_LOADER_URL_REPLACEMENT_11___}) format("svg"); } + +.far { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } +@font-face { + font-family: 'Font Awesome 5 Free'; + font-style: normal; + font-weight: 900; + font-display: block; + src: url(${___CSS_LOADER_URL_REPLACEMENT_12___}); + src: url(${___CSS_LOADER_URL_REPLACEMENT_13___}) format("embedded-opentype"), url(${___CSS_LOADER_URL_REPLACEMENT_14___}) format("woff2"), url(${___CSS_LOADER_URL_REPLACEMENT_15___}) format("woff"), url(${___CSS_LOADER_URL_REPLACEMENT_16___}) format("truetype"), url(${___CSS_LOADER_URL_REPLACEMENT_17___}) format("svg"); } + +.fa, +.fas { + font-family: 'Font Awesome 5 Free'; + font-weight: 900; } +`, "",{"version":3,"sources":["webpack://./node_modules/@fortawesome/fontawesome-free/css/all.css"],"names":[],"mappings":"AAAA;;;EAGE;AACF;;;;;;EAME,kCAAkC;EAClC,mCAAmC;EACnC,qBAAqB;EACrB,kBAAkB;EAClB,oBAAoB;EACpB,oBAAoB;EACpB,cAAc,EAAE;;AAElB;EACE,oBAAoB;EACpB,mBAAmB;EACnB,wBAAwB,EAAE;;AAE5B;EACE,gBAAgB,EAAE;;AAEpB;EACE,iBAAiB,EAAE;;AAErB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,cAAc,EAAE;;AAElB;EACE,eAAe,EAAE;;AAEnB;EACE,kBAAkB;EAClB,aAAa,EAAE;;AAEjB;EACE,qBAAqB;EACrB,kBAAkB;EAClB,eAAe,EAAE;EACjB;IACE,kBAAkB,EAAE;;AAExB;EACE,UAAU;EACV,kBAAkB;EAClB,kBAAkB;EAClB,UAAU;EACV,oBAAoB,EAAE;;AAExB;EACE,yBAAyB;EACzB,mBAAmB;EACnB,yBAAyB,EAAE;;AAE7B;EACE,WAAW,EAAE;;AAEf;EACE,YAAY,EAAE;;AAEhB;;;;;EAKE,kBAAkB,EAAE;;AAEtB;;;;;EAKE,iBAAiB,EAAE;;AAErB;EACE,6CAA6C;UACrC,qCAAqC,EAAE;;AAEjD;EACE,+CAA+C;UACvC,uCAAuC,EAAE;;AAEnD;EACE;IACE,+BAA+B;YACvB,uBAAuB,EAAE;EACnC;IACE,iCAAiC;YACzB,yBAAyB,EAAE,EAAE;;AAEzC;EACE;IACE,+BAA+B;YACvB,uBAAuB,EAAE;EACnC;IACE,iCAAiC;YACzB,yBAAyB,EAAE,EAAE;;AAEzC;EACE,sEAAsE;EACtE,gCAAgC;UACxB,wBAAwB,EAAE;;AAEpC;EACE,sEAAsE;EACtE,iCAAiC;UACzB,yBAAyB,EAAE;;AAErC;EACE,sEAAsE;EACtE,iCAAiC;UACzB,yBAAyB,EAAE;;AAErC;EACE,gFAAgF;EAChF,+BAA+B;UACvB,uBAAuB,EAAE;;AAEnC;EACE,gFAAgF;EAChF,+BAA+B;UACvB,uBAAuB,EAAE;;AAEnC;EACE,gFAAgF;EAChF,gCAAgC;UACxB,wBAAwB,EAAE;;AAEpC;;;;;;EAME,oBAAoB;UACZ,YAAY,EAAE;;AAExB;EACE,qBAAqB;EACrB,WAAW;EACX,gBAAgB;EAChB,kBAAkB;EAClB,sBAAsB;EACtB,YAAY,EAAE;;AAEhB;;EAEE,OAAO;EACP,kBAAkB;EAClB,kBAAkB;EAClB,WAAW,EAAE;;AAEf;EACE,oBAAoB,EAAE;;AAExB;EACE,cAAc,EAAE;;AAElB;EACE,WAAW,EAAE;;AAEf;gEACgE;AAChE;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,gBAAgB,EAAE;;AAEpB;EACE,SAAS;EACT,sBAAsB;EACtB,WAAW;EACX,YAAY;EACZ,gBAAgB;EAChB,UAAU;EACV,kBAAkB;EAClB,UAAU,EAAE;;AAEd;EACE,UAAU;EACV,YAAY;EACZ,SAAS;EACT,iBAAiB;EACjB,gBAAgB;EAChB,WAAW,EAAE;AACf;EACE,oCAAoC;EACpC,kBAAkB;EAClB,gBAAgB;EAChB,mBAAmB;EACnB,4CAAyC;EACzC,4SAAmT,EAAE;;AAEvT;EACE,oCAAoC;EACpC,gBAAgB,EAAE;AACpB;EACE,kCAAkC;EAClC,kBAAkB;EAClB,gBAAgB;EAChB,mBAAmB;EACnB,4CAA0C;EAC1C,8SAAwT,EAAE;;AAE5T;EACE,kCAAkC;EAClC,gBAAgB,EAAE;AACpB;EACE,kCAAkC;EAClC,kBAAkB;EAClB,gBAAgB;EAChB,mBAAmB;EACnB,6CAAwC;EACxC,iTAA8S,EAAE;;AAElT;;EAEE,kCAAkC;EAClC,gBAAgB,EAAE","sourcesContent":["/*!\n * Font Awesome Free 5.15.4 by @fontawesome - https://fontawesome.com\n * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)\n */\n.fa,\n.fas,\n.far,\n.fal,\n.fad,\n.fab {\n -moz-osx-font-smoothing: grayscale;\n -webkit-font-smoothing: antialiased;\n display: inline-block;\n font-style: normal;\n font-variant: normal;\n text-rendering: auto;\n line-height: 1; }\n\n.fa-lg {\n font-size: 1.33333em;\n line-height: 0.75em;\n vertical-align: -.0667em; }\n\n.fa-xs {\n font-size: .75em; }\n\n.fa-sm {\n font-size: .875em; }\n\n.fa-1x {\n font-size: 1em; }\n\n.fa-2x {\n font-size: 2em; }\n\n.fa-3x {\n font-size: 3em; }\n\n.fa-4x {\n font-size: 4em; }\n\n.fa-5x {\n font-size: 5em; }\n\n.fa-6x {\n font-size: 6em; }\n\n.fa-7x {\n font-size: 7em; }\n\n.fa-8x {\n font-size: 8em; }\n\n.fa-9x {\n font-size: 9em; }\n\n.fa-10x {\n font-size: 10em; }\n\n.fa-fw {\n text-align: center;\n width: 1.25em; }\n\n.fa-ul {\n list-style-type: none;\n margin-left: 2.5em;\n padding-left: 0; }\n .fa-ul > li {\n position: relative; }\n\n.fa-li {\n left: -2em;\n position: absolute;\n text-align: center;\n width: 2em;\n line-height: inherit; }\n\n.fa-border {\n border: solid 0.08em #eee;\n border-radius: .1em;\n padding: .2em .25em .15em; }\n\n.fa-pull-left {\n float: left; }\n\n.fa-pull-right {\n float: right; }\n\n.fa.fa-pull-left,\n.fas.fa-pull-left,\n.far.fa-pull-left,\n.fal.fa-pull-left,\n.fab.fa-pull-left {\n margin-right: .3em; }\n\n.fa.fa-pull-right,\n.fas.fa-pull-right,\n.far.fa-pull-right,\n.fal.fa-pull-right,\n.fab.fa-pull-right {\n margin-left: .3em; }\n\n.fa-spin {\n -webkit-animation: fa-spin 2s infinite linear;\n animation: fa-spin 2s infinite linear; }\n\n.fa-pulse {\n -webkit-animation: fa-spin 1s infinite steps(8);\n animation: fa-spin 1s infinite steps(8); }\n\n@-webkit-keyframes fa-spin {\n 0% {\n -webkit-transform: rotate(0deg);\n transform: rotate(0deg); }\n 100% {\n -webkit-transform: rotate(360deg);\n transform: rotate(360deg); } }\n\n@keyframes fa-spin {\n 0% {\n -webkit-transform: rotate(0deg);\n transform: rotate(0deg); }\n 100% {\n -webkit-transform: rotate(360deg);\n transform: rotate(360deg); } }\n\n.fa-rotate-90 {\n -ms-filter: \"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)\";\n -webkit-transform: rotate(90deg);\n transform: rotate(90deg); }\n\n.fa-rotate-180 {\n -ms-filter: \"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)\";\n -webkit-transform: rotate(180deg);\n transform: rotate(180deg); }\n\n.fa-rotate-270 {\n -ms-filter: \"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)\";\n -webkit-transform: rotate(270deg);\n transform: rotate(270deg); }\n\n.fa-flip-horizontal {\n -ms-filter: \"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)\";\n -webkit-transform: scale(-1, 1);\n transform: scale(-1, 1); }\n\n.fa-flip-vertical {\n -ms-filter: \"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)\";\n -webkit-transform: scale(1, -1);\n transform: scale(1, -1); }\n\n.fa-flip-both, .fa-flip-horizontal.fa-flip-vertical {\n -ms-filter: \"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)\";\n -webkit-transform: scale(-1, -1);\n transform: scale(-1, -1); }\n\n:root .fa-rotate-90,\n:root .fa-rotate-180,\n:root .fa-rotate-270,\n:root .fa-flip-horizontal,\n:root .fa-flip-vertical,\n:root .fa-flip-both {\n -webkit-filter: none;\n filter: none; }\n\n.fa-stack {\n display: inline-block;\n height: 2em;\n line-height: 2em;\n position: relative;\n vertical-align: middle;\n width: 2.5em; }\n\n.fa-stack-1x,\n.fa-stack-2x {\n left: 0;\n position: absolute;\n text-align: center;\n width: 100%; }\n\n.fa-stack-1x {\n line-height: inherit; }\n\n.fa-stack-2x {\n font-size: 2em; }\n\n.fa-inverse {\n color: #fff; }\n\n/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen\nreaders do not read off random characters that represent icons */\n.fa-500px:before {\n content: \"\\f26e\"; }\n\n.fa-accessible-icon:before {\n content: \"\\f368\"; }\n\n.fa-accusoft:before {\n content: \"\\f369\"; }\n\n.fa-acquisitions-incorporated:before {\n content: \"\\f6af\"; }\n\n.fa-ad:before {\n content: \"\\f641\"; }\n\n.fa-address-book:before {\n content: \"\\f2b9\"; }\n\n.fa-address-card:before {\n content: \"\\f2bb\"; }\n\n.fa-adjust:before {\n content: \"\\f042\"; }\n\n.fa-adn:before {\n content: \"\\f170\"; }\n\n.fa-adversal:before {\n content: \"\\f36a\"; }\n\n.fa-affiliatetheme:before {\n content: \"\\f36b\"; }\n\n.fa-air-freshener:before {\n content: \"\\f5d0\"; }\n\n.fa-airbnb:before {\n content: \"\\f834\"; }\n\n.fa-algolia:before {\n content: \"\\f36c\"; }\n\n.fa-align-center:before {\n content: \"\\f037\"; }\n\n.fa-align-justify:before {\n content: \"\\f039\"; }\n\n.fa-align-left:before {\n content: \"\\f036\"; }\n\n.fa-align-right:before {\n content: \"\\f038\"; }\n\n.fa-alipay:before {\n content: \"\\f642\"; }\n\n.fa-allergies:before {\n content: \"\\f461\"; }\n\n.fa-amazon:before {\n content: \"\\f270\"; }\n\n.fa-amazon-pay:before {\n content: \"\\f42c\"; }\n\n.fa-ambulance:before {\n content: \"\\f0f9\"; }\n\n.fa-american-sign-language-interpreting:before {\n content: \"\\f2a3\"; }\n\n.fa-amilia:before {\n content: \"\\f36d\"; }\n\n.fa-anchor:before {\n content: \"\\f13d\"; }\n\n.fa-android:before {\n content: \"\\f17b\"; }\n\n.fa-angellist:before {\n content: \"\\f209\"; }\n\n.fa-angle-double-down:before {\n content: \"\\f103\"; }\n\n.fa-angle-double-left:before {\n content: \"\\f100\"; }\n\n.fa-angle-double-right:before {\n content: \"\\f101\"; }\n\n.fa-angle-double-up:before {\n content: \"\\f102\"; }\n\n.fa-angle-down:before {\n content: \"\\f107\"; }\n\n.fa-angle-left:before {\n content: \"\\f104\"; }\n\n.fa-angle-right:before {\n content: \"\\f105\"; }\n\n.fa-angle-up:before {\n content: \"\\f106\"; }\n\n.fa-angry:before {\n content: \"\\f556\"; }\n\n.fa-angrycreative:before {\n content: \"\\f36e\"; }\n\n.fa-angular:before {\n content: \"\\f420\"; }\n\n.fa-ankh:before {\n content: \"\\f644\"; }\n\n.fa-app-store:before {\n content: \"\\f36f\"; }\n\n.fa-app-store-ios:before {\n content: \"\\f370\"; }\n\n.fa-apper:before {\n content: \"\\f371\"; }\n\n.fa-apple:before {\n content: \"\\f179\"; }\n\n.fa-apple-alt:before {\n content: \"\\f5d1\"; }\n\n.fa-apple-pay:before {\n content: \"\\f415\"; }\n\n.fa-archive:before {\n content: \"\\f187\"; }\n\n.fa-archway:before {\n content: \"\\f557\"; }\n\n.fa-arrow-alt-circle-down:before {\n content: \"\\f358\"; }\n\n.fa-arrow-alt-circle-left:before {\n content: \"\\f359\"; }\n\n.fa-arrow-alt-circle-right:before {\n content: \"\\f35a\"; }\n\n.fa-arrow-alt-circle-up:before {\n content: \"\\f35b\"; }\n\n.fa-arrow-circle-down:before {\n content: \"\\f0ab\"; }\n\n.fa-arrow-circle-left:before {\n content: \"\\f0a8\"; }\n\n.fa-arrow-circle-right:before {\n content: \"\\f0a9\"; }\n\n.fa-arrow-circle-up:before {\n content: \"\\f0aa\"; }\n\n.fa-arrow-down:before {\n content: \"\\f063\"; }\n\n.fa-arrow-left:before {\n content: \"\\f060\"; }\n\n.fa-arrow-right:before {\n content: \"\\f061\"; }\n\n.fa-arrow-up:before {\n content: \"\\f062\"; }\n\n.fa-arrows-alt:before {\n content: \"\\f0b2\"; }\n\n.fa-arrows-alt-h:before {\n content: \"\\f337\"; }\n\n.fa-arrows-alt-v:before {\n content: \"\\f338\"; }\n\n.fa-artstation:before {\n content: \"\\f77a\"; }\n\n.fa-assistive-listening-systems:before {\n content: \"\\f2a2\"; }\n\n.fa-asterisk:before {\n content: \"\\f069\"; }\n\n.fa-asymmetrik:before {\n content: \"\\f372\"; }\n\n.fa-at:before {\n content: \"\\f1fa\"; }\n\n.fa-atlas:before {\n content: \"\\f558\"; }\n\n.fa-atlassian:before {\n content: \"\\f77b\"; }\n\n.fa-atom:before {\n content: \"\\f5d2\"; }\n\n.fa-audible:before {\n content: \"\\f373\"; }\n\n.fa-audio-description:before {\n content: \"\\f29e\"; }\n\n.fa-autoprefixer:before {\n content: \"\\f41c\"; }\n\n.fa-avianex:before {\n content: \"\\f374\"; }\n\n.fa-aviato:before {\n content: \"\\f421\"; }\n\n.fa-award:before {\n content: \"\\f559\"; }\n\n.fa-aws:before {\n content: \"\\f375\"; }\n\n.fa-baby:before {\n content: \"\\f77c\"; }\n\n.fa-baby-carriage:before {\n content: \"\\f77d\"; }\n\n.fa-backspace:before {\n content: \"\\f55a\"; }\n\n.fa-backward:before {\n content: \"\\f04a\"; }\n\n.fa-bacon:before {\n content: \"\\f7e5\"; }\n\n.fa-bacteria:before {\n content: \"\\e059\"; }\n\n.fa-bacterium:before {\n content: \"\\e05a\"; }\n\n.fa-bahai:before {\n content: \"\\f666\"; }\n\n.fa-balance-scale:before {\n content: \"\\f24e\"; }\n\n.fa-balance-scale-left:before {\n content: \"\\f515\"; }\n\n.fa-balance-scale-right:before {\n content: \"\\f516\"; }\n\n.fa-ban:before {\n content: \"\\f05e\"; }\n\n.fa-band-aid:before {\n content: \"\\f462\"; }\n\n.fa-bandcamp:before {\n content: \"\\f2d5\"; }\n\n.fa-barcode:before {\n content: \"\\f02a\"; }\n\n.fa-bars:before {\n content: \"\\f0c9\"; }\n\n.fa-baseball-ball:before {\n content: \"\\f433\"; }\n\n.fa-basketball-ball:before {\n content: \"\\f434\"; }\n\n.fa-bath:before {\n content: \"\\f2cd\"; }\n\n.fa-battery-empty:before {\n content: \"\\f244\"; }\n\n.fa-battery-full:before {\n content: \"\\f240\"; }\n\n.fa-battery-half:before {\n content: \"\\f242\"; }\n\n.fa-battery-quarter:before {\n content: \"\\f243\"; }\n\n.fa-battery-three-quarters:before {\n content: \"\\f241\"; }\n\n.fa-battle-net:before {\n content: \"\\f835\"; }\n\n.fa-bed:before {\n content: \"\\f236\"; }\n\n.fa-beer:before {\n content: \"\\f0fc\"; }\n\n.fa-behance:before {\n content: \"\\f1b4\"; }\n\n.fa-behance-square:before {\n content: \"\\f1b5\"; }\n\n.fa-bell:before {\n content: \"\\f0f3\"; }\n\n.fa-bell-slash:before {\n content: \"\\f1f6\"; }\n\n.fa-bezier-curve:before {\n content: \"\\f55b\"; }\n\n.fa-bible:before {\n content: \"\\f647\"; }\n\n.fa-bicycle:before {\n content: \"\\f206\"; }\n\n.fa-biking:before {\n content: \"\\f84a\"; }\n\n.fa-bimobject:before {\n content: \"\\f378\"; }\n\n.fa-binoculars:before {\n content: \"\\f1e5\"; }\n\n.fa-biohazard:before {\n content: \"\\f780\"; }\n\n.fa-birthday-cake:before {\n content: \"\\f1fd\"; }\n\n.fa-bitbucket:before {\n content: \"\\f171\"; }\n\n.fa-bitcoin:before {\n content: \"\\f379\"; }\n\n.fa-bity:before {\n content: \"\\f37a\"; }\n\n.fa-black-tie:before {\n content: \"\\f27e\"; }\n\n.fa-blackberry:before {\n content: \"\\f37b\"; }\n\n.fa-blender:before {\n content: \"\\f517\"; }\n\n.fa-blender-phone:before {\n content: \"\\f6b6\"; }\n\n.fa-blind:before {\n content: \"\\f29d\"; }\n\n.fa-blog:before {\n content: \"\\f781\"; }\n\n.fa-blogger:before {\n content: \"\\f37c\"; }\n\n.fa-blogger-b:before {\n content: \"\\f37d\"; }\n\n.fa-bluetooth:before {\n content: \"\\f293\"; }\n\n.fa-bluetooth-b:before {\n content: \"\\f294\"; }\n\n.fa-bold:before {\n content: \"\\f032\"; }\n\n.fa-bolt:before {\n content: \"\\f0e7\"; }\n\n.fa-bomb:before {\n content: \"\\f1e2\"; }\n\n.fa-bone:before {\n content: \"\\f5d7\"; }\n\n.fa-bong:before {\n content: \"\\f55c\"; }\n\n.fa-book:before {\n content: \"\\f02d\"; }\n\n.fa-book-dead:before {\n content: \"\\f6b7\"; }\n\n.fa-book-medical:before {\n content: \"\\f7e6\"; }\n\n.fa-book-open:before {\n content: \"\\f518\"; }\n\n.fa-book-reader:before {\n content: \"\\f5da\"; }\n\n.fa-bookmark:before {\n content: \"\\f02e\"; }\n\n.fa-bootstrap:before {\n content: \"\\f836\"; }\n\n.fa-border-all:before {\n content: \"\\f84c\"; }\n\n.fa-border-none:before {\n content: \"\\f850\"; }\n\n.fa-border-style:before {\n content: \"\\f853\"; }\n\n.fa-bowling-ball:before {\n content: \"\\f436\"; }\n\n.fa-box:before {\n content: \"\\f466\"; }\n\n.fa-box-open:before {\n content: \"\\f49e\"; }\n\n.fa-box-tissue:before {\n content: \"\\e05b\"; }\n\n.fa-boxes:before {\n content: \"\\f468\"; }\n\n.fa-braille:before {\n content: \"\\f2a1\"; }\n\n.fa-brain:before {\n content: \"\\f5dc\"; }\n\n.fa-bread-slice:before {\n content: \"\\f7ec\"; }\n\n.fa-briefcase:before {\n content: \"\\f0b1\"; }\n\n.fa-briefcase-medical:before {\n content: \"\\f469\"; }\n\n.fa-broadcast-tower:before {\n content: \"\\f519\"; }\n\n.fa-broom:before {\n content: \"\\f51a\"; }\n\n.fa-brush:before {\n content: \"\\f55d\"; }\n\n.fa-btc:before {\n content: \"\\f15a\"; }\n\n.fa-buffer:before {\n content: \"\\f837\"; }\n\n.fa-bug:before {\n content: \"\\f188\"; }\n\n.fa-building:before {\n content: \"\\f1ad\"; }\n\n.fa-bullhorn:before {\n content: \"\\f0a1\"; }\n\n.fa-bullseye:before {\n content: \"\\f140\"; }\n\n.fa-burn:before {\n content: \"\\f46a\"; }\n\n.fa-buromobelexperte:before {\n content: \"\\f37f\"; }\n\n.fa-bus:before {\n content: \"\\f207\"; }\n\n.fa-bus-alt:before {\n content: \"\\f55e\"; }\n\n.fa-business-time:before {\n content: \"\\f64a\"; }\n\n.fa-buy-n-large:before {\n content: \"\\f8a6\"; }\n\n.fa-buysellads:before {\n content: \"\\f20d\"; }\n\n.fa-calculator:before {\n content: \"\\f1ec\"; }\n\n.fa-calendar:before {\n content: \"\\f133\"; }\n\n.fa-calendar-alt:before {\n content: \"\\f073\"; }\n\n.fa-calendar-check:before {\n content: \"\\f274\"; }\n\n.fa-calendar-day:before {\n content: \"\\f783\"; }\n\n.fa-calendar-minus:before {\n content: \"\\f272\"; }\n\n.fa-calendar-plus:before {\n content: \"\\f271\"; }\n\n.fa-calendar-times:before {\n content: \"\\f273\"; }\n\n.fa-calendar-week:before {\n content: \"\\f784\"; }\n\n.fa-camera:before {\n content: \"\\f030\"; }\n\n.fa-camera-retro:before {\n content: \"\\f083\"; }\n\n.fa-campground:before {\n content: \"\\f6bb\"; }\n\n.fa-canadian-maple-leaf:before {\n content: \"\\f785\"; }\n\n.fa-candy-cane:before {\n content: \"\\f786\"; }\n\n.fa-cannabis:before {\n content: \"\\f55f\"; }\n\n.fa-capsules:before {\n content: \"\\f46b\"; }\n\n.fa-car:before {\n content: \"\\f1b9\"; }\n\n.fa-car-alt:before {\n content: \"\\f5de\"; }\n\n.fa-car-battery:before {\n content: \"\\f5df\"; }\n\n.fa-car-crash:before {\n content: \"\\f5e1\"; }\n\n.fa-car-side:before {\n content: \"\\f5e4\"; }\n\n.fa-caravan:before {\n content: \"\\f8ff\"; }\n\n.fa-caret-down:before {\n content: \"\\f0d7\"; }\n\n.fa-caret-left:before {\n content: \"\\f0d9\"; }\n\n.fa-caret-right:before {\n content: \"\\f0da\"; }\n\n.fa-caret-square-down:before {\n content: \"\\f150\"; }\n\n.fa-caret-square-left:before {\n content: \"\\f191\"; }\n\n.fa-caret-square-right:before {\n content: \"\\f152\"; }\n\n.fa-caret-square-up:before {\n content: \"\\f151\"; }\n\n.fa-caret-up:before {\n content: \"\\f0d8\"; }\n\n.fa-carrot:before {\n content: \"\\f787\"; }\n\n.fa-cart-arrow-down:before {\n content: \"\\f218\"; }\n\n.fa-cart-plus:before {\n content: \"\\f217\"; }\n\n.fa-cash-register:before {\n content: \"\\f788\"; }\n\n.fa-cat:before {\n content: \"\\f6be\"; }\n\n.fa-cc-amazon-pay:before {\n content: \"\\f42d\"; }\n\n.fa-cc-amex:before {\n content: \"\\f1f3\"; }\n\n.fa-cc-apple-pay:before {\n content: \"\\f416\"; }\n\n.fa-cc-diners-club:before {\n content: \"\\f24c\"; }\n\n.fa-cc-discover:before {\n content: \"\\f1f2\"; }\n\n.fa-cc-jcb:before {\n content: \"\\f24b\"; }\n\n.fa-cc-mastercard:before {\n content: \"\\f1f1\"; }\n\n.fa-cc-paypal:before {\n content: \"\\f1f4\"; }\n\n.fa-cc-stripe:before {\n content: \"\\f1f5\"; }\n\n.fa-cc-visa:before {\n content: \"\\f1f0\"; }\n\n.fa-centercode:before {\n content: \"\\f380\"; }\n\n.fa-centos:before {\n content: \"\\f789\"; }\n\n.fa-certificate:before {\n content: \"\\f0a3\"; }\n\n.fa-chair:before {\n content: \"\\f6c0\"; }\n\n.fa-chalkboard:before {\n content: \"\\f51b\"; }\n\n.fa-chalkboard-teacher:before {\n content: \"\\f51c\"; }\n\n.fa-charging-station:before {\n content: \"\\f5e7\"; }\n\n.fa-chart-area:before {\n content: \"\\f1fe\"; }\n\n.fa-chart-bar:before {\n content: \"\\f080\"; }\n\n.fa-chart-line:before {\n content: \"\\f201\"; }\n\n.fa-chart-pie:before {\n content: \"\\f200\"; }\n\n.fa-check:before {\n content: \"\\f00c\"; }\n\n.fa-check-circle:before {\n content: \"\\f058\"; }\n\n.fa-check-double:before {\n content: \"\\f560\"; }\n\n.fa-check-square:before {\n content: \"\\f14a\"; }\n\n.fa-cheese:before {\n content: \"\\f7ef\"; }\n\n.fa-chess:before {\n content: \"\\f439\"; }\n\n.fa-chess-bishop:before {\n content: \"\\f43a\"; }\n\n.fa-chess-board:before {\n content: \"\\f43c\"; }\n\n.fa-chess-king:before {\n content: \"\\f43f\"; }\n\n.fa-chess-knight:before {\n content: \"\\f441\"; }\n\n.fa-chess-pawn:before {\n content: \"\\f443\"; }\n\n.fa-chess-queen:before {\n content: \"\\f445\"; }\n\n.fa-chess-rook:before {\n content: \"\\f447\"; }\n\n.fa-chevron-circle-down:before {\n content: \"\\f13a\"; }\n\n.fa-chevron-circle-left:before {\n content: \"\\f137\"; }\n\n.fa-chevron-circle-right:before {\n content: \"\\f138\"; }\n\n.fa-chevron-circle-up:before {\n content: \"\\f139\"; }\n\n.fa-chevron-down:before {\n content: \"\\f078\"; }\n\n.fa-chevron-left:before {\n content: \"\\f053\"; }\n\n.fa-chevron-right:before {\n content: \"\\f054\"; }\n\n.fa-chevron-up:before {\n content: \"\\f077\"; }\n\n.fa-child:before {\n content: \"\\f1ae\"; }\n\n.fa-chrome:before {\n content: \"\\f268\"; }\n\n.fa-chromecast:before {\n content: \"\\f838\"; }\n\n.fa-church:before {\n content: \"\\f51d\"; }\n\n.fa-circle:before {\n content: \"\\f111\"; }\n\n.fa-circle-notch:before {\n content: \"\\f1ce\"; }\n\n.fa-city:before {\n content: \"\\f64f\"; }\n\n.fa-clinic-medical:before {\n content: \"\\f7f2\"; }\n\n.fa-clipboard:before {\n content: \"\\f328\"; }\n\n.fa-clipboard-check:before {\n content: \"\\f46c\"; }\n\n.fa-clipboard-list:before {\n content: \"\\f46d\"; }\n\n.fa-clock:before {\n content: \"\\f017\"; }\n\n.fa-clone:before {\n content: \"\\f24d\"; }\n\n.fa-closed-captioning:before {\n content: \"\\f20a\"; }\n\n.fa-cloud:before {\n content: \"\\f0c2\"; }\n\n.fa-cloud-download-alt:before {\n content: \"\\f381\"; }\n\n.fa-cloud-meatball:before {\n content: \"\\f73b\"; }\n\n.fa-cloud-moon:before {\n content: \"\\f6c3\"; }\n\n.fa-cloud-moon-rain:before {\n content: \"\\f73c\"; }\n\n.fa-cloud-rain:before {\n content: \"\\f73d\"; }\n\n.fa-cloud-showers-heavy:before {\n content: \"\\f740\"; }\n\n.fa-cloud-sun:before {\n content: \"\\f6c4\"; }\n\n.fa-cloud-sun-rain:before {\n content: \"\\f743\"; }\n\n.fa-cloud-upload-alt:before {\n content: \"\\f382\"; }\n\n.fa-cloudflare:before {\n content: \"\\e07d\"; }\n\n.fa-cloudscale:before {\n content: \"\\f383\"; }\n\n.fa-cloudsmith:before {\n content: \"\\f384\"; }\n\n.fa-cloudversify:before {\n content: \"\\f385\"; }\n\n.fa-cocktail:before {\n content: \"\\f561\"; }\n\n.fa-code:before {\n content: \"\\f121\"; }\n\n.fa-code-branch:before {\n content: \"\\f126\"; }\n\n.fa-codepen:before {\n content: \"\\f1cb\"; }\n\n.fa-codiepie:before {\n content: \"\\f284\"; }\n\n.fa-coffee:before {\n content: \"\\f0f4\"; }\n\n.fa-cog:before {\n content: \"\\f013\"; }\n\n.fa-cogs:before {\n content: \"\\f085\"; }\n\n.fa-coins:before {\n content: \"\\f51e\"; }\n\n.fa-columns:before {\n content: \"\\f0db\"; }\n\n.fa-comment:before {\n content: \"\\f075\"; }\n\n.fa-comment-alt:before {\n content: \"\\f27a\"; }\n\n.fa-comment-dollar:before {\n content: \"\\f651\"; }\n\n.fa-comment-dots:before {\n content: \"\\f4ad\"; }\n\n.fa-comment-medical:before {\n content: \"\\f7f5\"; }\n\n.fa-comment-slash:before {\n content: \"\\f4b3\"; }\n\n.fa-comments:before {\n content: \"\\f086\"; }\n\n.fa-comments-dollar:before {\n content: \"\\f653\"; }\n\n.fa-compact-disc:before {\n content: \"\\f51f\"; }\n\n.fa-compass:before {\n content: \"\\f14e\"; }\n\n.fa-compress:before {\n content: \"\\f066\"; }\n\n.fa-compress-alt:before {\n content: \"\\f422\"; }\n\n.fa-compress-arrows-alt:before {\n content: \"\\f78c\"; }\n\n.fa-concierge-bell:before {\n content: \"\\f562\"; }\n\n.fa-confluence:before {\n content: \"\\f78d\"; }\n\n.fa-connectdevelop:before {\n content: \"\\f20e\"; }\n\n.fa-contao:before {\n content: \"\\f26d\"; }\n\n.fa-cookie:before {\n content: \"\\f563\"; }\n\n.fa-cookie-bite:before {\n content: \"\\f564\"; }\n\n.fa-copy:before {\n content: \"\\f0c5\"; }\n\n.fa-copyright:before {\n content: \"\\f1f9\"; }\n\n.fa-cotton-bureau:before {\n content: \"\\f89e\"; }\n\n.fa-couch:before {\n content: \"\\f4b8\"; }\n\n.fa-cpanel:before {\n content: \"\\f388\"; }\n\n.fa-creative-commons:before {\n content: \"\\f25e\"; }\n\n.fa-creative-commons-by:before {\n content: \"\\f4e7\"; }\n\n.fa-creative-commons-nc:before {\n content: \"\\f4e8\"; }\n\n.fa-creative-commons-nc-eu:before {\n content: \"\\f4e9\"; }\n\n.fa-creative-commons-nc-jp:before {\n content: \"\\f4ea\"; }\n\n.fa-creative-commons-nd:before {\n content: \"\\f4eb\"; }\n\n.fa-creative-commons-pd:before {\n content: \"\\f4ec\"; }\n\n.fa-creative-commons-pd-alt:before {\n content: \"\\f4ed\"; }\n\n.fa-creative-commons-remix:before {\n content: \"\\f4ee\"; }\n\n.fa-creative-commons-sa:before {\n content: \"\\f4ef\"; }\n\n.fa-creative-commons-sampling:before {\n content: \"\\f4f0\"; }\n\n.fa-creative-commons-sampling-plus:before {\n content: \"\\f4f1\"; }\n\n.fa-creative-commons-share:before {\n content: \"\\f4f2\"; }\n\n.fa-creative-commons-zero:before {\n content: \"\\f4f3\"; }\n\n.fa-credit-card:before {\n content: \"\\f09d\"; }\n\n.fa-critical-role:before {\n content: \"\\f6c9\"; }\n\n.fa-crop:before {\n content: \"\\f125\"; }\n\n.fa-crop-alt:before {\n content: \"\\f565\"; }\n\n.fa-cross:before {\n content: \"\\f654\"; }\n\n.fa-crosshairs:before {\n content: \"\\f05b\"; }\n\n.fa-crow:before {\n content: \"\\f520\"; }\n\n.fa-crown:before {\n content: \"\\f521\"; }\n\n.fa-crutch:before {\n content: \"\\f7f7\"; }\n\n.fa-css3:before {\n content: \"\\f13c\"; }\n\n.fa-css3-alt:before {\n content: \"\\f38b\"; }\n\n.fa-cube:before {\n content: \"\\f1b2\"; }\n\n.fa-cubes:before {\n content: \"\\f1b3\"; }\n\n.fa-cut:before {\n content: \"\\f0c4\"; }\n\n.fa-cuttlefish:before {\n content: \"\\f38c\"; }\n\n.fa-d-and-d:before {\n content: \"\\f38d\"; }\n\n.fa-d-and-d-beyond:before {\n content: \"\\f6ca\"; }\n\n.fa-dailymotion:before {\n content: \"\\e052\"; }\n\n.fa-dashcube:before {\n content: \"\\f210\"; }\n\n.fa-database:before {\n content: \"\\f1c0\"; }\n\n.fa-deaf:before {\n content: \"\\f2a4\"; }\n\n.fa-deezer:before {\n content: \"\\e077\"; }\n\n.fa-delicious:before {\n content: \"\\f1a5\"; }\n\n.fa-democrat:before {\n content: \"\\f747\"; }\n\n.fa-deploydog:before {\n content: \"\\f38e\"; }\n\n.fa-deskpro:before {\n content: \"\\f38f\"; }\n\n.fa-desktop:before {\n content: \"\\f108\"; }\n\n.fa-dev:before {\n content: \"\\f6cc\"; }\n\n.fa-deviantart:before {\n content: \"\\f1bd\"; }\n\n.fa-dharmachakra:before {\n content: \"\\f655\"; }\n\n.fa-dhl:before {\n content: \"\\f790\"; }\n\n.fa-diagnoses:before {\n content: \"\\f470\"; }\n\n.fa-diaspora:before {\n content: \"\\f791\"; }\n\n.fa-dice:before {\n content: \"\\f522\"; }\n\n.fa-dice-d20:before {\n content: \"\\f6cf\"; }\n\n.fa-dice-d6:before {\n content: \"\\f6d1\"; }\n\n.fa-dice-five:before {\n content: \"\\f523\"; }\n\n.fa-dice-four:before {\n content: \"\\f524\"; }\n\n.fa-dice-one:before {\n content: \"\\f525\"; }\n\n.fa-dice-six:before {\n content: \"\\f526\"; }\n\n.fa-dice-three:before {\n content: \"\\f527\"; }\n\n.fa-dice-two:before {\n content: \"\\f528\"; }\n\n.fa-digg:before {\n content: \"\\f1a6\"; }\n\n.fa-digital-ocean:before {\n content: \"\\f391\"; }\n\n.fa-digital-tachograph:before {\n content: \"\\f566\"; }\n\n.fa-directions:before {\n content: \"\\f5eb\"; }\n\n.fa-discord:before {\n content: \"\\f392\"; }\n\n.fa-discourse:before {\n content: \"\\f393\"; }\n\n.fa-disease:before {\n content: \"\\f7fa\"; }\n\n.fa-divide:before {\n content: \"\\f529\"; }\n\n.fa-dizzy:before {\n content: \"\\f567\"; }\n\n.fa-dna:before {\n content: \"\\f471\"; }\n\n.fa-dochub:before {\n content: \"\\f394\"; }\n\n.fa-docker:before {\n content: \"\\f395\"; }\n\n.fa-dog:before {\n content: \"\\f6d3\"; }\n\n.fa-dollar-sign:before {\n content: \"\\f155\"; }\n\n.fa-dolly:before {\n content: \"\\f472\"; }\n\n.fa-dolly-flatbed:before {\n content: \"\\f474\"; }\n\n.fa-donate:before {\n content: \"\\f4b9\"; }\n\n.fa-door-closed:before {\n content: \"\\f52a\"; }\n\n.fa-door-open:before {\n content: \"\\f52b\"; }\n\n.fa-dot-circle:before {\n content: \"\\f192\"; }\n\n.fa-dove:before {\n content: \"\\f4ba\"; }\n\n.fa-download:before {\n content: \"\\f019\"; }\n\n.fa-draft2digital:before {\n content: \"\\f396\"; }\n\n.fa-drafting-compass:before {\n content: \"\\f568\"; }\n\n.fa-dragon:before {\n content: \"\\f6d5\"; }\n\n.fa-draw-polygon:before {\n content: \"\\f5ee\"; }\n\n.fa-dribbble:before {\n content: \"\\f17d\"; }\n\n.fa-dribbble-square:before {\n content: \"\\f397\"; }\n\n.fa-dropbox:before {\n content: \"\\f16b\"; }\n\n.fa-drum:before {\n content: \"\\f569\"; }\n\n.fa-drum-steelpan:before {\n content: \"\\f56a\"; }\n\n.fa-drumstick-bite:before {\n content: \"\\f6d7\"; }\n\n.fa-drupal:before {\n content: \"\\f1a9\"; }\n\n.fa-dumbbell:before {\n content: \"\\f44b\"; }\n\n.fa-dumpster:before {\n content: \"\\f793\"; }\n\n.fa-dumpster-fire:before {\n content: \"\\f794\"; }\n\n.fa-dungeon:before {\n content: \"\\f6d9\"; }\n\n.fa-dyalog:before {\n content: \"\\f399\"; }\n\n.fa-earlybirds:before {\n content: \"\\f39a\"; }\n\n.fa-ebay:before {\n content: \"\\f4f4\"; }\n\n.fa-edge:before {\n content: \"\\f282\"; }\n\n.fa-edge-legacy:before {\n content: \"\\e078\"; }\n\n.fa-edit:before {\n content: \"\\f044\"; }\n\n.fa-egg:before {\n content: \"\\f7fb\"; }\n\n.fa-eject:before {\n content: \"\\f052\"; }\n\n.fa-elementor:before {\n content: \"\\f430\"; }\n\n.fa-ellipsis-h:before {\n content: \"\\f141\"; }\n\n.fa-ellipsis-v:before {\n content: \"\\f142\"; }\n\n.fa-ello:before {\n content: \"\\f5f1\"; }\n\n.fa-ember:before {\n content: \"\\f423\"; }\n\n.fa-empire:before {\n content: \"\\f1d1\"; }\n\n.fa-envelope:before {\n content: \"\\f0e0\"; }\n\n.fa-envelope-open:before {\n content: \"\\f2b6\"; }\n\n.fa-envelope-open-text:before {\n content: \"\\f658\"; }\n\n.fa-envelope-square:before {\n content: \"\\f199\"; }\n\n.fa-envira:before {\n content: \"\\f299\"; }\n\n.fa-equals:before {\n content: \"\\f52c\"; }\n\n.fa-eraser:before {\n content: \"\\f12d\"; }\n\n.fa-erlang:before {\n content: \"\\f39d\"; }\n\n.fa-ethereum:before {\n content: \"\\f42e\"; }\n\n.fa-ethernet:before {\n content: \"\\f796\"; }\n\n.fa-etsy:before {\n content: \"\\f2d7\"; }\n\n.fa-euro-sign:before {\n content: \"\\f153\"; }\n\n.fa-evernote:before {\n content: \"\\f839\"; }\n\n.fa-exchange-alt:before {\n content: \"\\f362\"; }\n\n.fa-exclamation:before {\n content: \"\\f12a\"; }\n\n.fa-exclamation-circle:before {\n content: \"\\f06a\"; }\n\n.fa-exclamation-triangle:before {\n content: \"\\f071\"; }\n\n.fa-expand:before {\n content: \"\\f065\"; }\n\n.fa-expand-alt:before {\n content: \"\\f424\"; }\n\n.fa-expand-arrows-alt:before {\n content: \"\\f31e\"; }\n\n.fa-expeditedssl:before {\n content: \"\\f23e\"; }\n\n.fa-external-link-alt:before {\n content: \"\\f35d\"; }\n\n.fa-external-link-square-alt:before {\n content: \"\\f360\"; }\n\n.fa-eye:before {\n content: \"\\f06e\"; }\n\n.fa-eye-dropper:before {\n content: \"\\f1fb\"; }\n\n.fa-eye-slash:before {\n content: \"\\f070\"; }\n\n.fa-facebook:before {\n content: \"\\f09a\"; }\n\n.fa-facebook-f:before {\n content: \"\\f39e\"; }\n\n.fa-facebook-messenger:before {\n content: \"\\f39f\"; }\n\n.fa-facebook-square:before {\n content: \"\\f082\"; }\n\n.fa-fan:before {\n content: \"\\f863\"; }\n\n.fa-fantasy-flight-games:before {\n content: \"\\f6dc\"; }\n\n.fa-fast-backward:before {\n content: \"\\f049\"; }\n\n.fa-fast-forward:before {\n content: \"\\f050\"; }\n\n.fa-faucet:before {\n content: \"\\e005\"; }\n\n.fa-fax:before {\n content: \"\\f1ac\"; }\n\n.fa-feather:before {\n content: \"\\f52d\"; }\n\n.fa-feather-alt:before {\n content: \"\\f56b\"; }\n\n.fa-fedex:before {\n content: \"\\f797\"; }\n\n.fa-fedora:before {\n content: \"\\f798\"; }\n\n.fa-female:before {\n content: \"\\f182\"; }\n\n.fa-fighter-jet:before {\n content: \"\\f0fb\"; }\n\n.fa-figma:before {\n content: \"\\f799\"; }\n\n.fa-file:before {\n content: \"\\f15b\"; }\n\n.fa-file-alt:before {\n content: \"\\f15c\"; }\n\n.fa-file-archive:before {\n content: \"\\f1c6\"; }\n\n.fa-file-audio:before {\n content: \"\\f1c7\"; }\n\n.fa-file-code:before {\n content: \"\\f1c9\"; }\n\n.fa-file-contract:before {\n content: \"\\f56c\"; }\n\n.fa-file-csv:before {\n content: \"\\f6dd\"; }\n\n.fa-file-download:before {\n content: \"\\f56d\"; }\n\n.fa-file-excel:before {\n content: \"\\f1c3\"; }\n\n.fa-file-export:before {\n content: \"\\f56e\"; }\n\n.fa-file-image:before {\n content: \"\\f1c5\"; }\n\n.fa-file-import:before {\n content: \"\\f56f\"; }\n\n.fa-file-invoice:before {\n content: \"\\f570\"; }\n\n.fa-file-invoice-dollar:before {\n content: \"\\f571\"; }\n\n.fa-file-medical:before {\n content: \"\\f477\"; }\n\n.fa-file-medical-alt:before {\n content: \"\\f478\"; }\n\n.fa-file-pdf:before {\n content: \"\\f1c1\"; }\n\n.fa-file-powerpoint:before {\n content: \"\\f1c4\"; }\n\n.fa-file-prescription:before {\n content: \"\\f572\"; }\n\n.fa-file-signature:before {\n content: \"\\f573\"; }\n\n.fa-file-upload:before {\n content: \"\\f574\"; }\n\n.fa-file-video:before {\n content: \"\\f1c8\"; }\n\n.fa-file-word:before {\n content: \"\\f1c2\"; }\n\n.fa-fill:before {\n content: \"\\f575\"; }\n\n.fa-fill-drip:before {\n content: \"\\f576\"; }\n\n.fa-film:before {\n content: \"\\f008\"; }\n\n.fa-filter:before {\n content: \"\\f0b0\"; }\n\n.fa-fingerprint:before {\n content: \"\\f577\"; }\n\n.fa-fire:before {\n content: \"\\f06d\"; }\n\n.fa-fire-alt:before {\n content: \"\\f7e4\"; }\n\n.fa-fire-extinguisher:before {\n content: \"\\f134\"; }\n\n.fa-firefox:before {\n content: \"\\f269\"; }\n\n.fa-firefox-browser:before {\n content: \"\\e007\"; }\n\n.fa-first-aid:before {\n content: \"\\f479\"; }\n\n.fa-first-order:before {\n content: \"\\f2b0\"; }\n\n.fa-first-order-alt:before {\n content: \"\\f50a\"; }\n\n.fa-firstdraft:before {\n content: \"\\f3a1\"; }\n\n.fa-fish:before {\n content: \"\\f578\"; }\n\n.fa-fist-raised:before {\n content: \"\\f6de\"; }\n\n.fa-flag:before {\n content: \"\\f024\"; }\n\n.fa-flag-checkered:before {\n content: \"\\f11e\"; }\n\n.fa-flag-usa:before {\n content: \"\\f74d\"; }\n\n.fa-flask:before {\n content: \"\\f0c3\"; }\n\n.fa-flickr:before {\n content: \"\\f16e\"; }\n\n.fa-flipboard:before {\n content: \"\\f44d\"; }\n\n.fa-flushed:before {\n content: \"\\f579\"; }\n\n.fa-fly:before {\n content: \"\\f417\"; }\n\n.fa-folder:before {\n content: \"\\f07b\"; }\n\n.fa-folder-minus:before {\n content: \"\\f65d\"; }\n\n.fa-folder-open:before {\n content: \"\\f07c\"; }\n\n.fa-folder-plus:before {\n content: \"\\f65e\"; }\n\n.fa-font:before {\n content: \"\\f031\"; }\n\n.fa-font-awesome:before {\n content: \"\\f2b4\"; }\n\n.fa-font-awesome-alt:before {\n content: \"\\f35c\"; }\n\n.fa-font-awesome-flag:before {\n content: \"\\f425\"; }\n\n.fa-font-awesome-logo-full:before {\n content: \"\\f4e6\"; }\n\n.fa-fonticons:before {\n content: \"\\f280\"; }\n\n.fa-fonticons-fi:before {\n content: \"\\f3a2\"; }\n\n.fa-football-ball:before {\n content: \"\\f44e\"; }\n\n.fa-fort-awesome:before {\n content: \"\\f286\"; }\n\n.fa-fort-awesome-alt:before {\n content: \"\\f3a3\"; }\n\n.fa-forumbee:before {\n content: \"\\f211\"; }\n\n.fa-forward:before {\n content: \"\\f04e\"; }\n\n.fa-foursquare:before {\n content: \"\\f180\"; }\n\n.fa-free-code-camp:before {\n content: \"\\f2c5\"; }\n\n.fa-freebsd:before {\n content: \"\\f3a4\"; }\n\n.fa-frog:before {\n content: \"\\f52e\"; }\n\n.fa-frown:before {\n content: \"\\f119\"; }\n\n.fa-frown-open:before {\n content: \"\\f57a\"; }\n\n.fa-fulcrum:before {\n content: \"\\f50b\"; }\n\n.fa-funnel-dollar:before {\n content: \"\\f662\"; }\n\n.fa-futbol:before {\n content: \"\\f1e3\"; }\n\n.fa-galactic-republic:before {\n content: \"\\f50c\"; }\n\n.fa-galactic-senate:before {\n content: \"\\f50d\"; }\n\n.fa-gamepad:before {\n content: \"\\f11b\"; }\n\n.fa-gas-pump:before {\n content: \"\\f52f\"; }\n\n.fa-gavel:before {\n content: \"\\f0e3\"; }\n\n.fa-gem:before {\n content: \"\\f3a5\"; }\n\n.fa-genderless:before {\n content: \"\\f22d\"; }\n\n.fa-get-pocket:before {\n content: \"\\f265\"; }\n\n.fa-gg:before {\n content: \"\\f260\"; }\n\n.fa-gg-circle:before {\n content: \"\\f261\"; }\n\n.fa-ghost:before {\n content: \"\\f6e2\"; }\n\n.fa-gift:before {\n content: \"\\f06b\"; }\n\n.fa-gifts:before {\n content: \"\\f79c\"; }\n\n.fa-git:before {\n content: \"\\f1d3\"; }\n\n.fa-git-alt:before {\n content: \"\\f841\"; }\n\n.fa-git-square:before {\n content: \"\\f1d2\"; }\n\n.fa-github:before {\n content: \"\\f09b\"; }\n\n.fa-github-alt:before {\n content: \"\\f113\"; }\n\n.fa-github-square:before {\n content: \"\\f092\"; }\n\n.fa-gitkraken:before {\n content: \"\\f3a6\"; }\n\n.fa-gitlab:before {\n content: \"\\f296\"; }\n\n.fa-gitter:before {\n content: \"\\f426\"; }\n\n.fa-glass-cheers:before {\n content: \"\\f79f\"; }\n\n.fa-glass-martini:before {\n content: \"\\f000\"; }\n\n.fa-glass-martini-alt:before {\n content: \"\\f57b\"; }\n\n.fa-glass-whiskey:before {\n content: \"\\f7a0\"; }\n\n.fa-glasses:before {\n content: \"\\f530\"; }\n\n.fa-glide:before {\n content: \"\\f2a5\"; }\n\n.fa-glide-g:before {\n content: \"\\f2a6\"; }\n\n.fa-globe:before {\n content: \"\\f0ac\"; }\n\n.fa-globe-africa:before {\n content: \"\\f57c\"; }\n\n.fa-globe-americas:before {\n content: \"\\f57d\"; }\n\n.fa-globe-asia:before {\n content: \"\\f57e\"; }\n\n.fa-globe-europe:before {\n content: \"\\f7a2\"; }\n\n.fa-gofore:before {\n content: \"\\f3a7\"; }\n\n.fa-golf-ball:before {\n content: \"\\f450\"; }\n\n.fa-goodreads:before {\n content: \"\\f3a8\"; }\n\n.fa-goodreads-g:before {\n content: \"\\f3a9\"; }\n\n.fa-google:before {\n content: \"\\f1a0\"; }\n\n.fa-google-drive:before {\n content: \"\\f3aa\"; }\n\n.fa-google-pay:before {\n content: \"\\e079\"; }\n\n.fa-google-play:before {\n content: \"\\f3ab\"; }\n\n.fa-google-plus:before {\n content: \"\\f2b3\"; }\n\n.fa-google-plus-g:before {\n content: \"\\f0d5\"; }\n\n.fa-google-plus-square:before {\n content: \"\\f0d4\"; }\n\n.fa-google-wallet:before {\n content: \"\\f1ee\"; }\n\n.fa-gopuram:before {\n content: \"\\f664\"; }\n\n.fa-graduation-cap:before {\n content: \"\\f19d\"; }\n\n.fa-gratipay:before {\n content: \"\\f184\"; }\n\n.fa-grav:before {\n content: \"\\f2d6\"; }\n\n.fa-greater-than:before {\n content: \"\\f531\"; }\n\n.fa-greater-than-equal:before {\n content: \"\\f532\"; }\n\n.fa-grimace:before {\n content: \"\\f57f\"; }\n\n.fa-grin:before {\n content: \"\\f580\"; }\n\n.fa-grin-alt:before {\n content: \"\\f581\"; }\n\n.fa-grin-beam:before {\n content: \"\\f582\"; }\n\n.fa-grin-beam-sweat:before {\n content: \"\\f583\"; }\n\n.fa-grin-hearts:before {\n content: \"\\f584\"; }\n\n.fa-grin-squint:before {\n content: \"\\f585\"; }\n\n.fa-grin-squint-tears:before {\n content: \"\\f586\"; }\n\n.fa-grin-stars:before {\n content: \"\\f587\"; }\n\n.fa-grin-tears:before {\n content: \"\\f588\"; }\n\n.fa-grin-tongue:before {\n content: \"\\f589\"; }\n\n.fa-grin-tongue-squint:before {\n content: \"\\f58a\"; }\n\n.fa-grin-tongue-wink:before {\n content: \"\\f58b\"; }\n\n.fa-grin-wink:before {\n content: \"\\f58c\"; }\n\n.fa-grip-horizontal:before {\n content: \"\\f58d\"; }\n\n.fa-grip-lines:before {\n content: \"\\f7a4\"; }\n\n.fa-grip-lines-vertical:before {\n content: \"\\f7a5\"; }\n\n.fa-grip-vertical:before {\n content: \"\\f58e\"; }\n\n.fa-gripfire:before {\n content: \"\\f3ac\"; }\n\n.fa-grunt:before {\n content: \"\\f3ad\"; }\n\n.fa-guilded:before {\n content: \"\\e07e\"; }\n\n.fa-guitar:before {\n content: \"\\f7a6\"; }\n\n.fa-gulp:before {\n content: \"\\f3ae\"; }\n\n.fa-h-square:before {\n content: \"\\f0fd\"; }\n\n.fa-hacker-news:before {\n content: \"\\f1d4\"; }\n\n.fa-hacker-news-square:before {\n content: \"\\f3af\"; }\n\n.fa-hackerrank:before {\n content: \"\\f5f7\"; }\n\n.fa-hamburger:before {\n content: \"\\f805\"; }\n\n.fa-hammer:before {\n content: \"\\f6e3\"; }\n\n.fa-hamsa:before {\n content: \"\\f665\"; }\n\n.fa-hand-holding:before {\n content: \"\\f4bd\"; }\n\n.fa-hand-holding-heart:before {\n content: \"\\f4be\"; }\n\n.fa-hand-holding-medical:before {\n content: \"\\e05c\"; }\n\n.fa-hand-holding-usd:before {\n content: \"\\f4c0\"; }\n\n.fa-hand-holding-water:before {\n content: \"\\f4c1\"; }\n\n.fa-hand-lizard:before {\n content: \"\\f258\"; }\n\n.fa-hand-middle-finger:before {\n content: \"\\f806\"; }\n\n.fa-hand-paper:before {\n content: \"\\f256\"; }\n\n.fa-hand-peace:before {\n content: \"\\f25b\"; }\n\n.fa-hand-point-down:before {\n content: \"\\f0a7\"; }\n\n.fa-hand-point-left:before {\n content: \"\\f0a5\"; }\n\n.fa-hand-point-right:before {\n content: \"\\f0a4\"; }\n\n.fa-hand-point-up:before {\n content: \"\\f0a6\"; }\n\n.fa-hand-pointer:before {\n content: \"\\f25a\"; }\n\n.fa-hand-rock:before {\n content: \"\\f255\"; }\n\n.fa-hand-scissors:before {\n content: \"\\f257\"; }\n\n.fa-hand-sparkles:before {\n content: \"\\e05d\"; }\n\n.fa-hand-spock:before {\n content: \"\\f259\"; }\n\n.fa-hands:before {\n content: \"\\f4c2\"; }\n\n.fa-hands-helping:before {\n content: \"\\f4c4\"; }\n\n.fa-hands-wash:before {\n content: \"\\e05e\"; }\n\n.fa-handshake:before {\n content: \"\\f2b5\"; }\n\n.fa-handshake-alt-slash:before {\n content: \"\\e05f\"; }\n\n.fa-handshake-slash:before {\n content: \"\\e060\"; }\n\n.fa-hanukiah:before {\n content: \"\\f6e6\"; }\n\n.fa-hard-hat:before {\n content: \"\\f807\"; }\n\n.fa-hashtag:before {\n content: \"\\f292\"; }\n\n.fa-hat-cowboy:before {\n content: \"\\f8c0\"; }\n\n.fa-hat-cowboy-side:before {\n content: \"\\f8c1\"; }\n\n.fa-hat-wizard:before {\n content: \"\\f6e8\"; }\n\n.fa-hdd:before {\n content: \"\\f0a0\"; }\n\n.fa-head-side-cough:before {\n content: \"\\e061\"; }\n\n.fa-head-side-cough-slash:before {\n content: \"\\e062\"; }\n\n.fa-head-side-mask:before {\n content: \"\\e063\"; }\n\n.fa-head-side-virus:before {\n content: \"\\e064\"; }\n\n.fa-heading:before {\n content: \"\\f1dc\"; }\n\n.fa-headphones:before {\n content: \"\\f025\"; }\n\n.fa-headphones-alt:before {\n content: \"\\f58f\"; }\n\n.fa-headset:before {\n content: \"\\f590\"; }\n\n.fa-heart:before {\n content: \"\\f004\"; }\n\n.fa-heart-broken:before {\n content: \"\\f7a9\"; }\n\n.fa-heartbeat:before {\n content: \"\\f21e\"; }\n\n.fa-helicopter:before {\n content: \"\\f533\"; }\n\n.fa-highlighter:before {\n content: \"\\f591\"; }\n\n.fa-hiking:before {\n content: \"\\f6ec\"; }\n\n.fa-hippo:before {\n content: \"\\f6ed\"; }\n\n.fa-hips:before {\n content: \"\\f452\"; }\n\n.fa-hire-a-helper:before {\n content: \"\\f3b0\"; }\n\n.fa-history:before {\n content: \"\\f1da\"; }\n\n.fa-hive:before {\n content: \"\\e07f\"; }\n\n.fa-hockey-puck:before {\n content: \"\\f453\"; }\n\n.fa-holly-berry:before {\n content: \"\\f7aa\"; }\n\n.fa-home:before {\n content: \"\\f015\"; }\n\n.fa-hooli:before {\n content: \"\\f427\"; }\n\n.fa-hornbill:before {\n content: \"\\f592\"; }\n\n.fa-horse:before {\n content: \"\\f6f0\"; }\n\n.fa-horse-head:before {\n content: \"\\f7ab\"; }\n\n.fa-hospital:before {\n content: \"\\f0f8\"; }\n\n.fa-hospital-alt:before {\n content: \"\\f47d\"; }\n\n.fa-hospital-symbol:before {\n content: \"\\f47e\"; }\n\n.fa-hospital-user:before {\n content: \"\\f80d\"; }\n\n.fa-hot-tub:before {\n content: \"\\f593\"; }\n\n.fa-hotdog:before {\n content: \"\\f80f\"; }\n\n.fa-hotel:before {\n content: \"\\f594\"; }\n\n.fa-hotjar:before {\n content: \"\\f3b1\"; }\n\n.fa-hourglass:before {\n content: \"\\f254\"; }\n\n.fa-hourglass-end:before {\n content: \"\\f253\"; }\n\n.fa-hourglass-half:before {\n content: \"\\f252\"; }\n\n.fa-hourglass-start:before {\n content: \"\\f251\"; }\n\n.fa-house-damage:before {\n content: \"\\f6f1\"; }\n\n.fa-house-user:before {\n content: \"\\e065\"; }\n\n.fa-houzz:before {\n content: \"\\f27c\"; }\n\n.fa-hryvnia:before {\n content: \"\\f6f2\"; }\n\n.fa-html5:before {\n content: \"\\f13b\"; }\n\n.fa-hubspot:before {\n content: \"\\f3b2\"; }\n\n.fa-i-cursor:before {\n content: \"\\f246\"; }\n\n.fa-ice-cream:before {\n content: \"\\f810\"; }\n\n.fa-icicles:before {\n content: \"\\f7ad\"; }\n\n.fa-icons:before {\n content: \"\\f86d\"; }\n\n.fa-id-badge:before {\n content: \"\\f2c1\"; }\n\n.fa-id-card:before {\n content: \"\\f2c2\"; }\n\n.fa-id-card-alt:before {\n content: \"\\f47f\"; }\n\n.fa-ideal:before {\n content: \"\\e013\"; }\n\n.fa-igloo:before {\n content: \"\\f7ae\"; }\n\n.fa-image:before {\n content: \"\\f03e\"; }\n\n.fa-images:before {\n content: \"\\f302\"; }\n\n.fa-imdb:before {\n content: \"\\f2d8\"; }\n\n.fa-inbox:before {\n content: \"\\f01c\"; }\n\n.fa-indent:before {\n content: \"\\f03c\"; }\n\n.fa-industry:before {\n content: \"\\f275\"; }\n\n.fa-infinity:before {\n content: \"\\f534\"; }\n\n.fa-info:before {\n content: \"\\f129\"; }\n\n.fa-info-circle:before {\n content: \"\\f05a\"; }\n\n.fa-innosoft:before {\n content: \"\\e080\"; }\n\n.fa-instagram:before {\n content: \"\\f16d\"; }\n\n.fa-instagram-square:before {\n content: \"\\e055\"; }\n\n.fa-instalod:before {\n content: \"\\e081\"; }\n\n.fa-intercom:before {\n content: \"\\f7af\"; }\n\n.fa-internet-explorer:before {\n content: \"\\f26b\"; }\n\n.fa-invision:before {\n content: \"\\f7b0\"; }\n\n.fa-ioxhost:before {\n content: \"\\f208\"; }\n\n.fa-italic:before {\n content: \"\\f033\"; }\n\n.fa-itch-io:before {\n content: \"\\f83a\"; }\n\n.fa-itunes:before {\n content: \"\\f3b4\"; }\n\n.fa-itunes-note:before {\n content: \"\\f3b5\"; }\n\n.fa-java:before {\n content: \"\\f4e4\"; }\n\n.fa-jedi:before {\n content: \"\\f669\"; }\n\n.fa-jedi-order:before {\n content: \"\\f50e\"; }\n\n.fa-jenkins:before {\n content: \"\\f3b6\"; }\n\n.fa-jira:before {\n content: \"\\f7b1\"; }\n\n.fa-joget:before {\n content: \"\\f3b7\"; }\n\n.fa-joint:before {\n content: \"\\f595\"; }\n\n.fa-joomla:before {\n content: \"\\f1aa\"; }\n\n.fa-journal-whills:before {\n content: \"\\f66a\"; }\n\n.fa-js:before {\n content: \"\\f3b8\"; }\n\n.fa-js-square:before {\n content: \"\\f3b9\"; }\n\n.fa-jsfiddle:before {\n content: \"\\f1cc\"; }\n\n.fa-kaaba:before {\n content: \"\\f66b\"; }\n\n.fa-kaggle:before {\n content: \"\\f5fa\"; }\n\n.fa-key:before {\n content: \"\\f084\"; }\n\n.fa-keybase:before {\n content: \"\\f4f5\"; }\n\n.fa-keyboard:before {\n content: \"\\f11c\"; }\n\n.fa-keycdn:before {\n content: \"\\f3ba\"; }\n\n.fa-khanda:before {\n content: \"\\f66d\"; }\n\n.fa-kickstarter:before {\n content: \"\\f3bb\"; }\n\n.fa-kickstarter-k:before {\n content: \"\\f3bc\"; }\n\n.fa-kiss:before {\n content: \"\\f596\"; }\n\n.fa-kiss-beam:before {\n content: \"\\f597\"; }\n\n.fa-kiss-wink-heart:before {\n content: \"\\f598\"; }\n\n.fa-kiwi-bird:before {\n content: \"\\f535\"; }\n\n.fa-korvue:before {\n content: \"\\f42f\"; }\n\n.fa-landmark:before {\n content: \"\\f66f\"; }\n\n.fa-language:before {\n content: \"\\f1ab\"; }\n\n.fa-laptop:before {\n content: \"\\f109\"; }\n\n.fa-laptop-code:before {\n content: \"\\f5fc\"; }\n\n.fa-laptop-house:before {\n content: \"\\e066\"; }\n\n.fa-laptop-medical:before {\n content: \"\\f812\"; }\n\n.fa-laravel:before {\n content: \"\\f3bd\"; }\n\n.fa-lastfm:before {\n content: \"\\f202\"; }\n\n.fa-lastfm-square:before {\n content: \"\\f203\"; }\n\n.fa-laugh:before {\n content: \"\\f599\"; }\n\n.fa-laugh-beam:before {\n content: \"\\f59a\"; }\n\n.fa-laugh-squint:before {\n content: \"\\f59b\"; }\n\n.fa-laugh-wink:before {\n content: \"\\f59c\"; }\n\n.fa-layer-group:before {\n content: \"\\f5fd\"; }\n\n.fa-leaf:before {\n content: \"\\f06c\"; }\n\n.fa-leanpub:before {\n content: \"\\f212\"; }\n\n.fa-lemon:before {\n content: \"\\f094\"; }\n\n.fa-less:before {\n content: \"\\f41d\"; }\n\n.fa-less-than:before {\n content: \"\\f536\"; }\n\n.fa-less-than-equal:before {\n content: \"\\f537\"; }\n\n.fa-level-down-alt:before {\n content: \"\\f3be\"; }\n\n.fa-level-up-alt:before {\n content: \"\\f3bf\"; }\n\n.fa-life-ring:before {\n content: \"\\f1cd\"; }\n\n.fa-lightbulb:before {\n content: \"\\f0eb\"; }\n\n.fa-line:before {\n content: \"\\f3c0\"; }\n\n.fa-link:before {\n content: \"\\f0c1\"; }\n\n.fa-linkedin:before {\n content: \"\\f08c\"; }\n\n.fa-linkedin-in:before {\n content: \"\\f0e1\"; }\n\n.fa-linode:before {\n content: \"\\f2b8\"; }\n\n.fa-linux:before {\n content: \"\\f17c\"; }\n\n.fa-lira-sign:before {\n content: \"\\f195\"; }\n\n.fa-list:before {\n content: \"\\f03a\"; }\n\n.fa-list-alt:before {\n content: \"\\f022\"; }\n\n.fa-list-ol:before {\n content: \"\\f0cb\"; }\n\n.fa-list-ul:before {\n content: \"\\f0ca\"; }\n\n.fa-location-arrow:before {\n content: \"\\f124\"; }\n\n.fa-lock:before {\n content: \"\\f023\"; }\n\n.fa-lock-open:before {\n content: \"\\f3c1\"; }\n\n.fa-long-arrow-alt-down:before {\n content: \"\\f309\"; }\n\n.fa-long-arrow-alt-left:before {\n content: \"\\f30a\"; }\n\n.fa-long-arrow-alt-right:before {\n content: \"\\f30b\"; }\n\n.fa-long-arrow-alt-up:before {\n content: \"\\f30c\"; }\n\n.fa-low-vision:before {\n content: \"\\f2a8\"; }\n\n.fa-luggage-cart:before {\n content: \"\\f59d\"; }\n\n.fa-lungs:before {\n content: \"\\f604\"; }\n\n.fa-lungs-virus:before {\n content: \"\\e067\"; }\n\n.fa-lyft:before {\n content: \"\\f3c3\"; }\n\n.fa-magento:before {\n content: \"\\f3c4\"; }\n\n.fa-magic:before {\n content: \"\\f0d0\"; }\n\n.fa-magnet:before {\n content: \"\\f076\"; }\n\n.fa-mail-bulk:before {\n content: \"\\f674\"; }\n\n.fa-mailchimp:before {\n content: \"\\f59e\"; }\n\n.fa-male:before {\n content: \"\\f183\"; }\n\n.fa-mandalorian:before {\n content: \"\\f50f\"; }\n\n.fa-map:before {\n content: \"\\f279\"; }\n\n.fa-map-marked:before {\n content: \"\\f59f\"; }\n\n.fa-map-marked-alt:before {\n content: \"\\f5a0\"; }\n\n.fa-map-marker:before {\n content: \"\\f041\"; }\n\n.fa-map-marker-alt:before {\n content: \"\\f3c5\"; }\n\n.fa-map-pin:before {\n content: \"\\f276\"; }\n\n.fa-map-signs:before {\n content: \"\\f277\"; }\n\n.fa-markdown:before {\n content: \"\\f60f\"; }\n\n.fa-marker:before {\n content: \"\\f5a1\"; }\n\n.fa-mars:before {\n content: \"\\f222\"; }\n\n.fa-mars-double:before {\n content: \"\\f227\"; }\n\n.fa-mars-stroke:before {\n content: \"\\f229\"; }\n\n.fa-mars-stroke-h:before {\n content: \"\\f22b\"; }\n\n.fa-mars-stroke-v:before {\n content: \"\\f22a\"; }\n\n.fa-mask:before {\n content: \"\\f6fa\"; }\n\n.fa-mastodon:before {\n content: \"\\f4f6\"; }\n\n.fa-maxcdn:before {\n content: \"\\f136\"; }\n\n.fa-mdb:before {\n content: \"\\f8ca\"; }\n\n.fa-medal:before {\n content: \"\\f5a2\"; }\n\n.fa-medapps:before {\n content: \"\\f3c6\"; }\n\n.fa-medium:before {\n content: \"\\f23a\"; }\n\n.fa-medium-m:before {\n content: \"\\f3c7\"; }\n\n.fa-medkit:before {\n content: \"\\f0fa\"; }\n\n.fa-medrt:before {\n content: \"\\f3c8\"; }\n\n.fa-meetup:before {\n content: \"\\f2e0\"; }\n\n.fa-megaport:before {\n content: \"\\f5a3\"; }\n\n.fa-meh:before {\n content: \"\\f11a\"; }\n\n.fa-meh-blank:before {\n content: \"\\f5a4\"; }\n\n.fa-meh-rolling-eyes:before {\n content: \"\\f5a5\"; }\n\n.fa-memory:before {\n content: \"\\f538\"; }\n\n.fa-mendeley:before {\n content: \"\\f7b3\"; }\n\n.fa-menorah:before {\n content: \"\\f676\"; }\n\n.fa-mercury:before {\n content: \"\\f223\"; }\n\n.fa-meteor:before {\n content: \"\\f753\"; }\n\n.fa-microblog:before {\n content: \"\\e01a\"; }\n\n.fa-microchip:before {\n content: \"\\f2db\"; }\n\n.fa-microphone:before {\n content: \"\\f130\"; }\n\n.fa-microphone-alt:before {\n content: \"\\f3c9\"; }\n\n.fa-microphone-alt-slash:before {\n content: \"\\f539\"; }\n\n.fa-microphone-slash:before {\n content: \"\\f131\"; }\n\n.fa-microscope:before {\n content: \"\\f610\"; }\n\n.fa-microsoft:before {\n content: \"\\f3ca\"; }\n\n.fa-minus:before {\n content: \"\\f068\"; }\n\n.fa-minus-circle:before {\n content: \"\\f056\"; }\n\n.fa-minus-square:before {\n content: \"\\f146\"; }\n\n.fa-mitten:before {\n content: \"\\f7b5\"; }\n\n.fa-mix:before {\n content: \"\\f3cb\"; }\n\n.fa-mixcloud:before {\n content: \"\\f289\"; }\n\n.fa-mixer:before {\n content: \"\\e056\"; }\n\n.fa-mizuni:before {\n content: \"\\f3cc\"; }\n\n.fa-mobile:before {\n content: \"\\f10b\"; }\n\n.fa-mobile-alt:before {\n content: \"\\f3cd\"; }\n\n.fa-modx:before {\n content: \"\\f285\"; }\n\n.fa-monero:before {\n content: \"\\f3d0\"; }\n\n.fa-money-bill:before {\n content: \"\\f0d6\"; }\n\n.fa-money-bill-alt:before {\n content: \"\\f3d1\"; }\n\n.fa-money-bill-wave:before {\n content: \"\\f53a\"; }\n\n.fa-money-bill-wave-alt:before {\n content: \"\\f53b\"; }\n\n.fa-money-check:before {\n content: \"\\f53c\"; }\n\n.fa-money-check-alt:before {\n content: \"\\f53d\"; }\n\n.fa-monument:before {\n content: \"\\f5a6\"; }\n\n.fa-moon:before {\n content: \"\\f186\"; }\n\n.fa-mortar-pestle:before {\n content: \"\\f5a7\"; }\n\n.fa-mosque:before {\n content: \"\\f678\"; }\n\n.fa-motorcycle:before {\n content: \"\\f21c\"; }\n\n.fa-mountain:before {\n content: \"\\f6fc\"; }\n\n.fa-mouse:before {\n content: \"\\f8cc\"; }\n\n.fa-mouse-pointer:before {\n content: \"\\f245\"; }\n\n.fa-mug-hot:before {\n content: \"\\f7b6\"; }\n\n.fa-music:before {\n content: \"\\f001\"; }\n\n.fa-napster:before {\n content: \"\\f3d2\"; }\n\n.fa-neos:before {\n content: \"\\f612\"; }\n\n.fa-network-wired:before {\n content: \"\\f6ff\"; }\n\n.fa-neuter:before {\n content: \"\\f22c\"; }\n\n.fa-newspaper:before {\n content: \"\\f1ea\"; }\n\n.fa-nimblr:before {\n content: \"\\f5a8\"; }\n\n.fa-node:before {\n content: \"\\f419\"; }\n\n.fa-node-js:before {\n content: \"\\f3d3\"; }\n\n.fa-not-equal:before {\n content: \"\\f53e\"; }\n\n.fa-notes-medical:before {\n content: \"\\f481\"; }\n\n.fa-npm:before {\n content: \"\\f3d4\"; }\n\n.fa-ns8:before {\n content: \"\\f3d5\"; }\n\n.fa-nutritionix:before {\n content: \"\\f3d6\"; }\n\n.fa-object-group:before {\n content: \"\\f247\"; }\n\n.fa-object-ungroup:before {\n content: \"\\f248\"; }\n\n.fa-octopus-deploy:before {\n content: \"\\e082\"; }\n\n.fa-odnoklassniki:before {\n content: \"\\f263\"; }\n\n.fa-odnoklassniki-square:before {\n content: \"\\f264\"; }\n\n.fa-oil-can:before {\n content: \"\\f613\"; }\n\n.fa-old-republic:before {\n content: \"\\f510\"; }\n\n.fa-om:before {\n content: \"\\f679\"; }\n\n.fa-opencart:before {\n content: \"\\f23d\"; }\n\n.fa-openid:before {\n content: \"\\f19b\"; }\n\n.fa-opera:before {\n content: \"\\f26a\"; }\n\n.fa-optin-monster:before {\n content: \"\\f23c\"; }\n\n.fa-orcid:before {\n content: \"\\f8d2\"; }\n\n.fa-osi:before {\n content: \"\\f41a\"; }\n\n.fa-otter:before {\n content: \"\\f700\"; }\n\n.fa-outdent:before {\n content: \"\\f03b\"; }\n\n.fa-page4:before {\n content: \"\\f3d7\"; }\n\n.fa-pagelines:before {\n content: \"\\f18c\"; }\n\n.fa-pager:before {\n content: \"\\f815\"; }\n\n.fa-paint-brush:before {\n content: \"\\f1fc\"; }\n\n.fa-paint-roller:before {\n content: \"\\f5aa\"; }\n\n.fa-palette:before {\n content: \"\\f53f\"; }\n\n.fa-palfed:before {\n content: \"\\f3d8\"; }\n\n.fa-pallet:before {\n content: \"\\f482\"; }\n\n.fa-paper-plane:before {\n content: \"\\f1d8\"; }\n\n.fa-paperclip:before {\n content: \"\\f0c6\"; }\n\n.fa-parachute-box:before {\n content: \"\\f4cd\"; }\n\n.fa-paragraph:before {\n content: \"\\f1dd\"; }\n\n.fa-parking:before {\n content: \"\\f540\"; }\n\n.fa-passport:before {\n content: \"\\f5ab\"; }\n\n.fa-pastafarianism:before {\n content: \"\\f67b\"; }\n\n.fa-paste:before {\n content: \"\\f0ea\"; }\n\n.fa-patreon:before {\n content: \"\\f3d9\"; }\n\n.fa-pause:before {\n content: \"\\f04c\"; }\n\n.fa-pause-circle:before {\n content: \"\\f28b\"; }\n\n.fa-paw:before {\n content: \"\\f1b0\"; }\n\n.fa-paypal:before {\n content: \"\\f1ed\"; }\n\n.fa-peace:before {\n content: \"\\f67c\"; }\n\n.fa-pen:before {\n content: \"\\f304\"; }\n\n.fa-pen-alt:before {\n content: \"\\f305\"; }\n\n.fa-pen-fancy:before {\n content: \"\\f5ac\"; }\n\n.fa-pen-nib:before {\n content: \"\\f5ad\"; }\n\n.fa-pen-square:before {\n content: \"\\f14b\"; }\n\n.fa-pencil-alt:before {\n content: \"\\f303\"; }\n\n.fa-pencil-ruler:before {\n content: \"\\f5ae\"; }\n\n.fa-penny-arcade:before {\n content: \"\\f704\"; }\n\n.fa-people-arrows:before {\n content: \"\\e068\"; }\n\n.fa-people-carry:before {\n content: \"\\f4ce\"; }\n\n.fa-pepper-hot:before {\n content: \"\\f816\"; }\n\n.fa-perbyte:before {\n content: \"\\e083\"; }\n\n.fa-percent:before {\n content: \"\\f295\"; }\n\n.fa-percentage:before {\n content: \"\\f541\"; }\n\n.fa-periscope:before {\n content: \"\\f3da\"; }\n\n.fa-person-booth:before {\n content: \"\\f756\"; }\n\n.fa-phabricator:before {\n content: \"\\f3db\"; }\n\n.fa-phoenix-framework:before {\n content: \"\\f3dc\"; }\n\n.fa-phoenix-squadron:before {\n content: \"\\f511\"; }\n\n.fa-phone:before {\n content: \"\\f095\"; }\n\n.fa-phone-alt:before {\n content: \"\\f879\"; }\n\n.fa-phone-slash:before {\n content: \"\\f3dd\"; }\n\n.fa-phone-square:before {\n content: \"\\f098\"; }\n\n.fa-phone-square-alt:before {\n content: \"\\f87b\"; }\n\n.fa-phone-volume:before {\n content: \"\\f2a0\"; }\n\n.fa-photo-video:before {\n content: \"\\f87c\"; }\n\n.fa-php:before {\n content: \"\\f457\"; }\n\n.fa-pied-piper:before {\n content: \"\\f2ae\"; }\n\n.fa-pied-piper-alt:before {\n content: \"\\f1a8\"; }\n\n.fa-pied-piper-hat:before {\n content: \"\\f4e5\"; }\n\n.fa-pied-piper-pp:before {\n content: \"\\f1a7\"; }\n\n.fa-pied-piper-square:before {\n content: \"\\e01e\"; }\n\n.fa-piggy-bank:before {\n content: \"\\f4d3\"; }\n\n.fa-pills:before {\n content: \"\\f484\"; }\n\n.fa-pinterest:before {\n content: \"\\f0d2\"; }\n\n.fa-pinterest-p:before {\n content: \"\\f231\"; }\n\n.fa-pinterest-square:before {\n content: \"\\f0d3\"; }\n\n.fa-pizza-slice:before {\n content: \"\\f818\"; }\n\n.fa-place-of-worship:before {\n content: \"\\f67f\"; }\n\n.fa-plane:before {\n content: \"\\f072\"; }\n\n.fa-plane-arrival:before {\n content: \"\\f5af\"; }\n\n.fa-plane-departure:before {\n content: \"\\f5b0\"; }\n\n.fa-plane-slash:before {\n content: \"\\e069\"; }\n\n.fa-play:before {\n content: \"\\f04b\"; }\n\n.fa-play-circle:before {\n content: \"\\f144\"; }\n\n.fa-playstation:before {\n content: \"\\f3df\"; }\n\n.fa-plug:before {\n content: \"\\f1e6\"; }\n\n.fa-plus:before {\n content: \"\\f067\"; }\n\n.fa-plus-circle:before {\n content: \"\\f055\"; }\n\n.fa-plus-square:before {\n content: \"\\f0fe\"; }\n\n.fa-podcast:before {\n content: \"\\f2ce\"; }\n\n.fa-poll:before {\n content: \"\\f681\"; }\n\n.fa-poll-h:before {\n content: \"\\f682\"; }\n\n.fa-poo:before {\n content: \"\\f2fe\"; }\n\n.fa-poo-storm:before {\n content: \"\\f75a\"; }\n\n.fa-poop:before {\n content: \"\\f619\"; }\n\n.fa-portrait:before {\n content: \"\\f3e0\"; }\n\n.fa-pound-sign:before {\n content: \"\\f154\"; }\n\n.fa-power-off:before {\n content: \"\\f011\"; }\n\n.fa-pray:before {\n content: \"\\f683\"; }\n\n.fa-praying-hands:before {\n content: \"\\f684\"; }\n\n.fa-prescription:before {\n content: \"\\f5b1\"; }\n\n.fa-prescription-bottle:before {\n content: \"\\f485\"; }\n\n.fa-prescription-bottle-alt:before {\n content: \"\\f486\"; }\n\n.fa-print:before {\n content: \"\\f02f\"; }\n\n.fa-procedures:before {\n content: \"\\f487\"; }\n\n.fa-product-hunt:before {\n content: \"\\f288\"; }\n\n.fa-project-diagram:before {\n content: \"\\f542\"; }\n\n.fa-pump-medical:before {\n content: \"\\e06a\"; }\n\n.fa-pump-soap:before {\n content: \"\\e06b\"; }\n\n.fa-pushed:before {\n content: \"\\f3e1\"; }\n\n.fa-puzzle-piece:before {\n content: \"\\f12e\"; }\n\n.fa-python:before {\n content: \"\\f3e2\"; }\n\n.fa-qq:before {\n content: \"\\f1d6\"; }\n\n.fa-qrcode:before {\n content: \"\\f029\"; }\n\n.fa-question:before {\n content: \"\\f128\"; }\n\n.fa-question-circle:before {\n content: \"\\f059\"; }\n\n.fa-quidditch:before {\n content: \"\\f458\"; }\n\n.fa-quinscape:before {\n content: \"\\f459\"; }\n\n.fa-quora:before {\n content: \"\\f2c4\"; }\n\n.fa-quote-left:before {\n content: \"\\f10d\"; }\n\n.fa-quote-right:before {\n content: \"\\f10e\"; }\n\n.fa-quran:before {\n content: \"\\f687\"; }\n\n.fa-r-project:before {\n content: \"\\f4f7\"; }\n\n.fa-radiation:before {\n content: \"\\f7b9\"; }\n\n.fa-radiation-alt:before {\n content: \"\\f7ba\"; }\n\n.fa-rainbow:before {\n content: \"\\f75b\"; }\n\n.fa-random:before {\n content: \"\\f074\"; }\n\n.fa-raspberry-pi:before {\n content: \"\\f7bb\"; }\n\n.fa-ravelry:before {\n content: \"\\f2d9\"; }\n\n.fa-react:before {\n content: \"\\f41b\"; }\n\n.fa-reacteurope:before {\n content: \"\\f75d\"; }\n\n.fa-readme:before {\n content: \"\\f4d5\"; }\n\n.fa-rebel:before {\n content: \"\\f1d0\"; }\n\n.fa-receipt:before {\n content: \"\\f543\"; }\n\n.fa-record-vinyl:before {\n content: \"\\f8d9\"; }\n\n.fa-recycle:before {\n content: \"\\f1b8\"; }\n\n.fa-red-river:before {\n content: \"\\f3e3\"; }\n\n.fa-reddit:before {\n content: \"\\f1a1\"; }\n\n.fa-reddit-alien:before {\n content: \"\\f281\"; }\n\n.fa-reddit-square:before {\n content: \"\\f1a2\"; }\n\n.fa-redhat:before {\n content: \"\\f7bc\"; }\n\n.fa-redo:before {\n content: \"\\f01e\"; }\n\n.fa-redo-alt:before {\n content: \"\\f2f9\"; }\n\n.fa-registered:before {\n content: \"\\f25d\"; }\n\n.fa-remove-format:before {\n content: \"\\f87d\"; }\n\n.fa-renren:before {\n content: \"\\f18b\"; }\n\n.fa-reply:before {\n content: \"\\f3e5\"; }\n\n.fa-reply-all:before {\n content: \"\\f122\"; }\n\n.fa-replyd:before {\n content: \"\\f3e6\"; }\n\n.fa-republican:before {\n content: \"\\f75e\"; }\n\n.fa-researchgate:before {\n content: \"\\f4f8\"; }\n\n.fa-resolving:before {\n content: \"\\f3e7\"; }\n\n.fa-restroom:before {\n content: \"\\f7bd\"; }\n\n.fa-retweet:before {\n content: \"\\f079\"; }\n\n.fa-rev:before {\n content: \"\\f5b2\"; }\n\n.fa-ribbon:before {\n content: \"\\f4d6\"; }\n\n.fa-ring:before {\n content: \"\\f70b\"; }\n\n.fa-road:before {\n content: \"\\f018\"; }\n\n.fa-robot:before {\n content: \"\\f544\"; }\n\n.fa-rocket:before {\n content: \"\\f135\"; }\n\n.fa-rocketchat:before {\n content: \"\\f3e8\"; }\n\n.fa-rockrms:before {\n content: \"\\f3e9\"; }\n\n.fa-route:before {\n content: \"\\f4d7\"; }\n\n.fa-rss:before {\n content: \"\\f09e\"; }\n\n.fa-rss-square:before {\n content: \"\\f143\"; }\n\n.fa-ruble-sign:before {\n content: \"\\f158\"; }\n\n.fa-ruler:before {\n content: \"\\f545\"; }\n\n.fa-ruler-combined:before {\n content: \"\\f546\"; }\n\n.fa-ruler-horizontal:before {\n content: \"\\f547\"; }\n\n.fa-ruler-vertical:before {\n content: \"\\f548\"; }\n\n.fa-running:before {\n content: \"\\f70c\"; }\n\n.fa-rupee-sign:before {\n content: \"\\f156\"; }\n\n.fa-rust:before {\n content: \"\\e07a\"; }\n\n.fa-sad-cry:before {\n content: \"\\f5b3\"; }\n\n.fa-sad-tear:before {\n content: \"\\f5b4\"; }\n\n.fa-safari:before {\n content: \"\\f267\"; }\n\n.fa-salesforce:before {\n content: \"\\f83b\"; }\n\n.fa-sass:before {\n content: \"\\f41e\"; }\n\n.fa-satellite:before {\n content: \"\\f7bf\"; }\n\n.fa-satellite-dish:before {\n content: \"\\f7c0\"; }\n\n.fa-save:before {\n content: \"\\f0c7\"; }\n\n.fa-schlix:before {\n content: \"\\f3ea\"; }\n\n.fa-school:before {\n content: \"\\f549\"; }\n\n.fa-screwdriver:before {\n content: \"\\f54a\"; }\n\n.fa-scribd:before {\n content: \"\\f28a\"; }\n\n.fa-scroll:before {\n content: \"\\f70e\"; }\n\n.fa-sd-card:before {\n content: \"\\f7c2\"; }\n\n.fa-search:before {\n content: \"\\f002\"; }\n\n.fa-search-dollar:before {\n content: \"\\f688\"; }\n\n.fa-search-location:before {\n content: \"\\f689\"; }\n\n.fa-search-minus:before {\n content: \"\\f010\"; }\n\n.fa-search-plus:before {\n content: \"\\f00e\"; }\n\n.fa-searchengin:before {\n content: \"\\f3eb\"; }\n\n.fa-seedling:before {\n content: \"\\f4d8\"; }\n\n.fa-sellcast:before {\n content: \"\\f2da\"; }\n\n.fa-sellsy:before {\n content: \"\\f213\"; }\n\n.fa-server:before {\n content: \"\\f233\"; }\n\n.fa-servicestack:before {\n content: \"\\f3ec\"; }\n\n.fa-shapes:before {\n content: \"\\f61f\"; }\n\n.fa-share:before {\n content: \"\\f064\"; }\n\n.fa-share-alt:before {\n content: \"\\f1e0\"; }\n\n.fa-share-alt-square:before {\n content: \"\\f1e1\"; }\n\n.fa-share-square:before {\n content: \"\\f14d\"; }\n\n.fa-shekel-sign:before {\n content: \"\\f20b\"; }\n\n.fa-shield-alt:before {\n content: \"\\f3ed\"; }\n\n.fa-shield-virus:before {\n content: \"\\e06c\"; }\n\n.fa-ship:before {\n content: \"\\f21a\"; }\n\n.fa-shipping-fast:before {\n content: \"\\f48b\"; }\n\n.fa-shirtsinbulk:before {\n content: \"\\f214\"; }\n\n.fa-shoe-prints:before {\n content: \"\\f54b\"; }\n\n.fa-shopify:before {\n content: \"\\e057\"; }\n\n.fa-shopping-bag:before {\n content: \"\\f290\"; }\n\n.fa-shopping-basket:before {\n content: \"\\f291\"; }\n\n.fa-shopping-cart:before {\n content: \"\\f07a\"; }\n\n.fa-shopware:before {\n content: \"\\f5b5\"; }\n\n.fa-shower:before {\n content: \"\\f2cc\"; }\n\n.fa-shuttle-van:before {\n content: \"\\f5b6\"; }\n\n.fa-sign:before {\n content: \"\\f4d9\"; }\n\n.fa-sign-in-alt:before {\n content: \"\\f2f6\"; }\n\n.fa-sign-language:before {\n content: \"\\f2a7\"; }\n\n.fa-sign-out-alt:before {\n content: \"\\f2f5\"; }\n\n.fa-signal:before {\n content: \"\\f012\"; }\n\n.fa-signature:before {\n content: \"\\f5b7\"; }\n\n.fa-sim-card:before {\n content: \"\\f7c4\"; }\n\n.fa-simplybuilt:before {\n content: \"\\f215\"; }\n\n.fa-sink:before {\n content: \"\\e06d\"; }\n\n.fa-sistrix:before {\n content: \"\\f3ee\"; }\n\n.fa-sitemap:before {\n content: \"\\f0e8\"; }\n\n.fa-sith:before {\n content: \"\\f512\"; }\n\n.fa-skating:before {\n content: \"\\f7c5\"; }\n\n.fa-sketch:before {\n content: \"\\f7c6\"; }\n\n.fa-skiing:before {\n content: \"\\f7c9\"; }\n\n.fa-skiing-nordic:before {\n content: \"\\f7ca\"; }\n\n.fa-skull:before {\n content: \"\\f54c\"; }\n\n.fa-skull-crossbones:before {\n content: \"\\f714\"; }\n\n.fa-skyatlas:before {\n content: \"\\f216\"; }\n\n.fa-skype:before {\n content: \"\\f17e\"; }\n\n.fa-slack:before {\n content: \"\\f198\"; }\n\n.fa-slack-hash:before {\n content: \"\\f3ef\"; }\n\n.fa-slash:before {\n content: \"\\f715\"; }\n\n.fa-sleigh:before {\n content: \"\\f7cc\"; }\n\n.fa-sliders-h:before {\n content: \"\\f1de\"; }\n\n.fa-slideshare:before {\n content: \"\\f1e7\"; }\n\n.fa-smile:before {\n content: \"\\f118\"; }\n\n.fa-smile-beam:before {\n content: \"\\f5b8\"; }\n\n.fa-smile-wink:before {\n content: \"\\f4da\"; }\n\n.fa-smog:before {\n content: \"\\f75f\"; }\n\n.fa-smoking:before {\n content: \"\\f48d\"; }\n\n.fa-smoking-ban:before {\n content: \"\\f54d\"; }\n\n.fa-sms:before {\n content: \"\\f7cd\"; }\n\n.fa-snapchat:before {\n content: \"\\f2ab\"; }\n\n.fa-snapchat-ghost:before {\n content: \"\\f2ac\"; }\n\n.fa-snapchat-square:before {\n content: \"\\f2ad\"; }\n\n.fa-snowboarding:before {\n content: \"\\f7ce\"; }\n\n.fa-snowflake:before {\n content: \"\\f2dc\"; }\n\n.fa-snowman:before {\n content: \"\\f7d0\"; }\n\n.fa-snowplow:before {\n content: \"\\f7d2\"; }\n\n.fa-soap:before {\n content: \"\\e06e\"; }\n\n.fa-socks:before {\n content: \"\\f696\"; }\n\n.fa-solar-panel:before {\n content: \"\\f5ba\"; }\n\n.fa-sort:before {\n content: \"\\f0dc\"; }\n\n.fa-sort-alpha-down:before {\n content: \"\\f15d\"; }\n\n.fa-sort-alpha-down-alt:before {\n content: \"\\f881\"; }\n\n.fa-sort-alpha-up:before {\n content: \"\\f15e\"; }\n\n.fa-sort-alpha-up-alt:before {\n content: \"\\f882\"; }\n\n.fa-sort-amount-down:before {\n content: \"\\f160\"; }\n\n.fa-sort-amount-down-alt:before {\n content: \"\\f884\"; }\n\n.fa-sort-amount-up:before {\n content: \"\\f161\"; }\n\n.fa-sort-amount-up-alt:before {\n content: \"\\f885\"; }\n\n.fa-sort-down:before {\n content: \"\\f0dd\"; }\n\n.fa-sort-numeric-down:before {\n content: \"\\f162\"; }\n\n.fa-sort-numeric-down-alt:before {\n content: \"\\f886\"; }\n\n.fa-sort-numeric-up:before {\n content: \"\\f163\"; }\n\n.fa-sort-numeric-up-alt:before {\n content: \"\\f887\"; }\n\n.fa-sort-up:before {\n content: \"\\f0de\"; }\n\n.fa-soundcloud:before {\n content: \"\\f1be\"; }\n\n.fa-sourcetree:before {\n content: \"\\f7d3\"; }\n\n.fa-spa:before {\n content: \"\\f5bb\"; }\n\n.fa-space-shuttle:before {\n content: \"\\f197\"; }\n\n.fa-speakap:before {\n content: \"\\f3f3\"; }\n\n.fa-speaker-deck:before {\n content: \"\\f83c\"; }\n\n.fa-spell-check:before {\n content: \"\\f891\"; }\n\n.fa-spider:before {\n content: \"\\f717\"; }\n\n.fa-spinner:before {\n content: \"\\f110\"; }\n\n.fa-splotch:before {\n content: \"\\f5bc\"; }\n\n.fa-spotify:before {\n content: \"\\f1bc\"; }\n\n.fa-spray-can:before {\n content: \"\\f5bd\"; }\n\n.fa-square:before {\n content: \"\\f0c8\"; }\n\n.fa-square-full:before {\n content: \"\\f45c\"; }\n\n.fa-square-root-alt:before {\n content: \"\\f698\"; }\n\n.fa-squarespace:before {\n content: \"\\f5be\"; }\n\n.fa-stack-exchange:before {\n content: \"\\f18d\"; }\n\n.fa-stack-overflow:before {\n content: \"\\f16c\"; }\n\n.fa-stackpath:before {\n content: \"\\f842\"; }\n\n.fa-stamp:before {\n content: \"\\f5bf\"; }\n\n.fa-star:before {\n content: \"\\f005\"; }\n\n.fa-star-and-crescent:before {\n content: \"\\f699\"; }\n\n.fa-star-half:before {\n content: \"\\f089\"; }\n\n.fa-star-half-alt:before {\n content: \"\\f5c0\"; }\n\n.fa-star-of-david:before {\n content: \"\\f69a\"; }\n\n.fa-star-of-life:before {\n content: \"\\f621\"; }\n\n.fa-staylinked:before {\n content: \"\\f3f5\"; }\n\n.fa-steam:before {\n content: \"\\f1b6\"; }\n\n.fa-steam-square:before {\n content: \"\\f1b7\"; }\n\n.fa-steam-symbol:before {\n content: \"\\f3f6\"; }\n\n.fa-step-backward:before {\n content: \"\\f048\"; }\n\n.fa-step-forward:before {\n content: \"\\f051\"; }\n\n.fa-stethoscope:before {\n content: \"\\f0f1\"; }\n\n.fa-sticker-mule:before {\n content: \"\\f3f7\"; }\n\n.fa-sticky-note:before {\n content: \"\\f249\"; }\n\n.fa-stop:before {\n content: \"\\f04d\"; }\n\n.fa-stop-circle:before {\n content: \"\\f28d\"; }\n\n.fa-stopwatch:before {\n content: \"\\f2f2\"; }\n\n.fa-stopwatch-20:before {\n content: \"\\e06f\"; }\n\n.fa-store:before {\n content: \"\\f54e\"; }\n\n.fa-store-alt:before {\n content: \"\\f54f\"; }\n\n.fa-store-alt-slash:before {\n content: \"\\e070\"; }\n\n.fa-store-slash:before {\n content: \"\\e071\"; }\n\n.fa-strava:before {\n content: \"\\f428\"; }\n\n.fa-stream:before {\n content: \"\\f550\"; }\n\n.fa-street-view:before {\n content: \"\\f21d\"; }\n\n.fa-strikethrough:before {\n content: \"\\f0cc\"; }\n\n.fa-stripe:before {\n content: \"\\f429\"; }\n\n.fa-stripe-s:before {\n content: \"\\f42a\"; }\n\n.fa-stroopwafel:before {\n content: \"\\f551\"; }\n\n.fa-studiovinari:before {\n content: \"\\f3f8\"; }\n\n.fa-stumbleupon:before {\n content: \"\\f1a4\"; }\n\n.fa-stumbleupon-circle:before {\n content: \"\\f1a3\"; }\n\n.fa-subscript:before {\n content: \"\\f12c\"; }\n\n.fa-subway:before {\n content: \"\\f239\"; }\n\n.fa-suitcase:before {\n content: \"\\f0f2\"; }\n\n.fa-suitcase-rolling:before {\n content: \"\\f5c1\"; }\n\n.fa-sun:before {\n content: \"\\f185\"; }\n\n.fa-superpowers:before {\n content: \"\\f2dd\"; }\n\n.fa-superscript:before {\n content: \"\\f12b\"; }\n\n.fa-supple:before {\n content: \"\\f3f9\"; }\n\n.fa-surprise:before {\n content: \"\\f5c2\"; }\n\n.fa-suse:before {\n content: \"\\f7d6\"; }\n\n.fa-swatchbook:before {\n content: \"\\f5c3\"; }\n\n.fa-swift:before {\n content: \"\\f8e1\"; }\n\n.fa-swimmer:before {\n content: \"\\f5c4\"; }\n\n.fa-swimming-pool:before {\n content: \"\\f5c5\"; }\n\n.fa-symfony:before {\n content: \"\\f83d\"; }\n\n.fa-synagogue:before {\n content: \"\\f69b\"; }\n\n.fa-sync:before {\n content: \"\\f021\"; }\n\n.fa-sync-alt:before {\n content: \"\\f2f1\"; }\n\n.fa-syringe:before {\n content: \"\\f48e\"; }\n\n.fa-table:before {\n content: \"\\f0ce\"; }\n\n.fa-table-tennis:before {\n content: \"\\f45d\"; }\n\n.fa-tablet:before {\n content: \"\\f10a\"; }\n\n.fa-tablet-alt:before {\n content: \"\\f3fa\"; }\n\n.fa-tablets:before {\n content: \"\\f490\"; }\n\n.fa-tachometer-alt:before {\n content: \"\\f3fd\"; }\n\n.fa-tag:before {\n content: \"\\f02b\"; }\n\n.fa-tags:before {\n content: \"\\f02c\"; }\n\n.fa-tape:before {\n content: \"\\f4db\"; }\n\n.fa-tasks:before {\n content: \"\\f0ae\"; }\n\n.fa-taxi:before {\n content: \"\\f1ba\"; }\n\n.fa-teamspeak:before {\n content: \"\\f4f9\"; }\n\n.fa-teeth:before {\n content: \"\\f62e\"; }\n\n.fa-teeth-open:before {\n content: \"\\f62f\"; }\n\n.fa-telegram:before {\n content: \"\\f2c6\"; }\n\n.fa-telegram-plane:before {\n content: \"\\f3fe\"; }\n\n.fa-temperature-high:before {\n content: \"\\f769\"; }\n\n.fa-temperature-low:before {\n content: \"\\f76b\"; }\n\n.fa-tencent-weibo:before {\n content: \"\\f1d5\"; }\n\n.fa-tenge:before {\n content: \"\\f7d7\"; }\n\n.fa-terminal:before {\n content: \"\\f120\"; }\n\n.fa-text-height:before {\n content: \"\\f034\"; }\n\n.fa-text-width:before {\n content: \"\\f035\"; }\n\n.fa-th:before {\n content: \"\\f00a\"; }\n\n.fa-th-large:before {\n content: \"\\f009\"; }\n\n.fa-th-list:before {\n content: \"\\f00b\"; }\n\n.fa-the-red-yeti:before {\n content: \"\\f69d\"; }\n\n.fa-theater-masks:before {\n content: \"\\f630\"; }\n\n.fa-themeco:before {\n content: \"\\f5c6\"; }\n\n.fa-themeisle:before {\n content: \"\\f2b2\"; }\n\n.fa-thermometer:before {\n content: \"\\f491\"; }\n\n.fa-thermometer-empty:before {\n content: \"\\f2cb\"; }\n\n.fa-thermometer-full:before {\n content: \"\\f2c7\"; }\n\n.fa-thermometer-half:before {\n content: \"\\f2c9\"; }\n\n.fa-thermometer-quarter:before {\n content: \"\\f2ca\"; }\n\n.fa-thermometer-three-quarters:before {\n content: \"\\f2c8\"; }\n\n.fa-think-peaks:before {\n content: \"\\f731\"; }\n\n.fa-thumbs-down:before {\n content: \"\\f165\"; }\n\n.fa-thumbs-up:before {\n content: \"\\f164\"; }\n\n.fa-thumbtack:before {\n content: \"\\f08d\"; }\n\n.fa-ticket-alt:before {\n content: \"\\f3ff\"; }\n\n.fa-tiktok:before {\n content: \"\\e07b\"; }\n\n.fa-times:before {\n content: \"\\f00d\"; }\n\n.fa-times-circle:before {\n content: \"\\f057\"; }\n\n.fa-tint:before {\n content: \"\\f043\"; }\n\n.fa-tint-slash:before {\n content: \"\\f5c7\"; }\n\n.fa-tired:before {\n content: \"\\f5c8\"; }\n\n.fa-toggle-off:before {\n content: \"\\f204\"; }\n\n.fa-toggle-on:before {\n content: \"\\f205\"; }\n\n.fa-toilet:before {\n content: \"\\f7d8\"; }\n\n.fa-toilet-paper:before {\n content: \"\\f71e\"; }\n\n.fa-toilet-paper-slash:before {\n content: \"\\e072\"; }\n\n.fa-toolbox:before {\n content: \"\\f552\"; }\n\n.fa-tools:before {\n content: \"\\f7d9\"; }\n\n.fa-tooth:before {\n content: \"\\f5c9\"; }\n\n.fa-torah:before {\n content: \"\\f6a0\"; }\n\n.fa-torii-gate:before {\n content: \"\\f6a1\"; }\n\n.fa-tractor:before {\n content: \"\\f722\"; }\n\n.fa-trade-federation:before {\n content: \"\\f513\"; }\n\n.fa-trademark:before {\n content: \"\\f25c\"; }\n\n.fa-traffic-light:before {\n content: \"\\f637\"; }\n\n.fa-trailer:before {\n content: \"\\e041\"; }\n\n.fa-train:before {\n content: \"\\f238\"; }\n\n.fa-tram:before {\n content: \"\\f7da\"; }\n\n.fa-transgender:before {\n content: \"\\f224\"; }\n\n.fa-transgender-alt:before {\n content: \"\\f225\"; }\n\n.fa-trash:before {\n content: \"\\f1f8\"; }\n\n.fa-trash-alt:before {\n content: \"\\f2ed\"; }\n\n.fa-trash-restore:before {\n content: \"\\f829\"; }\n\n.fa-trash-restore-alt:before {\n content: \"\\f82a\"; }\n\n.fa-tree:before {\n content: \"\\f1bb\"; }\n\n.fa-trello:before {\n content: \"\\f181\"; }\n\n.fa-trophy:before {\n content: \"\\f091\"; }\n\n.fa-truck:before {\n content: \"\\f0d1\"; }\n\n.fa-truck-loading:before {\n content: \"\\f4de\"; }\n\n.fa-truck-monster:before {\n content: \"\\f63b\"; }\n\n.fa-truck-moving:before {\n content: \"\\f4df\"; }\n\n.fa-truck-pickup:before {\n content: \"\\f63c\"; }\n\n.fa-tshirt:before {\n content: \"\\f553\"; }\n\n.fa-tty:before {\n content: \"\\f1e4\"; }\n\n.fa-tumblr:before {\n content: \"\\f173\"; }\n\n.fa-tumblr-square:before {\n content: \"\\f174\"; }\n\n.fa-tv:before {\n content: \"\\f26c\"; }\n\n.fa-twitch:before {\n content: \"\\f1e8\"; }\n\n.fa-twitter:before {\n content: \"\\f099\"; }\n\n.fa-twitter-square:before {\n content: \"\\f081\"; }\n\n.fa-typo3:before {\n content: \"\\f42b\"; }\n\n.fa-uber:before {\n content: \"\\f402\"; }\n\n.fa-ubuntu:before {\n content: \"\\f7df\"; }\n\n.fa-uikit:before {\n content: \"\\f403\"; }\n\n.fa-umbraco:before {\n content: \"\\f8e8\"; }\n\n.fa-umbrella:before {\n content: \"\\f0e9\"; }\n\n.fa-umbrella-beach:before {\n content: \"\\f5ca\"; }\n\n.fa-uncharted:before {\n content: \"\\e084\"; }\n\n.fa-underline:before {\n content: \"\\f0cd\"; }\n\n.fa-undo:before {\n content: \"\\f0e2\"; }\n\n.fa-undo-alt:before {\n content: \"\\f2ea\"; }\n\n.fa-uniregistry:before {\n content: \"\\f404\"; }\n\n.fa-unity:before {\n content: \"\\e049\"; }\n\n.fa-universal-access:before {\n content: \"\\f29a\"; }\n\n.fa-university:before {\n content: \"\\f19c\"; }\n\n.fa-unlink:before {\n content: \"\\f127\"; }\n\n.fa-unlock:before {\n content: \"\\f09c\"; }\n\n.fa-unlock-alt:before {\n content: \"\\f13e\"; }\n\n.fa-unsplash:before {\n content: \"\\e07c\"; }\n\n.fa-untappd:before {\n content: \"\\f405\"; }\n\n.fa-upload:before {\n content: \"\\f093\"; }\n\n.fa-ups:before {\n content: \"\\f7e0\"; }\n\n.fa-usb:before {\n content: \"\\f287\"; }\n\n.fa-user:before {\n content: \"\\f007\"; }\n\n.fa-user-alt:before {\n content: \"\\f406\"; }\n\n.fa-user-alt-slash:before {\n content: \"\\f4fa\"; }\n\n.fa-user-astronaut:before {\n content: \"\\f4fb\"; }\n\n.fa-user-check:before {\n content: \"\\f4fc\"; }\n\n.fa-user-circle:before {\n content: \"\\f2bd\"; }\n\n.fa-user-clock:before {\n content: \"\\f4fd\"; }\n\n.fa-user-cog:before {\n content: \"\\f4fe\"; }\n\n.fa-user-edit:before {\n content: \"\\f4ff\"; }\n\n.fa-user-friends:before {\n content: \"\\f500\"; }\n\n.fa-user-graduate:before {\n content: \"\\f501\"; }\n\n.fa-user-injured:before {\n content: \"\\f728\"; }\n\n.fa-user-lock:before {\n content: \"\\f502\"; }\n\n.fa-user-md:before {\n content: \"\\f0f0\"; }\n\n.fa-user-minus:before {\n content: \"\\f503\"; }\n\n.fa-user-ninja:before {\n content: \"\\f504\"; }\n\n.fa-user-nurse:before {\n content: \"\\f82f\"; }\n\n.fa-user-plus:before {\n content: \"\\f234\"; }\n\n.fa-user-secret:before {\n content: \"\\f21b\"; }\n\n.fa-user-shield:before {\n content: \"\\f505\"; }\n\n.fa-user-slash:before {\n content: \"\\f506\"; }\n\n.fa-user-tag:before {\n content: \"\\f507\"; }\n\n.fa-user-tie:before {\n content: \"\\f508\"; }\n\n.fa-user-times:before {\n content: \"\\f235\"; }\n\n.fa-users:before {\n content: \"\\f0c0\"; }\n\n.fa-users-cog:before {\n content: \"\\f509\"; }\n\n.fa-users-slash:before {\n content: \"\\e073\"; }\n\n.fa-usps:before {\n content: \"\\f7e1\"; }\n\n.fa-ussunnah:before {\n content: \"\\f407\"; }\n\n.fa-utensil-spoon:before {\n content: \"\\f2e5\"; }\n\n.fa-utensils:before {\n content: \"\\f2e7\"; }\n\n.fa-vaadin:before {\n content: \"\\f408\"; }\n\n.fa-vector-square:before {\n content: \"\\f5cb\"; }\n\n.fa-venus:before {\n content: \"\\f221\"; }\n\n.fa-venus-double:before {\n content: \"\\f226\"; }\n\n.fa-venus-mars:before {\n content: \"\\f228\"; }\n\n.fa-vest:before {\n content: \"\\e085\"; }\n\n.fa-vest-patches:before {\n content: \"\\e086\"; }\n\n.fa-viacoin:before {\n content: \"\\f237\"; }\n\n.fa-viadeo:before {\n content: \"\\f2a9\"; }\n\n.fa-viadeo-square:before {\n content: \"\\f2aa\"; }\n\n.fa-vial:before {\n content: \"\\f492\"; }\n\n.fa-vials:before {\n content: \"\\f493\"; }\n\n.fa-viber:before {\n content: \"\\f409\"; }\n\n.fa-video:before {\n content: \"\\f03d\"; }\n\n.fa-video-slash:before {\n content: \"\\f4e2\"; }\n\n.fa-vihara:before {\n content: \"\\f6a7\"; }\n\n.fa-vimeo:before {\n content: \"\\f40a\"; }\n\n.fa-vimeo-square:before {\n content: \"\\f194\"; }\n\n.fa-vimeo-v:before {\n content: \"\\f27d\"; }\n\n.fa-vine:before {\n content: \"\\f1ca\"; }\n\n.fa-virus:before {\n content: \"\\e074\"; }\n\n.fa-virus-slash:before {\n content: \"\\e075\"; }\n\n.fa-viruses:before {\n content: \"\\e076\"; }\n\n.fa-vk:before {\n content: \"\\f189\"; }\n\n.fa-vnv:before {\n content: \"\\f40b\"; }\n\n.fa-voicemail:before {\n content: \"\\f897\"; }\n\n.fa-volleyball-ball:before {\n content: \"\\f45f\"; }\n\n.fa-volume-down:before {\n content: \"\\f027\"; }\n\n.fa-volume-mute:before {\n content: \"\\f6a9\"; }\n\n.fa-volume-off:before {\n content: \"\\f026\"; }\n\n.fa-volume-up:before {\n content: \"\\f028\"; }\n\n.fa-vote-yea:before {\n content: \"\\f772\"; }\n\n.fa-vr-cardboard:before {\n content: \"\\f729\"; }\n\n.fa-vuejs:before {\n content: \"\\f41f\"; }\n\n.fa-walking:before {\n content: \"\\f554\"; }\n\n.fa-wallet:before {\n content: \"\\f555\"; }\n\n.fa-warehouse:before {\n content: \"\\f494\"; }\n\n.fa-watchman-monitoring:before {\n content: \"\\e087\"; }\n\n.fa-water:before {\n content: \"\\f773\"; }\n\n.fa-wave-square:before {\n content: \"\\f83e\"; }\n\n.fa-waze:before {\n content: \"\\f83f\"; }\n\n.fa-weebly:before {\n content: \"\\f5cc\"; }\n\n.fa-weibo:before {\n content: \"\\f18a\"; }\n\n.fa-weight:before {\n content: \"\\f496\"; }\n\n.fa-weight-hanging:before {\n content: \"\\f5cd\"; }\n\n.fa-weixin:before {\n content: \"\\f1d7\"; }\n\n.fa-whatsapp:before {\n content: \"\\f232\"; }\n\n.fa-whatsapp-square:before {\n content: \"\\f40c\"; }\n\n.fa-wheelchair:before {\n content: \"\\f193\"; }\n\n.fa-whmcs:before {\n content: \"\\f40d\"; }\n\n.fa-wifi:before {\n content: \"\\f1eb\"; }\n\n.fa-wikipedia-w:before {\n content: \"\\f266\"; }\n\n.fa-wind:before {\n content: \"\\f72e\"; }\n\n.fa-window-close:before {\n content: \"\\f410\"; }\n\n.fa-window-maximize:before {\n content: \"\\f2d0\"; }\n\n.fa-window-minimize:before {\n content: \"\\f2d1\"; }\n\n.fa-window-restore:before {\n content: \"\\f2d2\"; }\n\n.fa-windows:before {\n content: \"\\f17a\"; }\n\n.fa-wine-bottle:before {\n content: \"\\f72f\"; }\n\n.fa-wine-glass:before {\n content: \"\\f4e3\"; }\n\n.fa-wine-glass-alt:before {\n content: \"\\f5ce\"; }\n\n.fa-wix:before {\n content: \"\\f5cf\"; }\n\n.fa-wizards-of-the-coast:before {\n content: \"\\f730\"; }\n\n.fa-wodu:before {\n content: \"\\e088\"; }\n\n.fa-wolf-pack-battalion:before {\n content: \"\\f514\"; }\n\n.fa-won-sign:before {\n content: \"\\f159\"; }\n\n.fa-wordpress:before {\n content: \"\\f19a\"; }\n\n.fa-wordpress-simple:before {\n content: \"\\f411\"; }\n\n.fa-wpbeginner:before {\n content: \"\\f297\"; }\n\n.fa-wpexplorer:before {\n content: \"\\f2de\"; }\n\n.fa-wpforms:before {\n content: \"\\f298\"; }\n\n.fa-wpressr:before {\n content: \"\\f3e4\"; }\n\n.fa-wrench:before {\n content: \"\\f0ad\"; }\n\n.fa-x-ray:before {\n content: \"\\f497\"; }\n\n.fa-xbox:before {\n content: \"\\f412\"; }\n\n.fa-xing:before {\n content: \"\\f168\"; }\n\n.fa-xing-square:before {\n content: \"\\f169\"; }\n\n.fa-y-combinator:before {\n content: \"\\f23b\"; }\n\n.fa-yahoo:before {\n content: \"\\f19e\"; }\n\n.fa-yammer:before {\n content: \"\\f840\"; }\n\n.fa-yandex:before {\n content: \"\\f413\"; }\n\n.fa-yandex-international:before {\n content: \"\\f414\"; }\n\n.fa-yarn:before {\n content: \"\\f7e3\"; }\n\n.fa-yelp:before {\n content: \"\\f1e9\"; }\n\n.fa-yen-sign:before {\n content: \"\\f157\"; }\n\n.fa-yin-yang:before {\n content: \"\\f6ad\"; }\n\n.fa-yoast:before {\n content: \"\\f2b1\"; }\n\n.fa-youtube:before {\n content: \"\\f167\"; }\n\n.fa-youtube-square:before {\n content: \"\\f431\"; }\n\n.fa-zhihu:before {\n content: \"\\f63f\"; }\n\n.sr-only {\n border: 0;\n clip: rect(0, 0, 0, 0);\n height: 1px;\n margin: -1px;\n overflow: hidden;\n padding: 0;\n position: absolute;\n width: 1px; }\n\n.sr-only-focusable:active, .sr-only-focusable:focus {\n clip: auto;\n height: auto;\n margin: 0;\n overflow: visible;\n position: static;\n width: auto; }\n@font-face {\n font-family: 'Font Awesome 5 Brands';\n font-style: normal;\n font-weight: 400;\n font-display: block;\n src: url(\"../webfonts/fa-brands-400.eot\");\n src: url(\"../webfonts/fa-brands-400.eot?#iefix\") format(\"embedded-opentype\"), url(\"../webfonts/fa-brands-400.woff2\") format(\"woff2\"), url(\"../webfonts/fa-brands-400.woff\") format(\"woff\"), url(\"../webfonts/fa-brands-400.ttf\") format(\"truetype\"), url(\"../webfonts/fa-brands-400.svg#fontawesome\") format(\"svg\"); }\n\n.fab {\n font-family: 'Font Awesome 5 Brands';\n font-weight: 400; }\n@font-face {\n font-family: 'Font Awesome 5 Free';\n font-style: normal;\n font-weight: 400;\n font-display: block;\n src: url(\"../webfonts/fa-regular-400.eot\");\n src: url(\"../webfonts/fa-regular-400.eot?#iefix\") format(\"embedded-opentype\"), url(\"../webfonts/fa-regular-400.woff2\") format(\"woff2\"), url(\"../webfonts/fa-regular-400.woff\") format(\"woff\"), url(\"../webfonts/fa-regular-400.ttf\") format(\"truetype\"), url(\"../webfonts/fa-regular-400.svg#fontawesome\") format(\"svg\"); }\n\n.far {\n font-family: 'Font Awesome 5 Free';\n font-weight: 400; }\n@font-face {\n font-family: 'Font Awesome 5 Free';\n font-style: normal;\n font-weight: 900;\n font-display: block;\n src: url(\"../webfonts/fa-solid-900.eot\");\n src: url(\"../webfonts/fa-solid-900.eot?#iefix\") format(\"embedded-opentype\"), url(\"../webfonts/fa-solid-900.woff2\") format(\"woff2\"), url(\"../webfonts/fa-solid-900.woff\") format(\"woff\"), url(\"../webfonts/fa-solid-900.ttf\") format(\"truetype\"), url(\"../webfonts/fa-solid-900.svg#fontawesome\") format(\"svg\"); }\n\n.fa,\n.fas {\n font-family: 'Font Awesome 5 Free';\n font-weight: 900; }\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.css": +/*!*************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.css ***! + \*************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-action-bar { + white-space: nowrap; + height: 100%; +} + +.monaco-action-bar .actions-container { + display: flex; + margin: 0 auto; + padding: 0; + height: 100%; + width: 100%; + align-items: center; +} + +.monaco-action-bar.vertical .actions-container { + display: inline-block; +} + +.monaco-action-bar .action-item { + display: block; + align-items: center; + justify-content: center; + cursor: pointer; + position: relative; /* DO NOT REMOVE - this is the key to preventing the ghosting icon bug in Chrome 42 */ +} + +.monaco-action-bar .action-item.disabled { + cursor: default; +} + +.monaco-action-bar .action-item .icon, +.monaco-action-bar .action-item .codicon { + display: block; +} + +.monaco-action-bar .action-item .codicon { + display: flex; + align-items: center; + width: 16px; + height: 16px; +} + +.monaco-action-bar .action-label { + display: flex; + font-size: 11px; + padding: 3px; + border-radius: 5px; +} + +.monaco-action-bar .action-item.disabled .action-label, +.monaco-action-bar .action-item.disabled .action-label::before, +.monaco-action-bar .action-item.disabled .action-label:hover { + opacity: 0.6; +} + +/* Vertical actions */ + +.monaco-action-bar.vertical { + text-align: left; +} + +.monaco-action-bar.vertical .action-item { + display: block; +} + +.monaco-action-bar.vertical .action-label.separator { + display: block; + border-bottom: 1px solid #bbb; + padding-top: 1px; + margin-left: .8em; + margin-right: .8em; +} + +.monaco-action-bar .action-item .action-label.separator { + width: 1px; + height: 16px; + margin: 5px 4px !important; + cursor: default; + min-width: 1px; + padding: 0; + background-color: #bbb; +} + +.secondary-actions .monaco-action-bar .action-label { + margin-left: 6px; +} + +/* Action Items */ +.monaco-action-bar .action-item.select-container { + overflow: hidden; /* somehow the dropdown overflows its container, we prevent it here to not push */ + flex: 1; + max-width: 170px; + min-width: 60px; + display: flex; + align-items: center; + justify-content: center; + margin-right: 10px; +} + +.monaco-action-bar .action-item.action-dropdown-item { + display: flex; +} + +.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator { + display: flex; + align-items: center; + cursor: default; +} + +.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator > div { + width: 1px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,mBAAmB;CACnB,YAAY;AACb;;AAEA;CACC,aAAa;CACb,cAAc;CACd,UAAU;CACV,YAAY;CACZ,WAAW;CACX,mBAAmB;AACpB;;AAEA;CACC,qBAAqB;AACtB;;AAEA;CACC,cAAc;CACd,mBAAmB;CACnB,uBAAuB;CACvB,eAAe;CACf,kBAAkB,GAAG,qFAAqF;AAC3G;;AAEA;CACC,eAAe;AAChB;;AAEA;;CAEC,cAAc;AACf;;AAEA;CACC,aAAa;CACb,mBAAmB;CACnB,WAAW;CACX,YAAY;AACb;;AAEA;CACC,aAAa;CACb,eAAe;CACf,YAAY;CACZ,kBAAkB;AACnB;;AAEA;;;CAGC,YAAY;AACb;;AAEA,qBAAqB;;AAErB;CACC,gBAAgB;AACjB;;AAEA;CACC,cAAc;AACf;;AAEA;CACC,cAAc;CACd,6BAA6B;CAC7B,gBAAgB;CAChB,iBAAiB;CACjB,kBAAkB;AACnB;;AAEA;CACC,UAAU;CACV,YAAY;CACZ,0BAA0B;CAC1B,eAAe;CACf,cAAc;CACd,UAAU;CACV,sBAAsB;AACvB;;AAEA;CACC,gBAAgB;AACjB;;AAEA,iBAAiB;AACjB;CACC,gBAAgB,EAAE,iFAAiF;CACnG,OAAO;CACP,gBAAgB;CAChB,eAAe;CACf,aAAa;CACb,mBAAmB;CACnB,uBAAuB;CACvB,kBAAkB;AACnB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,aAAa;CACb,mBAAmB;CACnB,eAAe;AAChB;;AAEA;CACC,UAAU;AACX","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-action-bar {\n\twhite-space: nowrap;\n\theight: 100%;\n}\n\n.monaco-action-bar .actions-container {\n\tdisplay: flex;\n\tmargin: 0 auto;\n\tpadding: 0;\n\theight: 100%;\n\twidth: 100%;\n\talign-items: center;\n}\n\n.monaco-action-bar.vertical .actions-container {\n\tdisplay: inline-block;\n}\n\n.monaco-action-bar .action-item {\n\tdisplay: block;\n\talign-items: center;\n\tjustify-content: center;\n\tcursor: pointer;\n\tposition: relative; /* DO NOT REMOVE - this is the key to preventing the ghosting icon bug in Chrome 42 */\n}\n\n.monaco-action-bar .action-item.disabled {\n\tcursor: default;\n}\n\n.monaco-action-bar .action-item .icon,\n.monaco-action-bar .action-item .codicon {\n\tdisplay: block;\n}\n\n.monaco-action-bar .action-item .codicon {\n\tdisplay: flex;\n\talign-items: center;\n\twidth: 16px;\n\theight: 16px;\n}\n\n.monaco-action-bar .action-label {\n\tdisplay: flex;\n\tfont-size: 11px;\n\tpadding: 3px;\n\tborder-radius: 5px;\n}\n\n.monaco-action-bar .action-item.disabled .action-label,\n.monaco-action-bar .action-item.disabled .action-label::before,\n.monaco-action-bar .action-item.disabled .action-label:hover {\n\topacity: 0.6;\n}\n\n/* Vertical actions */\n\n.monaco-action-bar.vertical {\n\ttext-align: left;\n}\n\n.monaco-action-bar.vertical .action-item {\n\tdisplay: block;\n}\n\n.monaco-action-bar.vertical .action-label.separator {\n\tdisplay: block;\n\tborder-bottom: 1px solid #bbb;\n\tpadding-top: 1px;\n\tmargin-left: .8em;\n\tmargin-right: .8em;\n}\n\n.monaco-action-bar .action-item .action-label.separator {\n\twidth: 1px;\n\theight: 16px;\n\tmargin: 5px 4px !important;\n\tcursor: default;\n\tmin-width: 1px;\n\tpadding: 0;\n\tbackground-color: #bbb;\n}\n\n.secondary-actions .monaco-action-bar .action-label {\n\tmargin-left: 6px;\n}\n\n/* Action Items */\n.monaco-action-bar .action-item.select-container {\n\toverflow: hidden; /* somehow the dropdown overflows its container, we prevent it here to not push */\n\tflex: 1;\n\tmax-width: 170px;\n\tmin-width: 60px;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n\tmargin-right: 10px;\n}\n\n.monaco-action-bar .action-item.action-dropdown-item {\n\tdisplay: flex;\n}\n\n.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator {\n\tdisplay: flex;\n\talign-items: center;\n\tcursor: default;\n}\n\n.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator > div {\n\twidth: 1px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/aria/aria.css": +/*!***************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/aria/aria.css ***! + \***************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-aria-container { + position: absolute; /* try to hide from window but not from screen readers */ + left:-999em; +}`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/aria/aria.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB,EAAE,wDAAwD;CAC5E,WAAW;AACZ","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-aria-container {\n\tposition: absolute; /* try to hide from window but not from screen readers */\n\tleft:-999em;\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/button/button.css": +/*!*******************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/button/button.css ***! + \*******************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-text-button { + box-sizing: border-box; + display: flex; + width: 100%; + padding: 4px; + border-radius: 2px; + text-align: center; + cursor: pointer; + justify-content: center; + align-items: center; + border: 1px solid var(--vscode-button-border, transparent); + line-height: 18px; +} + +.monaco-text-button:focus { + outline-offset: 2px !important; +} + +.monaco-text-button:hover { + text-decoration: none !important; +} + +.monaco-button.disabled:focus, +.monaco-button.disabled { + opacity: 0.4 !important; + cursor: default; +} + +.monaco-text-button .codicon { + margin: 0 0.2em; + color: inherit !important; +} + +.monaco-text-button.monaco-text-button-with-short-label { + flex-direction: row; + flex-wrap: wrap; + padding: 0 4px; + overflow: hidden; + height: 28px; +} + +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label { + flex-basis: 100%; +} + +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short { + flex-grow: 1; + width: 0; + overflow: hidden; +} + +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label, +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short { + display: flex; + justify-content: center; + align-items: center; + font-weight: normal; + font-style: inherit; + padding: 4px 0; +} + +.monaco-button-dropdown { + display: flex; + cursor: pointer; +} + +.monaco-button-dropdown.disabled { + cursor: default; +} + +.monaco-button-dropdown > .monaco-button:focus { + outline-offset: -1px !important; +} + +.monaco-button-dropdown.disabled > .monaco-button.disabled, +.monaco-button-dropdown.disabled > .monaco-button.disabled:focus, +.monaco-button-dropdown.disabled > .monaco-button-dropdown-separator { + opacity: 0.4 !important; +} + +.monaco-button-dropdown > .monaco-button.monaco-text-button { + border-right-width: 0 !important; +} + +.monaco-button-dropdown .monaco-button-dropdown-separator { + padding: 4px 0; + cursor: default; +} + +.monaco-button-dropdown .monaco-button-dropdown-separator > div { + height: 100%; + width: 1px; +} + +.monaco-button-dropdown > .monaco-button.monaco-dropdown-button { + border: 1px solid var(--vscode-button-border, transparent); + border-left-width: 0 !important; + border-radius: 0 2px 2px 0; + display: flex; + align-items: center; +} + +.monaco-button-dropdown > .monaco-button.monaco-text-button { + border-radius: 2px 0 0 2px; +} + +.monaco-description-button { + display: flex; + flex-direction: column; + align-items: center; + margin: 4px 5px; /* allows button focus outline to be visible */ +} + +.monaco-description-button .monaco-button-description { + font-style: italic; + font-size: 11px; + padding: 4px 20px; +} + +.monaco-description-button .monaco-button-label, +.monaco-description-button .monaco-button-description { + display: flex; + justify-content: center; + align-items: center; +} + +.monaco-description-button .monaco-button-label > .codicon, +.monaco-description-button .monaco-button-description > .codicon { + margin: 0 0.2em; + color: inherit !important; +} + +/* default color styles - based on CSS variables */ + +.monaco-button.default-colors, +.monaco-button-dropdown.default-colors > .monaco-button{ + color: var(--vscode-button-foreground); + background-color: var(--vscode-button-background); +} + +.monaco-button.default-colors:hover, +.monaco-button-dropdown.default-colors > .monaco-button:hover { + background-color: var(--vscode-button-hoverBackground); +} + +.monaco-button.default-colors.secondary, +.monaco-button-dropdown.default-colors > .monaco-button.secondary { + color: var(--vscode-button-secondaryForeground); + background-color: var(--vscode-button-secondaryBackground); +} + +.monaco-button.default-colors.secondary:hover, +.monaco-button-dropdown.default-colors > .monaco-button.secondary:hover { + background-color: var(--vscode-button-secondaryHoverBackground); +} + +.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator { + background-color: var(--vscode-button-background); + border-top: 1px solid var(--vscode-button-border); + border-bottom: 1px solid var(--vscode-button-border); +} + +.monaco-button-dropdown.default-colors .monaco-button.secondary + .monaco-button-dropdown-separator { + background-color: var(--vscode-button-secondaryBackground); +} + +.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator > div { + background-color: var(--vscode-button-separator); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/button/button.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,sBAAsB;CACtB,aAAa;CACb,WAAW;CACX,YAAY;CACZ,kBAAkB;CAClB,kBAAkB;CAClB,eAAe;CACf,uBAAuB;CACvB,mBAAmB;CACnB,0DAA0D;CAC1D,iBAAiB;AAClB;;AAEA;CACC,8BAA8B;AAC/B;;AAEA;CACC,gCAAgC;AACjC;;AAEA;;CAEC,uBAAuB;CACvB,eAAe;AAChB;;AAEA;CACC,eAAe;CACf,yBAAyB;AAC1B;;AAEA;CACC,mBAAmB;CACnB,eAAe;CACf,cAAc;CACd,gBAAgB;CAChB,YAAY;AACb;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,YAAY;CACZ,QAAQ;CACR,gBAAgB;AACjB;;AAEA;;CAEC,aAAa;CACb,uBAAuB;CACvB,mBAAmB;CACnB,mBAAmB;CACnB,mBAAmB;CACnB,cAAc;AACf;;AAEA;CACC,aAAa;CACb,eAAe;AAChB;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,+BAA+B;AAChC;;AAEA;;;CAGC,uBAAuB;AACxB;;AAEA;CACC,gCAAgC;AACjC;;AAEA;CACC,cAAc;CACd,eAAe;AAChB;;AAEA;CACC,YAAY;CACZ,UAAU;AACX;;AAEA;CACC,0DAA0D;CAC1D,+BAA+B;CAC/B,0BAA0B;CAC1B,aAAa;CACb,mBAAmB;AACpB;;AAEA;CACC,0BAA0B;AAC3B;;AAEA;CACC,aAAa;CACb,sBAAsB;CACtB,mBAAmB;CACnB,eAAe,EAAE,8CAA8C;AAChE;;AAEA;CACC,kBAAkB;CAClB,eAAe;CACf,iBAAiB;AAClB;;AAEA;;CAEC,aAAa;CACb,uBAAuB;CACvB,mBAAmB;AACpB;;AAEA;;CAEC,eAAe;CACf,yBAAyB;AAC1B;;AAEA,kDAAkD;;AAElD;;CAEC,sCAAsC;CACtC,iDAAiD;AAClD;;AAEA;;CAEC,sDAAsD;AACvD;;AAEA;;CAEC,+CAA+C;CAC/C,0DAA0D;AAC3D;;AAEA;;CAEC,+DAA+D;AAChE;;AAEA;CACC,iDAAiD;CACjD,iDAAiD;CACjD,oDAAoD;AACrD;;AAEA;CACC,0DAA0D;AAC3D;;AAEA;CACC,gDAAgD;AACjD","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-text-button {\n\tbox-sizing: border-box;\n\tdisplay: flex;\n\twidth: 100%;\n\tpadding: 4px;\n\tborder-radius: 2px;\n\ttext-align: center;\n\tcursor: pointer;\n\tjustify-content: center;\n\talign-items: center;\n\tborder: 1px solid var(--vscode-button-border, transparent);\n\tline-height: 18px;\n}\n\n.monaco-text-button:focus {\n\toutline-offset: 2px !important;\n}\n\n.monaco-text-button:hover {\n\ttext-decoration: none !important;\n}\n\n.monaco-button.disabled:focus,\n.monaco-button.disabled {\n\topacity: 0.4 !important;\n\tcursor: default;\n}\n\n.monaco-text-button .codicon {\n\tmargin: 0 0.2em;\n\tcolor: inherit !important;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label {\n\tflex-direction: row;\n\tflex-wrap: wrap;\n\tpadding: 0 4px;\n\toverflow: hidden;\n\theight: 28px;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label {\n\tflex-basis: 100%;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short {\n\tflex-grow: 1;\n\twidth: 0;\n\toverflow: hidden;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label,\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short {\n\tdisplay: flex;\n\tjustify-content: center;\n\talign-items: center;\n\tfont-weight: normal;\n\tfont-style: inherit;\n\tpadding: 4px 0;\n}\n\n.monaco-button-dropdown {\n\tdisplay: flex;\n\tcursor: pointer;\n}\n\n.monaco-button-dropdown.disabled {\n\tcursor: default;\n}\n\n.monaco-button-dropdown > .monaco-button:focus {\n\toutline-offset: -1px !important;\n}\n\n.monaco-button-dropdown.disabled > .monaco-button.disabled,\n.monaco-button-dropdown.disabled > .monaco-button.disabled:focus,\n.monaco-button-dropdown.disabled > .monaco-button-dropdown-separator {\n\topacity: 0.4 !important;\n}\n\n.monaco-button-dropdown > .monaco-button.monaco-text-button {\n\tborder-right-width: 0 !important;\n}\n\n.monaco-button-dropdown .monaco-button-dropdown-separator {\n\tpadding: 4px 0;\n\tcursor: default;\n}\n\n.monaco-button-dropdown .monaco-button-dropdown-separator > div {\n\theight: 100%;\n\twidth: 1px;\n}\n\n.monaco-button-dropdown > .monaco-button.monaco-dropdown-button {\n\tborder: 1px solid var(--vscode-button-border, transparent);\n\tborder-left-width: 0 !important;\n\tborder-radius: 0 2px 2px 0;\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.monaco-button-dropdown > .monaco-button.monaco-text-button {\n\tborder-radius: 2px 0 0 2px;\n}\n\n.monaco-description-button {\n\tdisplay: flex;\n\tflex-direction: column;\n\talign-items: center;\n\tmargin: 4px 5px; /* allows button focus outline to be visible */\n}\n\n.monaco-description-button .monaco-button-description {\n\tfont-style: italic;\n\tfont-size: 11px;\n\tpadding: 4px 20px;\n}\n\n.monaco-description-button .monaco-button-label,\n.monaco-description-button .monaco-button-description {\n\tdisplay: flex;\n\tjustify-content: center;\n\talign-items: center;\n}\n\n.monaco-description-button .monaco-button-label > .codicon,\n.monaco-description-button .monaco-button-description > .codicon {\n\tmargin: 0 0.2em;\n\tcolor: inherit !important;\n}\n\n/* default color styles - based on CSS variables */\n\n.monaco-button.default-colors,\n.monaco-button-dropdown.default-colors > .monaco-button{\n\tcolor: var(--vscode-button-foreground);\n\tbackground-color: var(--vscode-button-background);\n}\n\n.monaco-button.default-colors:hover,\n.monaco-button-dropdown.default-colors > .monaco-button:hover {\n\tbackground-color: var(--vscode-button-hoverBackground);\n}\n\n.monaco-button.default-colors.secondary,\n.monaco-button-dropdown.default-colors > .monaco-button.secondary {\n\tcolor: var(--vscode-button-secondaryForeground);\n\tbackground-color: var(--vscode-button-secondaryBackground);\n}\n\n.monaco-button.default-colors.secondary:hover,\n.monaco-button-dropdown.default-colors > .monaco-button.secondary:hover {\n\tbackground-color: var(--vscode-button-secondaryHoverBackground);\n}\n\n.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator {\n\tbackground-color: var(--vscode-button-background);\n\tborder-top: 1px solid var(--vscode-button-border);\n\tborder-bottom: 1px solid var(--vscode-button-border);\n}\n\n.monaco-button-dropdown.default-colors .monaco-button.secondary + .monaco-button-dropdown-separator {\n\tbackground-color: var(--vscode-button-secondaryBackground);\n}\n\n.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator > div {\n\tbackground-color: var(--vscode-button-separator);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css": +/*!****************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css ***! + \****************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.codicon-wrench-subaction { + opacity: 0.5; +} + +@keyframes codicon-spin { + 100% { + transform:rotate(360deg); + } +} + +.codicon-sync.codicon-modifier-spin, +.codicon-loading.codicon-modifier-spin, +.codicon-gear.codicon-modifier-spin, +.codicon-notebook-state-executing.codicon-modifier-spin { + /* Use steps to throttle FPS to reduce CPU usage */ + animation: codicon-spin 1.5s steps(30) infinite; +} + +.codicon-modifier-disabled { + opacity: 0.4; +} + +/* custom speed & easing for loading icon */ +.codicon-loading, +.codicon-tree-item-loading::before { + animation-duration: 1s !important; + animation-timing-function: cubic-bezier(0.53, 0.21, 0.29, 0.67) !important; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,YAAY;AACb;;AAEA;CACC;EACC,wBAAwB;CACzB;AACD;;AAEA;;;;CAIC,kDAAkD;CAClD,+CAA+C;AAChD;;AAEA;CACC,YAAY;AACb;;AAEA,2CAA2C;AAC3C;;CAEC,iCAAiC;CACjC,0EAA0E;AAC3E","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.codicon-wrench-subaction {\n\topacity: 0.5;\n}\n\n@keyframes codicon-spin {\n\t100% {\n\t\ttransform:rotate(360deg);\n\t}\n}\n\n.codicon-sync.codicon-modifier-spin,\n.codicon-loading.codicon-modifier-spin,\n.codicon-gear.codicon-modifier-spin,\n.codicon-notebook-state-executing.codicon-modifier-spin {\n\t/* Use steps to throttle FPS to reduce CPU usage */\n\tanimation: codicon-spin 1.5s steps(30) infinite;\n}\n\n.codicon-modifier-disabled {\n\topacity: 0.4;\n}\n\n/* custom speed & easing for loading icon */\n.codicon-loading,\n.codicon-tree-item-loading::before {\n\tanimation-duration: 1s !important;\n\tanimation-timing-function: cubic-bezier(0.53, 0.21, 0.29, 0.67) !important;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css": +/*!******************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css ***! + \******************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/getUrl.js */ "./node_modules/css-loader/dist/runtime/getUrl.js"); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__); +// Imports + + + +var ___CSS_LOADER_URL_IMPORT_0___ = new URL(/* asset import */ __webpack_require__(/*! ./codicon.ttf */ "./node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.ttf"), __webpack_require__.b); +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +var ___CSS_LOADER_URL_REPLACEMENT_0___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_0___); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +@font-face { + font-family: "codicon"; + font-display: block; + src: url(${___CSS_LOADER_URL_REPLACEMENT_0___}) format("truetype"); +} + +.codicon[class*='codicon-'] { + font: normal normal normal 16px/1 codicon; + display: inline-block; + text-decoration: none; + text-rendering: auto; + text-align: center; + text-transform: none; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + user-select: none; + -webkit-user-select: none; +} + +/* icon rules are dynamically created by the platform theme service (see iconsStyleSheet.ts) */ +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,sBAAsB;CACtB,mBAAmB;CACnB,+DAA0C;AAC3C;;AAEA;CACC,yCAAyC;CACzC,qBAAqB;CACrB,qBAAqB;CACrB,oBAAoB;CACpB,kBAAkB;CAClB,oBAAoB;CACpB,mCAAmC;CACnC,kCAAkC;CAClC,iBAAiB;CACjB,yBAAyB;AAC1B;;AAEA,8FAA8F","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n@font-face {\n\tfont-family: \"codicon\";\n\tfont-display: block;\n\tsrc: url(./codicon.ttf) format(\"truetype\");\n}\n\n.codicon[class*='codicon-'] {\n\tfont: normal normal normal 16px/1 codicon;\n\tdisplay: inline-block;\n\ttext-decoration: none;\n\ttext-rendering: auto;\n\ttext-align: center;\n\ttext-transform: none;\n\t-webkit-font-smoothing: antialiased;\n\t-moz-osx-font-smoothing: grayscale;\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n/* icon rules are dynamically created by the platform theme service (see iconsStyleSheet.ts) */\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/contextview/contextview.css": +/*!*****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/contextview/contextview.css ***! + \*****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.context-view { + position: absolute; +} + +.context-view.fixed { + all: initial; + font-family: inherit; + font-size: 13px; + position: fixed; + color: inherit; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/contextview/contextview.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;AACnB;;AAEA;CACC,YAAY;CACZ,oBAAoB;CACpB,eAAe;CACf,eAAe;CACf,cAAc;AACf","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.context-view {\n\tposition: absolute;\n}\n\n.context-view.fixed {\n\tall: initial;\n\tfont-family: inherit;\n\tfont-size: 13px;\n\tposition: fixed;\n\tcolor: inherit;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.css": +/*!***************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.css ***! + \***************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-count-badge { + padding: 3px 6px; + border-radius: 11px; + font-size: 11px; + min-width: 18px; + min-height: 18px; + line-height: 11px; + font-weight: normal; + text-align: center; + display: inline-block; + box-sizing: border-box; +} + +.monaco-count-badge.long { + padding: 2px 3px; + border-radius: 2px; + min-height: auto; + line-height: normal; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,gBAAgB;CAChB,mBAAmB;CACnB,eAAe;CACf,eAAe;CACf,gBAAgB;CAChB,iBAAiB;CACjB,mBAAmB;CACnB,kBAAkB;CAClB,qBAAqB;CACrB,sBAAsB;AACvB;;AAEA;CACC,gBAAgB;CAChB,kBAAkB;CAClB,gBAAgB;CAChB,mBAAmB;AACpB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-count-badge {\n\tpadding: 3px 6px;\n\tborder-radius: 11px;\n\tfont-size: 11px;\n\tmin-width: 18px;\n\tmin-height: 18px;\n\tline-height: 11px;\n\tfont-weight: normal;\n\ttext-align: center;\n\tdisplay: inline-block;\n\tbox-sizing: border-box;\n}\n\n.monaco-count-badge.long {\n\tpadding: 2px 3px;\n\tborder-radius: 2px;\n\tmin-height: auto;\n\tline-height: normal;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/dropdown/dropdown.css": +/*!***********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/dropdown/dropdown.css ***! + \***********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-dropdown { + height: 100%; + padding: 0; +} + +.monaco-dropdown > .dropdown-label { + cursor: pointer; + height: 100%; + display: flex; + align-items: center; + justify-content: center; +} + +.monaco-dropdown > .dropdown-label > .action-label.disabled { + cursor: default; +} + +.monaco-dropdown-with-primary { + display: flex !important; + flex-direction: row; + border-radius: 5px; +} + +.monaco-dropdown-with-primary > .action-container > .action-label { + margin-right: 0; +} + +.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*='codicon-'] { + font-size: 12px; + padding-left: 0px; + padding-right: 0px; + line-height: 16px; + margin-left: -3px; +} + +.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label { + display: block; + background-size: 16px; + background-position: center center; + background-repeat: no-repeat; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/dropdown/dropdown.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,YAAY;CACZ,UAAU;AACX;;AAEA;CACC,eAAe;CACf,YAAY;CACZ,aAAa;CACb,mBAAmB;CACnB,uBAAuB;AACxB;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,wBAAwB;CACxB,mBAAmB;CACnB,kBAAkB;AACnB;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,eAAe;CACf,iBAAiB;CACjB,kBAAkB;CAClB,iBAAiB;CACjB,iBAAiB;AAClB;;AAEA;CACC,cAAc;CACd,qBAAqB;CACrB,kCAAkC;CAClC,4BAA4B;AAC7B","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-dropdown {\n\theight: 100%;\n\tpadding: 0;\n}\n\n.monaco-dropdown > .dropdown-label {\n\tcursor: pointer;\n\theight: 100%;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n.monaco-dropdown > .dropdown-label > .action-label.disabled {\n\tcursor: default;\n}\n\n.monaco-dropdown-with-primary {\n\tdisplay: flex !important;\n\tflex-direction: row;\n\tborder-radius: 5px;\n}\n\n.monaco-dropdown-with-primary > .action-container > .action-label {\n\tmargin-right: 0;\n}\n\n.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*='codicon-'] {\n\tfont-size: 12px;\n\tpadding-left: 0px;\n\tpadding-right: 0px;\n\tline-height: 16px;\n\tmargin-left: -3px;\n}\n\n.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label {\n\tdisplay: block;\n\tbackground-size: 16px;\n\tbackground-position: center center;\n\tbackground-repeat: no-repeat;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/findinput/findInput.css": +/*!*************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/findinput/findInput.css ***! + \*************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/* ---------- Find input ---------- */ + +.monaco-findInput { + position: relative; +} + +.monaco-findInput .monaco-inputbox { + font-size: 13px; + width: 100%; +} + +.monaco-findInput > .controls { + position: absolute; + top: 3px; + right: 2px; +} + +.vs .monaco-findInput.disabled { + background-color: #E1E1E1; +} + +/* Theming */ +.vs-dark .monaco-findInput.disabled { + background-color: #333; +} + +/* Highlighting */ +.monaco-findInput.highlight-0 .controls, +.hc-light .monaco-findInput.highlight-0 .controls { + animation: monaco-findInput-highlight-0 100ms linear 0s; +} + +.monaco-findInput.highlight-1 .controls, +.hc-light .monaco-findInput.highlight-1 .controls { + animation: monaco-findInput-highlight-1 100ms linear 0s; +} + +.hc-black .monaco-findInput.highlight-0 .controls, +.vs-dark .monaco-findInput.highlight-0 .controls { + animation: monaco-findInput-highlight-dark-0 100ms linear 0s; +} + +.hc-black .monaco-findInput.highlight-1 .controls, +.vs-dark .monaco-findInput.highlight-1 .controls { + animation: monaco-findInput-highlight-dark-1 100ms linear 0s; +} + +@keyframes monaco-findInput-highlight-0 { + 0% { background: rgba(253, 255, 0, 0.8); } + 100% { background: transparent; } +} +@keyframes monaco-findInput-highlight-1 { + 0% { background: rgba(253, 255, 0, 0.8); } + /* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/ + 99% { background: transparent; } +} + +@keyframes monaco-findInput-highlight-dark-0 { + 0% { background: rgba(255, 255, 255, 0.44); } + 100% { background: transparent; } +} +@keyframes monaco-findInput-highlight-dark-1 { + 0% { background: rgba(255, 255, 255, 0.44); } + /* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/ + 99% { background: transparent; } +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/findinput/findInput.css"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F,qCAAqC;;AAErC;CACC,kBAAkB;AACnB;;AAEA;CACC,eAAe;CACf,WAAW;AACZ;;AAEA;CACC,kBAAkB;CAClB,QAAQ;CACR,UAAU;AACX;;AAEA;CACC,yBAAyB;AAC1B;;AAEA,YAAY;AACZ;CACC,sBAAsB;AACvB;;AAEA,iBAAiB;AACjB;;CAEC,uDAAuD;AACxD;;AAEA;;CAEC,uDAAuD;AACxD;;AAEA;;CAEC,4DAA4D;AAC7D;;AAEA;;CAEC,4DAA4D;AAC7D;;AAEA;CACC,KAAK,kCAAkC,EAAE;CACzC,OAAO,uBAAuB,EAAE;AACjC;AACA;CACC,KAAK,kCAAkC,EAAE;CACzC,kHAAkH;CAClH,MAAM,uBAAuB,EAAE;AAChC;;AAEA;CACC,KAAK,qCAAqC,EAAE;CAC5C,OAAO,uBAAuB,EAAE;AACjC;AACA;CACC,KAAK,qCAAqC,EAAE;CAC5C,kHAAkH;CAClH,MAAM,uBAAuB,EAAE;AAChC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/* ---------- Find input ---------- */\n\n.monaco-findInput {\n\tposition: relative;\n}\n\n.monaco-findInput .monaco-inputbox {\n\tfont-size: 13px;\n\twidth: 100%;\n}\n\n.monaco-findInput > .controls {\n\tposition: absolute;\n\ttop: 3px;\n\tright: 2px;\n}\n\n.vs .monaco-findInput.disabled {\n\tbackground-color: #E1E1E1;\n}\n\n/* Theming */\n.vs-dark .monaco-findInput.disabled {\n\tbackground-color: #333;\n}\n\n/* Highlighting */\n.monaco-findInput.highlight-0 .controls,\n.hc-light .monaco-findInput.highlight-0 .controls {\n\tanimation: monaco-findInput-highlight-0 100ms linear 0s;\n}\n\n.monaco-findInput.highlight-1 .controls,\n.hc-light .monaco-findInput.highlight-1 .controls {\n\tanimation: monaco-findInput-highlight-1 100ms linear 0s;\n}\n\n.hc-black .monaco-findInput.highlight-0 .controls,\n.vs-dark .monaco-findInput.highlight-0 .controls {\n\tanimation: monaco-findInput-highlight-dark-0 100ms linear 0s;\n}\n\n.hc-black .monaco-findInput.highlight-1 .controls,\n.vs-dark .monaco-findInput.highlight-1 .controls {\n\tanimation: monaco-findInput-highlight-dark-1 100ms linear 0s;\n}\n\n@keyframes monaco-findInput-highlight-0 {\n\t0% { background: rgba(253, 255, 0, 0.8); }\n\t100% { background: transparent; }\n}\n@keyframes monaco-findInput-highlight-1 {\n\t0% { background: rgba(253, 255, 0, 0.8); }\n\t/* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/\n\t99% { background: transparent; }\n}\n\n@keyframes monaco-findInput-highlight-dark-0 {\n\t0% { background: rgba(255, 255, 255, 0.44); }\n\t100% { background: transparent; }\n}\n@keyframes monaco-findInput-highlight-dark-1 {\n\t0% { background: rgba(255, 255, 255, 0.44); }\n\t/* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/\n\t99% { background: transparent; }\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/hover/hover.css": +/*!*****************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/hover/hover.css ***! + \*****************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-hover { + cursor: default; + position: absolute; + overflow: hidden; + user-select: text; + -webkit-user-select: text; + box-sizing: border-box; + animation: fadein 100ms linear; + line-height: 1.5em; + white-space: var(--vscode-hover-whiteSpace, normal); +} + +.monaco-hover.hidden { + display: none; +} + +.monaco-hover a:hover:not(.disabled) { + cursor: pointer; +} + +.monaco-hover .hover-contents:not(.html-hover-contents) { + padding: 4px 8px; +} + +.monaco-hover .markdown-hover > .hover-contents:not(.code-hover-contents) { + max-width: var(--vscode-hover-maxWidth, 500px); + word-wrap: break-word; +} + +.monaco-hover .markdown-hover > .hover-contents:not(.code-hover-contents) hr { + min-width: 100%; +} + +.monaco-hover p, +.monaco-hover .code, +.monaco-hover ul, +.monaco-hover h1, +.monaco-hover h2, +.monaco-hover h3, +.monaco-hover h4, +.monaco-hover h5, +.monaco-hover h6 { + margin: 8px 0; +} + +.monaco-hover h1, +.monaco-hover h2, +.monaco-hover h3, +.monaco-hover h4, +.monaco-hover h5, +.monaco-hover h6 { + line-height: 1.1; +} + +.monaco-hover code { + font-family: var(--monaco-monospace-font); +} + +.monaco-hover hr { + box-sizing: border-box; + border-left: 0px; + border-right: 0px; + margin-top: 4px; + margin-bottom: -4px; + margin-left: -8px; + margin-right: -8px; + height: 1px; +} + +.monaco-hover p:first-child, +.monaco-hover .code:first-child, +.monaco-hover ul:first-child { + margin-top: 0; +} + +.monaco-hover p:last-child, +.monaco-hover .code:last-child, +.monaco-hover ul:last-child { + margin-bottom: 0; +} + +/* MarkupContent Layout */ +.monaco-hover ul { + padding-left: 20px; +} +.monaco-hover ol { + padding-left: 20px; +} + +.monaco-hover li > p { + margin-bottom: 0; +} + +.monaco-hover li > ul { + margin-top: 0; +} + +.monaco-hover code { + border-radius: 3px; + padding: 0 0.4em; +} + +.monaco-hover .monaco-tokenized-source { + white-space: var(--vscode-hover-sourceWhiteSpace, pre-wrap); +} + +.monaco-hover .hover-row.status-bar { + font-size: 12px; + line-height: 22px; +} + +.monaco-hover .hover-row.status-bar .info { + font-style: italic; + padding: 0px 8px; +} + +.monaco-hover .hover-row.status-bar .actions { + display: flex; + padding: 0px 8px; +} + +.monaco-hover .hover-row.status-bar .actions .action-container { + margin-right: 16px; + cursor: pointer; +} + +.monaco-hover .hover-row.status-bar .actions .action-container .action .icon { + padding-right: 4px; +} + +.monaco-hover .markdown-hover .hover-contents .codicon { + color: inherit; + font-size: inherit; + vertical-align: middle; +} + +.monaco-hover .hover-contents a.code-link:hover, +.monaco-hover .hover-contents a.code-link { + color: inherit; +} + +.monaco-hover .hover-contents a.code-link:before { + content: '('; +} + +.monaco-hover .hover-contents a.code-link:after { + content: ')'; +} + +.monaco-hover .hover-contents a.code-link > span { + text-decoration: underline; + /** Hack to force underline to show **/ + border-bottom: 1px solid transparent; + text-underline-position: under; + color: var(--vscode-textLink-foreground); +} + +.monaco-hover .hover-contents a.code-link > span:hover { + color: var(--vscode-textLink-activeForeground); +} + +/** Spans in markdown hovers need a margin-bottom to avoid looking cramped: https://github.com/microsoft/vscode/issues/101496 **/ +.monaco-hover .markdown-hover .hover-contents:not(.code-hover-contents):not(.html-hover-contents) span { + margin-bottom: 4px; + display: inline-block; +} + +.monaco-hover-content .action-container a { + -webkit-user-select: none; + user-select: none; +} + +.monaco-hover-content .action-container.disabled { + pointer-events: none; + opacity: 0.4; + cursor: default; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/hover/hover.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,eAAe;CACf,kBAAkB;CAClB,gBAAgB;CAChB,iBAAiB;CACjB,yBAAyB;CACzB,sBAAsB;CACtB,8BAA8B;CAC9B,kBAAkB;CAClB,mDAAmD;AACpD;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,8CAA8C;CAC9C,qBAAqB;AACtB;;AAEA;CACC,eAAe;AAChB;;AAEA;;;;;;;;;CASC,aAAa;AACd;;AAEA;;;;;;CAMC,gBAAgB;AACjB;;AAEA;CACC,yCAAyC;AAC1C;;AAEA;CACC,sBAAsB;CACtB,gBAAgB;CAChB,iBAAiB;CACjB,eAAe;CACf,mBAAmB;CACnB,iBAAiB;CACjB,kBAAkB;CAClB,WAAW;AACZ;;AAEA;;;CAGC,aAAa;AACd;;AAEA;;;CAGC,gBAAgB;AACjB;;AAEA,yBAAyB;AACzB;CACC,kBAAkB;AACnB;AACA;CACC,kBAAkB;AACnB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;AACjB;;AAEA;CACC,2DAA2D;AAC5D;;AAEA;CACC,eAAe;CACf,iBAAiB;AAClB;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;AACjB;;AAEA;CACC,aAAa;CACb,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;CAClB,eAAe;AAChB;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,cAAc;CACd,kBAAkB;CAClB,sBAAsB;AACvB;;AAEA;;CAEC,cAAc;AACf;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,0BAA0B;CAC1B,sCAAsC;CACtC,oCAAoC;CACpC,8BAA8B;CAC9B,wCAAwC;AACzC;;AAEA;CACC,8CAA8C;AAC/C;;AAEA,gIAAgI;AAChI;CACC,kBAAkB;CAClB,qBAAqB;AACtB;;AAEA;CACC,yBAAyB;CACzB,iBAAiB;AAClB;;AAEA;CACC,oBAAoB;CACpB,YAAY;CACZ,eAAe;AAChB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-hover {\n\tcursor: default;\n\tposition: absolute;\n\toverflow: hidden;\n\tuser-select: text;\n\t-webkit-user-select: text;\n\tbox-sizing: border-box;\n\tanimation: fadein 100ms linear;\n\tline-height: 1.5em;\n\twhite-space: var(--vscode-hover-whiteSpace, normal);\n}\n\n.monaco-hover.hidden {\n\tdisplay: none;\n}\n\n.monaco-hover a:hover:not(.disabled) {\n\tcursor: pointer;\n}\n\n.monaco-hover .hover-contents:not(.html-hover-contents) {\n\tpadding: 4px 8px;\n}\n\n.monaco-hover .markdown-hover > .hover-contents:not(.code-hover-contents) {\n\tmax-width: var(--vscode-hover-maxWidth, 500px);\n\tword-wrap: break-word;\n}\n\n.monaco-hover .markdown-hover > .hover-contents:not(.code-hover-contents) hr {\n\tmin-width: 100%;\n}\n\n.monaco-hover p,\n.monaco-hover .code,\n.monaco-hover ul,\n.monaco-hover h1,\n.monaco-hover h2,\n.monaco-hover h3,\n.monaco-hover h4,\n.monaco-hover h5,\n.monaco-hover h6 {\n\tmargin: 8px 0;\n}\n\n.monaco-hover h1,\n.monaco-hover h2,\n.monaco-hover h3,\n.monaco-hover h4,\n.monaco-hover h5,\n.monaco-hover h6 {\n\tline-height: 1.1;\n}\n\n.monaco-hover code {\n\tfont-family: var(--monaco-monospace-font);\n}\n\n.monaco-hover hr {\n\tbox-sizing: border-box;\n\tborder-left: 0px;\n\tborder-right: 0px;\n\tmargin-top: 4px;\n\tmargin-bottom: -4px;\n\tmargin-left: -8px;\n\tmargin-right: -8px;\n\theight: 1px;\n}\n\n.monaco-hover p:first-child,\n.monaco-hover .code:first-child,\n.monaco-hover ul:first-child {\n\tmargin-top: 0;\n}\n\n.monaco-hover p:last-child,\n.monaco-hover .code:last-child,\n.monaco-hover ul:last-child {\n\tmargin-bottom: 0;\n}\n\n/* MarkupContent Layout */\n.monaco-hover ul {\n\tpadding-left: 20px;\n}\n.monaco-hover ol {\n\tpadding-left: 20px;\n}\n\n.monaco-hover li > p {\n\tmargin-bottom: 0;\n}\n\n.monaco-hover li > ul {\n\tmargin-top: 0;\n}\n\n.monaco-hover code {\n\tborder-radius: 3px;\n\tpadding: 0 0.4em;\n}\n\n.monaco-hover .monaco-tokenized-source {\n\twhite-space: var(--vscode-hover-sourceWhiteSpace, pre-wrap);\n}\n\n.monaco-hover .hover-row.status-bar {\n\tfont-size: 12px;\n\tline-height: 22px;\n}\n\n.monaco-hover .hover-row.status-bar .info {\n\tfont-style: italic;\n\tpadding: 0px 8px;\n}\n\n.monaco-hover .hover-row.status-bar .actions {\n\tdisplay: flex;\n\tpadding: 0px 8px;\n}\n\n.monaco-hover .hover-row.status-bar .actions .action-container {\n\tmargin-right: 16px;\n\tcursor: pointer;\n}\n\n.monaco-hover .hover-row.status-bar .actions .action-container .action .icon {\n\tpadding-right: 4px;\n}\n\n.monaco-hover .markdown-hover .hover-contents .codicon {\n\tcolor: inherit;\n\tfont-size: inherit;\n\tvertical-align: middle;\n}\n\n.monaco-hover .hover-contents a.code-link:hover,\n.monaco-hover .hover-contents a.code-link {\n\tcolor: inherit;\n}\n\n.monaco-hover .hover-contents a.code-link:before {\n\tcontent: '(';\n}\n\n.monaco-hover .hover-contents a.code-link:after {\n\tcontent: ')';\n}\n\n.monaco-hover .hover-contents a.code-link > span {\n\ttext-decoration: underline;\n\t/** Hack to force underline to show **/\n\tborder-bottom: 1px solid transparent;\n\ttext-underline-position: under;\n\tcolor: var(--vscode-textLink-foreground);\n}\n\n.monaco-hover .hover-contents a.code-link > span:hover {\n\tcolor: var(--vscode-textLink-activeForeground);\n}\n\n/** Spans in markdown hovers need a margin-bottom to avoid looking cramped: https://github.com/microsoft/vscode/issues/101496 **/\n.monaco-hover .markdown-hover .hover-contents:not(.code-hover-contents):not(.html-hover-contents) span {\n\tmargin-bottom: 4px;\n\tdisplay: inline-block;\n}\n\n.monaco-hover-content .action-container a {\n\t-webkit-user-select: none;\n\tuser-select: none;\n}\n\n.monaco-hover-content .action-container.disabled {\n\tpointer-events: none;\n\topacity: 0.4;\n\tcursor: default;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/iconLabel/iconlabel.css": +/*!*************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/iconLabel/iconlabel.css ***! + \*************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* ---------- Icon label ---------- */ + +.monaco-icon-label { + display: flex; /* required for icons support :before rule */ + overflow: hidden; + text-overflow: ellipsis; +} + +.monaco-icon-label::before { + + /* svg icons rendered as background image */ + background-size: 16px; + background-position: left center; + background-repeat: no-repeat; + padding-right: 6px; + width: 16px; + height: 22px; + line-height: inherit !important; + display: inline-block; + + /* fonts icons */ + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + vertical-align: top; + + flex-shrink: 0; /* fix for https://github.com/microsoft/vscode/issues/13787 */ +} + +.monaco-icon-label-container.disabled { + color: var(--vscode-disabledForeground); +} +.monaco-icon-label > .monaco-icon-label-container { + min-width: 0; + overflow: hidden; + text-overflow: ellipsis; + flex: 1; +} + +.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name { + color: inherit; + white-space: pre; /* enable to show labels that include multiple whitespaces */ +} + +.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name > .label-separator { + margin: 0 2px; + opacity: 0.5; +} + +.monaco-icon-label>.monaco-icon-label-container>.monaco-icon-suffix-container>.label-suffix { + opacity: .7; + white-space: pre; +} + +.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + opacity: .7; + margin-left: 0.5em; + font-size: 0.9em; + white-space: pre; /* enable to show labels that include multiple whitespaces */ +} + +.monaco-icon-label.nowrap > .monaco-icon-label-container > .monaco-icon-description-container > .label-description{ + white-space: nowrap +} + +.vs .monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + opacity: .95; +} + +.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-name-container > .label-name, +.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + font-style: italic; +} + +.monaco-icon-label.deprecated { + text-decoration: line-through; + opacity: 0.66; +} + +/* make sure apply italic font style to decorations as well */ +.monaco-icon-label.italic::after { + font-style: italic; +} + +.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-name-container > .label-name, +.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + text-decoration: line-through; +} + +.monaco-icon-label::after { + opacity: 0.75; + font-size: 90%; + font-weight: 600; + margin: auto 16px 0 5px; /* https://github.com/microsoft/vscode/issues/113223 */ + text-align: center; +} + +/* make sure selection color wins when a label is being selected */ +.monaco-list:focus .selected .monaco-icon-label, /* list */ +.monaco-list:focus .selected .monaco-icon-label::after +{ + color: inherit !important; +} + +.monaco-list-row.focused.selected .label-description, +.monaco-list-row.selected .label-description { + opacity: .8; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/iconLabel/iconlabel.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,qCAAqC;;AAErC;CACC,aAAa,EAAE,4CAA4C;CAC3D,gBAAgB;CAChB,uBAAuB;AACxB;;AAEA;;CAEC,2CAA2C;CAC3C,qBAAqB;CACrB,gCAAgC;CAChC,4BAA4B;CAC5B,kBAAkB;CAClB,WAAW;CACX,YAAY;CACZ,+BAA+B;CAC/B,qBAAqB;;CAErB,gBAAgB;CAChB,mCAAmC;CACnC,kCAAkC;CAClC,mBAAmB;;CAEnB,cAAc,EAAE,6DAA6D;AAC9E;;AAEA;CACC,uCAAuC;AACxC;AACA;CACC,YAAY;CACZ,gBAAgB;CAChB,uBAAuB;CACvB,OAAO;AACR;;AAEA;CACC,cAAc;CACd,gBAAgB,EAAE,4DAA4D;AAC/E;;AAEA;CACC,aAAa;CACb,YAAY;AACb;;AAEA;CACC,WAAW;CACX,gBAAgB;AACjB;;AAEA;CACC,WAAW;CACX,kBAAkB;CAClB,gBAAgB;CAChB,gBAAgB,EAAE,4DAA4D;AAC/E;;AAEA;CACC;AACD;;AAEA;CACC,YAAY;AACb;;AAEA;;CAEC,kBAAkB;AACnB;;AAEA;CACC,6BAA6B;CAC7B,aAAa;AACd;;AAEA,6DAA6D;AAC7D;CACC,kBAAkB;AACnB;;AAEA;;CAEC,6BAA6B;AAC9B;;AAEA;CACC,aAAa;CACb,cAAc;CACd,gBAAgB;CAChB,uBAAuB,EAAE,sDAAsD;CAC/E,kBAAkB;AACnB;;AAEA,kEAAkE;AAClE;;;CAGC,yBAAyB;AAC1B;;AAEA;;CAEC,WAAW;AACZ","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* ---------- Icon label ---------- */\n\n.monaco-icon-label {\n\tdisplay: flex; /* required for icons support :before rule */\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-icon-label::before {\n\n\t/* svg icons rendered as background image */\n\tbackground-size: 16px;\n\tbackground-position: left center;\n\tbackground-repeat: no-repeat;\n\tpadding-right: 6px;\n\twidth: 16px;\n\theight: 22px;\n\tline-height: inherit !important;\n\tdisplay: inline-block;\n\n\t/* fonts icons */\n\t-webkit-font-smoothing: antialiased;\n\t-moz-osx-font-smoothing: grayscale;\n\tvertical-align: top;\n\n\tflex-shrink: 0; /* fix for https://github.com/microsoft/vscode/issues/13787 */\n}\n\n.monaco-icon-label-container.disabled {\n\tcolor: var(--vscode-disabledForeground);\n}\n.monaco-icon-label > .monaco-icon-label-container {\n\tmin-width: 0;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\tflex: 1;\n}\n\n.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name {\n\tcolor: inherit;\n\twhite-space: pre; /* enable to show labels that include multiple whitespaces */\n}\n\n.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name > .label-separator {\n\tmargin: 0 2px;\n\topacity: 0.5;\n}\n\n.monaco-icon-label>.monaco-icon-label-container>.monaco-icon-suffix-container>.label-suffix {\n\topacity: .7;\n\twhite-space: pre;\n}\n\n.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\topacity: .7;\n\tmargin-left: 0.5em;\n\tfont-size: 0.9em;\n\twhite-space: pre; /* enable to show labels that include multiple whitespaces */\n}\n\n.monaco-icon-label.nowrap > .monaco-icon-label-container > .monaco-icon-description-container > .label-description{\n\twhite-space: nowrap\n}\n\n.vs .monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\topacity: .95;\n}\n\n.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-name-container > .label-name,\n.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\tfont-style: italic;\n}\n\n.monaco-icon-label.deprecated {\n\ttext-decoration: line-through;\n\topacity: 0.66;\n}\n\n/* make sure apply italic font style to decorations as well */\n.monaco-icon-label.italic::after {\n\tfont-style: italic;\n}\n\n.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-name-container > .label-name,\n.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\ttext-decoration: line-through;\n}\n\n.monaco-icon-label::after {\n\topacity: 0.75;\n\tfont-size: 90%;\n\tfont-weight: 600;\n\tmargin: auto 16px 0 5px; /* https://github.com/microsoft/vscode/issues/113223 */\n\ttext-align: center;\n}\n\n/* make sure selection color wins when a label is being selected */\n.monaco-list:focus .selected .monaco-icon-label, /* list */\n.monaco-list:focus .selected .monaco-icon-label::after\n{\n\tcolor: inherit !important;\n}\n\n.monaco-list-row.focused.selected .label-description,\n.monaco-list-row.selected .label-description {\n\topacity: .8;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.css": +/*!***********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.css ***! + \***********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-inputbox { + position: relative; + display: block; + padding: 0; + box-sizing: border-box; + border-radius: 2px; + + /* Customizable */ + font-size: inherit; +} + +.monaco-inputbox > .ibwrapper > .input, +.monaco-inputbox > .ibwrapper > .mirror { + + /* Customizable */ + padding: 4px 6px; +} + +.monaco-inputbox > .ibwrapper { + position: relative; + width: 100%; + height: 100%; +} + +.monaco-inputbox > .ibwrapper > .input { + display: inline-block; + box-sizing: border-box; + width: 100%; + height: 100%; + line-height: inherit; + border: none; + font-family: inherit; + font-size: inherit; + resize: none; + color: inherit; +} + +.monaco-inputbox > .ibwrapper > input { + text-overflow: ellipsis; +} + +.monaco-inputbox > .ibwrapper > textarea.input { + display: block; + scrollbar-width: none; /* Firefox: hide scrollbars */ + outline: none; +} + +.monaco-inputbox > .ibwrapper > textarea.input::-webkit-scrollbar { + display: none; /* Chrome + Safari: hide scrollbar */ +} + +.monaco-inputbox > .ibwrapper > textarea.input.empty { + white-space: nowrap; +} + +.monaco-inputbox > .ibwrapper > .mirror { + position: absolute; + display: inline-block; + width: 100%; + top: 0; + left: 0; + box-sizing: border-box; + white-space: pre-wrap; + visibility: hidden; + word-wrap: break-word; +} + +/* Context view */ + +.monaco-inputbox-container { + text-align: right; +} + +.monaco-inputbox-container .monaco-inputbox-message { + display: inline-block; + overflow: hidden; + text-align: left; + width: 100%; + box-sizing: border-box; + padding: 0.4em; + font-size: 12px; + line-height: 17px; + margin-top: -1px; + word-wrap: break-word; +} + +/* Action bar support */ +.monaco-inputbox .monaco-action-bar { + position: absolute; + right: 2px; + top: 4px; +} + +.monaco-inputbox .monaco-action-bar .action-item { + margin-left: 2px; +} + +.monaco-inputbox .monaco-action-bar .action-item .codicon { + background-repeat: no-repeat; + width: 16px; + height: 16px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,cAAc;CACd,UAAU;CACV,sBAAsB;CACtB,kBAAkB;;CAElB,iBAAiB;CACjB,kBAAkB;AACnB;;AAEA;;;CAGC,iBAAiB;CACjB,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;CAClB,WAAW;CACX,YAAY;AACb;;AAEA;CACC,qBAAqB;CACrB,sBAAsB;CACtB,WAAW;CACX,YAAY;CACZ,oBAAoB;CACpB,YAAY;CACZ,oBAAoB;CACpB,kBAAkB;CAClB,YAAY;CACZ,cAAc;AACf;;AAEA;CACC,uBAAuB;AACxB;;AAEA;CACC,cAAc;CACd,qBAAqB,EAAE,6BAA6B;CACpD,aAAa;AACd;;AAEA;CACC,aAAa,EAAE,oCAAoC;AACpD;;AAEA;CACC,mBAAmB;AACpB;;AAEA;CACC,kBAAkB;CAClB,qBAAqB;CACrB,WAAW;CACX,MAAM;CACN,OAAO;CACP,sBAAsB;CACtB,qBAAqB;CACrB,kBAAkB;CAClB,qBAAqB;AACtB;;AAEA,iBAAiB;;AAEjB;CACC,iBAAiB;AAClB;;AAEA;CACC,qBAAqB;CACrB,gBAAgB;CAChB,gBAAgB;CAChB,WAAW;CACX,sBAAsB;CACtB,cAAc;CACd,eAAe;CACf,iBAAiB;CACjB,gBAAgB;CAChB,qBAAqB;AACtB;;AAEA,uBAAuB;AACvB;CACC,kBAAkB;CAClB,UAAU;CACV,QAAQ;AACT;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,4BAA4B;CAC5B,WAAW;CACX,YAAY;AACb","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-inputbox {\n\tposition: relative;\n\tdisplay: block;\n\tpadding: 0;\n\tbox-sizing:\tborder-box;\n\tborder-radius: 2px;\n\n\t/* Customizable */\n\tfont-size: inherit;\n}\n\n.monaco-inputbox > .ibwrapper > .input,\n.monaco-inputbox > .ibwrapper > .mirror {\n\n\t/* Customizable */\n\tpadding: 4px 6px;\n}\n\n.monaco-inputbox > .ibwrapper {\n\tposition: relative;\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-inputbox > .ibwrapper > .input {\n\tdisplay: inline-block;\n\tbox-sizing:\tborder-box;\n\twidth: 100%;\n\theight: 100%;\n\tline-height: inherit;\n\tborder: none;\n\tfont-family: inherit;\n\tfont-size: inherit;\n\tresize: none;\n\tcolor: inherit;\n}\n\n.monaco-inputbox > .ibwrapper > input {\n\ttext-overflow: ellipsis;\n}\n\n.monaco-inputbox > .ibwrapper > textarea.input {\n\tdisplay: block;\n\tscrollbar-width: none; /* Firefox: hide scrollbars */\n\toutline: none;\n}\n\n.monaco-inputbox > .ibwrapper > textarea.input::-webkit-scrollbar {\n\tdisplay: none; /* Chrome + Safari: hide scrollbar */\n}\n\n.monaco-inputbox > .ibwrapper > textarea.input.empty {\n\twhite-space: nowrap;\n}\n\n.monaco-inputbox > .ibwrapper > .mirror {\n\tposition: absolute;\n\tdisplay: inline-block;\n\twidth: 100%;\n\ttop: 0;\n\tleft: 0;\n\tbox-sizing: border-box;\n\twhite-space: pre-wrap;\n\tvisibility: hidden;\n\tword-wrap: break-word;\n}\n\n/* Context view */\n\n.monaco-inputbox-container {\n\ttext-align: right;\n}\n\n.monaco-inputbox-container .monaco-inputbox-message {\n\tdisplay: inline-block;\n\toverflow: hidden;\n\ttext-align: left;\n\twidth: 100%;\n\tbox-sizing:\tborder-box;\n\tpadding: 0.4em;\n\tfont-size: 12px;\n\tline-height: 17px;\n\tmargin-top: -1px;\n\tword-wrap: break-word;\n}\n\n/* Action bar support */\n.monaco-inputbox .monaco-action-bar {\n\tposition: absolute;\n\tright: 2px;\n\ttop: 4px;\n}\n\n.monaco-inputbox .monaco-action-bar .action-item {\n\tmargin-left: 2px;\n}\n\n.monaco-inputbox .monaco-action-bar .action-item .codicon {\n\tbackground-repeat: no-repeat;\n\twidth: 16px;\n\theight: 16px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.css": +/*!*************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.css ***! + \*************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-keybinding { + display: flex; + align-items: center; + line-height: 10px; +} + +.monaco-keybinding > .monaco-keybinding-key { + display: inline-block; + border-style: solid; + border-width: 1px; + border-radius: 3px; + vertical-align: middle; + font-size: 11px; + padding: 3px 5px; + margin: 0 2px; +} + +.monaco-keybinding > .monaco-keybinding-key:first-child { + margin-left: 0; +} + +.monaco-keybinding > .monaco-keybinding-key:last-child { + margin-right: 0; +} + +.monaco-keybinding > .monaco-keybinding-key-separator { + display: inline-block; +} + +.monaco-keybinding > .monaco-keybinding-key-chord-separator { + width: 6px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,aAAa;CACb,mBAAmB;CACnB,iBAAiB;AAClB;;AAEA;CACC,qBAAqB;CACrB,mBAAmB;CACnB,iBAAiB;CACjB,kBAAkB;CAClB,sBAAsB;CACtB,eAAe;CACf,gBAAgB;CAChB,aAAa;AACd;;AAEA;CACC,cAAc;AACf;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,qBAAqB;AACtB;;AAEA;CACC,UAAU;AACX","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-keybinding {\n\tdisplay: flex;\n\talign-items: center;\n\tline-height: 10px;\n}\n\n.monaco-keybinding > .monaco-keybinding-key {\n\tdisplay: inline-block;\n\tborder-style: solid;\n\tborder-width: 1px;\n\tborder-radius: 3px;\n\tvertical-align: middle;\n\tfont-size: 11px;\n\tpadding: 3px 5px;\n\tmargin: 0 2px;\n}\n\n.monaco-keybinding > .monaco-keybinding-key:first-child {\n\tmargin-left: 0;\n}\n\n.monaco-keybinding > .monaco-keybinding-key:last-child {\n\tmargin-right: 0;\n}\n\n.monaco-keybinding > .monaco-keybinding-key-separator {\n\tdisplay: inline-block;\n}\n\n.monaco-keybinding > .monaco-keybinding-key-chord-separator {\n\twidth: 6px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/list/list.css": +/*!***************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/list/list.css ***! + \***************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-list { + position: relative; + height: 100%; + width: 100%; + white-space: nowrap; +} + +.monaco-list.mouse-support { + user-select: none; + -webkit-user-select: none; +} + +.monaco-list > .monaco-scrollable-element { + height: 100%; +} + +.monaco-list-rows { + position: relative; + width: 100%; + height: 100%; +} + +.monaco-list.horizontal-scrolling .monaco-list-rows { + width: auto; + min-width: 100%; +} + +.monaco-list-row { + position: absolute; + box-sizing: border-box; + overflow: hidden; + width: 100%; +} + +.monaco-list.mouse-support .monaco-list-row { + cursor: pointer; + touch-action: none; +} + +/* Make sure the scrollbar renders above overlays (sticky scroll) */ +.monaco-list .monaco-scrollable-element > .scrollbar.vertical, +.monaco-pane-view > .monaco-split-view2.vertical > .monaco-scrollable-element > .scrollbar.vertical { + z-index: 14; +} + +/* for OS X ballistic scrolling */ +.monaco-list-row.scrolling { + display: none !important; +} + +/* Focus */ +.monaco-list.element-focused, +.monaco-list.selection-single, +.monaco-list.selection-multiple { + outline: 0 !important; +} + +/* Dnd */ +.monaco-drag-image { + display: inline-block; + padding: 1px 7px; + border-radius: 10px; + font-size: 12px; + position: absolute; + z-index: 1000; +} + +/* Filter */ + +.monaco-list-type-filter-message { + position: absolute; + box-sizing: border-box; + width: 100%; + height: 100%; + top: 0; + left: 0; + padding: 40px 1em 1em 1em; + text-align: center; + white-space: normal; + opacity: 0.7; + pointer-events: none; +} + +.monaco-list-type-filter-message:empty { + display: none; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/list/list.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,YAAY;CACZ,WAAW;CACX,mBAAmB;AACpB;;AAEA;CACC,iBAAiB;CACjB,yBAAyB;AAC1B;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,kBAAkB;CAClB,WAAW;CACX,YAAY;AACb;;AAEA;CACC,WAAW;CACX,eAAe;AAChB;;AAEA;CACC,kBAAkB;CAClB,sBAAsB;CACtB,gBAAgB;CAChB,WAAW;AACZ;;AAEA;CACC,eAAe;CACf,kBAAkB;AACnB;;AAEA,mEAAmE;AACnE;;CAEC,WAAW;AACZ;;AAEA,iCAAiC;AACjC;CACC,wBAAwB;AACzB;;AAEA,UAAU;AACV;;;CAGC,qBAAqB;AACtB;;AAEA,QAAQ;AACR;CACC,qBAAqB;CACrB,gBAAgB;CAChB,mBAAmB;CACnB,eAAe;CACf,kBAAkB;CAClB,aAAa;AACd;;AAEA,WAAW;;AAEX;CACC,kBAAkB;CAClB,sBAAsB;CACtB,WAAW;CACX,YAAY;CACZ,MAAM;CACN,OAAO;CACP,yBAAyB;CACzB,kBAAkB;CAClB,mBAAmB;CACnB,YAAY;CACZ,oBAAoB;AACrB;;AAEA;CACC,aAAa;AACd","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-list {\n\tposition: relative;\n\theight: 100%;\n\twidth: 100%;\n\twhite-space: nowrap;\n}\n\n.monaco-list.mouse-support {\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n.monaco-list > .monaco-scrollable-element {\n\theight: 100%;\n}\n\n.monaco-list-rows {\n\tposition: relative;\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-list.horizontal-scrolling .monaco-list-rows {\n\twidth: auto;\n\tmin-width: 100%;\n}\n\n.monaco-list-row {\n\tposition: absolute;\n\tbox-sizing: border-box;\n\toverflow: hidden;\n\twidth: 100%;\n}\n\n.monaco-list.mouse-support .monaco-list-row {\n\tcursor: pointer;\n\ttouch-action: none;\n}\n\n/* Make sure the scrollbar renders above overlays (sticky scroll) */\n.monaco-list .monaco-scrollable-element > .scrollbar.vertical,\n.monaco-pane-view > .monaco-split-view2.vertical > .monaco-scrollable-element > .scrollbar.vertical {\n\tz-index: 14;\n}\n\n/* for OS X ballistic scrolling */\n.monaco-list-row.scrolling {\n\tdisplay: none !important;\n}\n\n/* Focus */\n.monaco-list.element-focused,\n.monaco-list.selection-single,\n.monaco-list.selection-multiple {\n\toutline: 0 !important;\n}\n\n/* Dnd */\n.monaco-drag-image {\n\tdisplay: inline-block;\n\tpadding: 1px 7px;\n\tborder-radius: 10px;\n\tfont-size: 12px;\n\tposition: absolute;\n\tz-index: 1000;\n}\n\n/* Filter */\n\n.monaco-list-type-filter-message {\n\tposition: absolute;\n\tbox-sizing: border-box;\n\twidth: 100%;\n\theight: 100%;\n\ttop: 0;\n\tleft: 0;\n\tpadding: 40px 1em 1em 1em;\n\ttext-align: center;\n\twhite-space: normal;\n\topacity: 0.7;\n\tpointer-events: none;\n}\n\n.monaco-list-type-filter-message:empty {\n\tdisplay: none;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/mouseCursor/mouseCursor.css": +/*!*****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/mouseCursor/mouseCursor.css ***! + \*****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-mouse-cursor-text { + cursor: text; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/mouseCursor/mouseCursor.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,YAAY;AACb","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-mouse-cursor-text {\n\tcursor: text;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.css": +/*!*****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.css ***! + \*****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-progress-container { + width: 100%; + height: 2px; + overflow: hidden; /* keep progress bit in bounds */ +} + +.monaco-progress-container .progress-bit { + width: 2%; + height: 2px; + position: absolute; + left: 0; + display: none; +} + +.monaco-progress-container.active .progress-bit { + display: inherit; +} + +.monaco-progress-container.discrete .progress-bit { + left: 0; + transition: width 100ms linear; +} + +.monaco-progress-container.discrete.done .progress-bit { + width: 100%; +} + +.monaco-progress-container.infinite .progress-bit { + animation-name: progress; + animation-duration: 4s; + animation-iteration-count: infinite; + transform: translate3d(0px, 0px, 0px); + animation-timing-function: linear; +} + +.monaco-progress-container.infinite.infinite-long-running .progress-bit { + /* + The more smooth \`linear\` timing function can cause + higher GPU consumption as indicated in + https://github.com/microsoft/vscode/issues/97900 & + https://github.com/microsoft/vscode/issues/138396 + */ + animation-timing-function: steps(100); +} + +/** + * The progress bit has a width: 2% (1/50) of the parent container. The animation moves it from 0% to 100% of + * that container. Since translateX is relative to the progress bit size, we have to multiple it with + * its relative size to the parent container: + * parent width: 5000% + * bit width: 100% + * translateX should be as follow: + * 50%: 5000% * 50% - 50% (set to center) = 2450% + * 100%: 5000% * 100% - 100% (do not overflow) = 4900% + */ +@keyframes progress { from { transform: translateX(0%) scaleX(1) } 50% { transform: translateX(2500%) scaleX(3) } to { transform: translateX(4900%) scaleX(1) } } +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,WAAW;CACX,WAAW;CACX,gBAAgB,EAAE,gCAAgC;AACnD;;AAEA;CACC,SAAS;CACT,WAAW;CACX,kBAAkB;CAClB,OAAO;CACP,aAAa;AACd;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,OAAO;CACP,8BAA8B;AAC/B;;AAEA;CACC,WAAW;AACZ;;AAEA;CACC,wBAAwB;CACxB,sBAAsB;CACtB,mCAAmC;CACnC,qCAAqC;CACrC,iCAAiC;AAClC;;AAEA;CACC;;;;;EAKC;CACD,qCAAqC;AACtC;;AAEA;;;;;;;;;EASE;AACF,sBAAsB,OAAO,oCAAoC,EAAE,MAAM,uCAAuC,EAAE,KAAK,uCAAuC,EAAE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-progress-container {\n\twidth: 100%;\n\theight: 2px;\n\toverflow: hidden; /* keep progress bit in bounds */\n}\n\n.monaco-progress-container .progress-bit {\n\twidth: 2%;\n\theight: 2px;\n\tposition: absolute;\n\tleft: 0;\n\tdisplay: none;\n}\n\n.monaco-progress-container.active .progress-bit {\n\tdisplay: inherit;\n}\n\n.monaco-progress-container.discrete .progress-bit {\n\tleft: 0;\n\ttransition: width 100ms linear;\n}\n\n.monaco-progress-container.discrete.done .progress-bit {\n\twidth: 100%;\n}\n\n.monaco-progress-container.infinite .progress-bit {\n\tanimation-name: progress;\n\tanimation-duration: 4s;\n\tanimation-iteration-count: infinite;\n\ttransform: translate3d(0px, 0px, 0px);\n\tanimation-timing-function: linear;\n}\n\n.monaco-progress-container.infinite.infinite-long-running .progress-bit {\n\t/*\n\t\tThe more smooth `linear` timing function can cause\n\t\thigher GPU consumption as indicated in\n\t\thttps://github.com/microsoft/vscode/issues/97900 &\n\t\thttps://github.com/microsoft/vscode/issues/138396\n\t*/\n\tanimation-timing-function: steps(100);\n}\n\n/**\n * The progress bit has a width: 2% (1/50) of the parent container. The animation moves it from 0% to 100% of\n * that container. Since translateX is relative to the progress bit size, we have to multiple it with\n * its relative size to the parent container:\n * parent width: 5000%\n * bit width: 100%\n * translateX should be as follow:\n * 50%: 5000% * 50% - 50% (set to center) = 2450%\n * 100%: 5000% * 100% - 100% (do not overflow) = 4900%\n */\n@keyframes progress { from { transform: translateX(0%) scaleX(1) } 50% { transform: translateX(2500%) scaleX(3) } to { transform: translateX(4900%) scaleX(1) } }\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/sash/sash.css": +/*!***************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/sash/sash.css ***! + \***************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +:root { + --vscode-sash-size: 4px; + --vscode-sash-hover-size: 4px; +} + +.monaco-sash { + position: absolute; + z-index: 35; + touch-action: none; +} + +.monaco-sash.disabled { + pointer-events: none; +} + +.monaco-sash.mac.vertical { + cursor: col-resize; +} + +.monaco-sash.vertical.minimum { + cursor: e-resize; +} + +.monaco-sash.vertical.maximum { + cursor: w-resize; +} + +.monaco-sash.mac.horizontal { + cursor: row-resize; +} + +.monaco-sash.horizontal.minimum { + cursor: s-resize; +} + +.monaco-sash.horizontal.maximum { + cursor: n-resize; +} + +.monaco-sash.disabled { + cursor: default !important; + pointer-events: none !important; +} + +.monaco-sash.vertical { + cursor: ew-resize; + top: 0; + width: var(--vscode-sash-size); + height: 100%; +} + +.monaco-sash.horizontal { + cursor: ns-resize; + left: 0; + width: 100%; + height: var(--vscode-sash-size); +} + +.monaco-sash:not(.disabled) > .orthogonal-drag-handle { + content: " "; + height: calc(var(--vscode-sash-size) * 2); + width: calc(var(--vscode-sash-size) * 2); + z-index: 100; + display: block; + cursor: all-scroll; + position: absolute; +} + +.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled) + > .orthogonal-drag-handle.start, +.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled) + > .orthogonal-drag-handle.end { + cursor: nwse-resize; +} + +.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled) + > .orthogonal-drag-handle.end, +.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled) + > .orthogonal-drag-handle.start { + cursor: nesw-resize; +} + +.monaco-sash.vertical > .orthogonal-drag-handle.start { + left: calc(var(--vscode-sash-size) * -0.5); + top: calc(var(--vscode-sash-size) * -1); +} +.monaco-sash.vertical > .orthogonal-drag-handle.end { + left: calc(var(--vscode-sash-size) * -0.5); + bottom: calc(var(--vscode-sash-size) * -1); +} +.monaco-sash.horizontal > .orthogonal-drag-handle.start { + top: calc(var(--vscode-sash-size) * -0.5); + left: calc(var(--vscode-sash-size) * -1); +} +.monaco-sash.horizontal > .orthogonal-drag-handle.end { + top: calc(var(--vscode-sash-size) * -0.5); + right: calc(var(--vscode-sash-size) * -1); +} + +.monaco-sash:before { + content: ''; + pointer-events: none; + position: absolute; + width: 100%; + height: 100%; + background: transparent; +} + +.monaco-workbench:not(.reduce-motion) .monaco-sash:before { + transition: background-color 0.1s ease-out; +} + +.monaco-sash.hover:before, +.monaco-sash.active:before { + background: var(--vscode-sash-hoverBorder); +} + +.monaco-sash.vertical:before { + width: var(--vscode-sash-hover-size); + left: calc(50% - (var(--vscode-sash-hover-size) / 2)); +} + +.monaco-sash.horizontal:before { + height: var(--vscode-sash-hover-size); + top: calc(50% - (var(--vscode-sash-hover-size) / 2)); +} + +.pointer-events-disabled { + pointer-events: none !important; +} + +/** Debug **/ + +.monaco-sash.debug { + background: cyan; +} + +.monaco-sash.debug.disabled { + background: rgba(0, 255, 255, 0.2); +} + +.monaco-sash.debug:not(.disabled) > .orthogonal-drag-handle { + background: red; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/sash/sash.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,uBAAuB;CACvB,6BAA6B;AAC9B;;AAEA;CACC,kBAAkB;CAClB,WAAW;CACX,kBAAkB;AACnB;;AAEA;CACC,oBAAoB;AACrB;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,0BAA0B;CAC1B,+BAA+B;AAChC;;AAEA;CACC,iBAAiB;CACjB,MAAM;CACN,8BAA8B;CAC9B,YAAY;AACb;;AAEA;CACC,iBAAiB;CACjB,OAAO;CACP,WAAW;CACX,+BAA+B;AAChC;;AAEA;CACC,YAAY;CACZ,yCAAyC;CACzC,wCAAwC;CACxC,YAAY;CACZ,cAAc;CACd,kBAAkB;CAClB,kBAAkB;AACnB;;AAEA;;;;CAIC,mBAAmB;AACpB;;AAEA;;;;CAIC,mBAAmB;AACpB;;AAEA;CACC,0CAA0C;CAC1C,uCAAuC;AACxC;AACA;CACC,0CAA0C;CAC1C,0CAA0C;AAC3C;AACA;CACC,yCAAyC;CACzC,wCAAwC;AACzC;AACA;CACC,yCAAyC;CACzC,yCAAyC;AAC1C;;AAEA;CACC,WAAW;CACX,oBAAoB;CACpB,kBAAkB;CAClB,WAAW;CACX,YAAY;CACZ,uBAAuB;AACxB;;AAEA;CACC,0CAA0C;AAC3C;;AAEA;;CAEC,0CAA0C;AAC3C;;AAEA;CACC,oCAAoC;CACpC,qDAAqD;AACtD;;AAEA;CACC,qCAAqC;CACrC,oDAAoD;AACrD;;AAEA;CACC,+BAA+B;AAChC;;AAEA,YAAY;;AAEZ;CACC,gBAAgB;AACjB;;AAEA;CACC,kCAAkC;AACnC;;AAEA;CACC,eAAe;AAChB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n:root {\n\t--vscode-sash-size: 4px;\n\t--vscode-sash-hover-size: 4px;\n}\n\n.monaco-sash {\n\tposition: absolute;\n\tz-index: 35;\n\ttouch-action: none;\n}\n\n.monaco-sash.disabled {\n\tpointer-events: none;\n}\n\n.monaco-sash.mac.vertical {\n\tcursor: col-resize;\n}\n\n.monaco-sash.vertical.minimum {\n\tcursor: e-resize;\n}\n\n.monaco-sash.vertical.maximum {\n\tcursor: w-resize;\n}\n\n.monaco-sash.mac.horizontal {\n\tcursor: row-resize;\n}\n\n.monaco-sash.horizontal.minimum {\n\tcursor: s-resize;\n}\n\n.monaco-sash.horizontal.maximum {\n\tcursor: n-resize;\n}\n\n.monaco-sash.disabled {\n\tcursor: default !important;\n\tpointer-events: none !important;\n}\n\n.monaco-sash.vertical {\n\tcursor: ew-resize;\n\ttop: 0;\n\twidth: var(--vscode-sash-size);\n\theight: 100%;\n}\n\n.monaco-sash.horizontal {\n\tcursor: ns-resize;\n\tleft: 0;\n\twidth: 100%;\n\theight: var(--vscode-sash-size);\n}\n\n.monaco-sash:not(.disabled) > .orthogonal-drag-handle {\n\tcontent: \" \";\n\theight: calc(var(--vscode-sash-size) * 2);\n\twidth: calc(var(--vscode-sash-size) * 2);\n\tz-index: 100;\n\tdisplay: block;\n\tcursor: all-scroll;\n\tposition: absolute;\n}\n\n.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled)\n\t> .orthogonal-drag-handle.start,\n.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled)\n\t> .orthogonal-drag-handle.end {\n\tcursor: nwse-resize;\n}\n\n.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled)\n\t> .orthogonal-drag-handle.end,\n.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled)\n\t> .orthogonal-drag-handle.start {\n\tcursor: nesw-resize;\n}\n\n.monaco-sash.vertical > .orthogonal-drag-handle.start {\n\tleft: calc(var(--vscode-sash-size) * -0.5);\n\ttop: calc(var(--vscode-sash-size) * -1);\n}\n.monaco-sash.vertical > .orthogonal-drag-handle.end {\n\tleft: calc(var(--vscode-sash-size) * -0.5);\n\tbottom: calc(var(--vscode-sash-size) * -1);\n}\n.monaco-sash.horizontal > .orthogonal-drag-handle.start {\n\ttop: calc(var(--vscode-sash-size) * -0.5);\n\tleft: calc(var(--vscode-sash-size) * -1);\n}\n.monaco-sash.horizontal > .orthogonal-drag-handle.end {\n\ttop: calc(var(--vscode-sash-size) * -0.5);\n\tright: calc(var(--vscode-sash-size) * -1);\n}\n\n.monaco-sash:before {\n\tcontent: '';\n\tpointer-events: none;\n\tposition: absolute;\n\twidth: 100%;\n\theight: 100%;\n\tbackground: transparent;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-sash:before {\n\ttransition: background-color 0.1s ease-out;\n}\n\n.monaco-sash.hover:before,\n.monaco-sash.active:before {\n\tbackground: var(--vscode-sash-hoverBorder);\n}\n\n.monaco-sash.vertical:before {\n\twidth: var(--vscode-sash-hover-size);\n\tleft: calc(50% - (var(--vscode-sash-hover-size) / 2));\n}\n\n.monaco-sash.horizontal:before {\n\theight: var(--vscode-sash-hover-size);\n\ttop: calc(50% - (var(--vscode-sash-hover-size) / 2));\n}\n\n.pointer-events-disabled {\n\tpointer-events: none !important;\n}\n\n/** Debug **/\n\n.monaco-sash.debug {\n\tbackground: cyan;\n}\n\n.monaco-sash.debug.disabled {\n\tbackground: rgba(0, 255, 255, 0.2);\n}\n\n.monaco-sash.debug:not(.disabled) > .orthogonal-drag-handle {\n\tbackground: red;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/scrollbar/media/scrollbars.css": +/*!********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/scrollbar/media/scrollbars.css ***! + \********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* Arrows */ +.monaco-scrollable-element > .scrollbar > .scra { + cursor: pointer; + font-size: 11px !important; +} + +.monaco-scrollable-element > .visible { + opacity: 1; + + /* Background rule added for IE9 - to allow clicks on dom node */ + background:rgba(0,0,0,0); + + transition: opacity 100ms linear; + /* In front of peek view */ + z-index: 11; +} +.monaco-scrollable-element > .invisible { + opacity: 0; + pointer-events: none; +} +.monaco-scrollable-element > .invisible.fade { + transition: opacity 800ms linear; +} + +/* Scrollable Content Inset Shadow */ +.monaco-scrollable-element > .shadow { + position: absolute; + display: none; +} +.monaco-scrollable-element > .shadow.top { + display: block; + top: 0; + left: 3px; + height: 3px; + width: 100%; + box-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset; +} +.monaco-scrollable-element > .shadow.left { + display: block; + top: 3px; + left: 0; + height: 100%; + width: 3px; + box-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset; +} +.monaco-scrollable-element > .shadow.top-left-corner { + display: block; + top: 0; + left: 0; + height: 3px; + width: 3px; +} +.monaco-scrollable-element > .shadow.top.left { + box-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset; +} + +.monaco-scrollable-element > .scrollbar > .slider { + background: var(--vscode-scrollbarSlider-background); +} + +.monaco-scrollable-element > .scrollbar > .slider:hover { + background: var(--vscode-scrollbarSlider-hoverBackground); +} + +.monaco-scrollable-element > .scrollbar > .slider.active { + background: var(--vscode-scrollbarSlider-activeBackground); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/scrollbar/media/scrollbars.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,WAAW;AACX;CACC,eAAe;CACf,0BAA0B;AAC3B;;AAEA;CACC,UAAU;;CAEV,gEAAgE;CAChE,wBAAwB;;CAExB,gCAAgC;CAChC,0BAA0B;CAC1B,WAAW;AACZ;AACA;CACC,UAAU;CACV,oBAAoB;AACrB;AACA;CACC,gCAAgC;AACjC;;AAEA,oCAAoC;AACpC;CACC,kBAAkB;CAClB,aAAa;AACd;AACA;CACC,cAAc;CACd,MAAM;CACN,SAAS;CACT,WAAW;CACX,WAAW;CACX,+DAA+D;AAChE;AACA;CACC,cAAc;CACd,QAAQ;CACR,OAAO;CACP,YAAY;CACZ,UAAU;CACV,+DAA+D;AAChE;AACA;CACC,cAAc;CACd,MAAM;CACN,OAAO;CACP,WAAW;CACX,UAAU;AACX;AACA;CACC,+DAA+D;AAChE;;AAEA;CACC,oDAAoD;AACrD;;AAEA;CACC,yDAAyD;AAC1D;;AAEA;CACC,0DAA0D;AAC3D","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Arrows */\n.monaco-scrollable-element > .scrollbar > .scra {\n\tcursor: pointer;\n\tfont-size: 11px !important;\n}\n\n.monaco-scrollable-element > .visible {\n\topacity: 1;\n\n\t/* Background rule added for IE9 - to allow clicks on dom node */\n\tbackground:rgba(0,0,0,0);\n\n\ttransition: opacity 100ms linear;\n\t/* In front of peek view */\n\tz-index: 11;\n}\n.monaco-scrollable-element > .invisible {\n\topacity: 0;\n\tpointer-events: none;\n}\n.monaco-scrollable-element > .invisible.fade {\n\ttransition: opacity 800ms linear;\n}\n\n/* Scrollable Content Inset Shadow */\n.monaco-scrollable-element > .shadow {\n\tposition: absolute;\n\tdisplay: none;\n}\n.monaco-scrollable-element > .shadow.top {\n\tdisplay: block;\n\ttop: 0;\n\tleft: 3px;\n\theight: 3px;\n\twidth: 100%;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset;\n}\n.monaco-scrollable-element > .shadow.left {\n\tdisplay: block;\n\ttop: 3px;\n\tleft: 0;\n\theight: 100%;\n\twidth: 3px;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset;\n}\n.monaco-scrollable-element > .shadow.top-left-corner {\n\tdisplay: block;\n\ttop: 0;\n\tleft: 0;\n\theight: 3px;\n\twidth: 3px;\n}\n.monaco-scrollable-element > .shadow.top.left {\n\tbox-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset;\n}\n\n.monaco-scrollable-element > .scrollbar > .slider {\n\tbackground: var(--vscode-scrollbarSlider-background);\n}\n\n.monaco-scrollable-element > .scrollbar > .slider:hover {\n\tbackground: var(--vscode-scrollbarSlider-hoverBackground);\n}\n\n.monaco-scrollable-element > .scrollbar > .slider.active {\n\tbackground: var(--vscode-scrollbarSlider-activeBackground);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBox.css": +/*!*************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBox.css ***! + \*************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-select-box { + width: 100%; + cursor: pointer; + border-radius: 2px; +} + +.monaco-select-box-dropdown-container { + font-size: 13px; + font-weight: normal; + text-transform: none; +} + +/** Actions */ + +.monaco-action-bar .action-item.select-container { + cursor: default; +} + +.monaco-action-bar .action-item .monaco-select-box { + cursor: pointer; + min-width: 100px; + min-height: 18px; + padding: 2px 23px 2px 8px; +} + +.mac .monaco-action-bar .action-item .monaco-select-box { + font-size: 11px; + border-radius: 5px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBox.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,WAAW;CACX,eAAe;CACf,kBAAkB;AACnB;;AAEA;CACC,eAAe;CACf,mBAAmB;CACnB,oBAAoB;AACrB;;AAEA,aAAa;;AAEb;CACC,eAAe;AAChB;;AAEA;CACC,eAAe;CACf,gBAAgB;CAChB,gBAAgB;CAChB,yBAAyB;AAC1B;;AAEA;CACC,eAAe;CACf,kBAAkB;AACnB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-select-box {\n\twidth: 100%;\n\tcursor: pointer;\n\tborder-radius: 2px;\n}\n\n.monaco-select-box-dropdown-container {\n\tfont-size: 13px;\n\tfont-weight: normal;\n\ttext-transform: none;\n}\n\n/** Actions */\n\n.monaco-action-bar .action-item.select-container {\n\tcursor: default;\n}\n\n.monaco-action-bar .action-item .monaco-select-box {\n\tcursor: pointer;\n\tmin-width: 100px;\n\tmin-height: 18px;\n\tpadding: 2px 23px 2px 8px;\n}\n\n.mac .monaco-action-bar .action-item .monaco-select-box {\n\tfont-size: 11px;\n\tborder-radius: 5px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBoxCustom.css": +/*!*******************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBoxCustom.css ***! + \*******************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* Use custom CSS vars to expose padding into parent select for padding calculation */ +.monaco-select-box-dropdown-padding { + --dropdown-padding-top: 1px; + --dropdown-padding-bottom: 1px; +} + +.hc-black .monaco-select-box-dropdown-padding, +.hc-light .monaco-select-box-dropdown-padding { + --dropdown-padding-top: 3px; + --dropdown-padding-bottom: 4px; +} + +.monaco-select-box-dropdown-container { + display: none; + box-sizing: border-box; +} + +.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown * { + margin: 0; +} + +.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown a:focus { + outline: 1px solid -webkit-focus-ring-color; + outline-offset: -1px; +} + +.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown code { + line-height: 15px; /** For some reason, this is needed, otherwise will take up 20px height */ + font-family: var(--monaco-monospace-font); +} + + +.monaco-select-box-dropdown-container.visible { + display: flex; + flex-direction: column; + text-align: left; + width: 1px; + overflow: hidden; + border-bottom-left-radius: 3px; + border-bottom-right-radius: 3px; +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container { + flex: 0 0 auto; + align-self: flex-start; + padding-top: var(--dropdown-padding-top); + padding-bottom: var(--dropdown-padding-bottom); + padding-left: 1px; + padding-right: 1px; + width: 100%; + overflow: hidden; + box-sizing: border-box; +} + +.monaco-select-box-dropdown-container > .select-box-details-pane { + padding: 5px; +} + +.hc-black .monaco-select-box-dropdown-container > .select-box-dropdown-list-container { + padding-top: var(--dropdown-padding-top); + padding-bottom: var(--dropdown-padding-bottom); +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row { + cursor: pointer; +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-text { + text-overflow: ellipsis; + overflow: hidden; + padding-left: 3.5px; + white-space: nowrap; + float: left; +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-detail { + text-overflow: ellipsis; + overflow: hidden; + padding-left: 3.5px; + white-space: nowrap; + float: left; + opacity: 0.7; +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-decorator-right { + text-overflow: ellipsis; + overflow: hidden; + padding-right: 10px; + white-space: nowrap; + float: right; +} + + +/* Accepted CSS hiding technique for accessibility reader text */ +/* https://webaim.org/techniques/css/invisiblecontent/ */ + +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .visually-hidden { + position: absolute; + left: -10000px; + top: auto; + width: 1px; + height: 1px; + overflow: hidden; +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control { + flex: 1 1 auto; + align-self: flex-start; + opacity: 0; +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div { + overflow: hidden; + max-height: 0px; +} + +.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div > .option-text-width-control { + padding-left: 4px; + padding-right: 8px; + white-space: nowrap; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBoxCustom.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,qFAAqF;AACrF;CACC,2BAA2B;CAC3B,8BAA8B;AAC/B;;AAEA;;CAEC,2BAA2B;CAC3B,8BAA8B;AAC/B;;AAEA;CACC,aAAa;CACb,sBAAsB;AACvB;;AAEA;CACC,SAAS;AACV;;AAEA;CACC,2CAA2C;CAC3C,oBAAoB;AACrB;;AAEA;CACC,iBAAiB,EAAE,gFAAgF;CACnG,yCAAyC;AAC1C;;;AAGA;CACC,aAAa;CACb,sBAAsB;CACtB,gBAAgB;CAChB,UAAU;CACV,gBAAgB;CAChB,8BAA8B;CAC9B,+BAA+B;AAChC;;AAEA;CACC,cAAc;CACd,sBAAsB;CACtB,wCAAwC;CACxC,8CAA8C;CAC9C,iBAAiB;CACjB,kBAAkB;CAClB,WAAW;CACX,gBAAgB;CAChB,sBAAsB;AACvB;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,wCAAwC;CACxC,8CAA8C;AAC/C;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,uBAAuB;CACvB,gBAAgB;CAChB,mBAAmB;CACnB,mBAAmB;CACnB,WAAW;AACZ;;AAEA;CACC,uBAAuB;CACvB,gBAAgB;CAChB,mBAAmB;CACnB,mBAAmB;CACnB,WAAW;CACX,YAAY;AACb;;AAEA;CACC,uBAAuB;CACvB,gBAAgB;CAChB,mBAAmB;CACnB,mBAAmB;CACnB,YAAY;AACb;;;AAGA,iEAAiE;AACjE,wDAAwD;;AAExD;EACE,kBAAkB;EAClB,cAAc;EACd,SAAS;EACT,UAAU;EACV,WAAW;EACX,gBAAgB;AAClB;;AAEA;CACC,cAAc;CACd,sBAAsB;CACtB,UAAU;AACX;;AAEA;CACC,gBAAgB;CAChB,eAAe;AAChB;;AAEA;CACC,iBAAiB;CACjB,kBAAkB;CAClB,mBAAmB;AACpB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Use custom CSS vars to expose padding into parent select for padding calculation */\n.monaco-select-box-dropdown-padding {\n\t--dropdown-padding-top: 1px;\n\t--dropdown-padding-bottom: 1px;\n}\n\n.hc-black .monaco-select-box-dropdown-padding,\n.hc-light .monaco-select-box-dropdown-padding {\n\t--dropdown-padding-top: 3px;\n\t--dropdown-padding-bottom: 4px;\n}\n\n.monaco-select-box-dropdown-container {\n\tdisplay: none;\n\tbox-sizing:\tborder-box;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown * {\n\tmargin: 0;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown a:focus {\n\toutline: 1px solid -webkit-focus-ring-color;\n\toutline-offset: -1px;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown code {\n\tline-height: 15px; /** For some reason, this is needed, otherwise will take up 20px height */\n\tfont-family: var(--monaco-monospace-font);\n}\n\n\n.monaco-select-box-dropdown-container.visible {\n\tdisplay: flex;\n\tflex-direction: column;\n\ttext-align: left;\n\twidth: 1px;\n\toverflow: hidden;\n\tborder-bottom-left-radius: 3px;\n\tborder-bottom-right-radius: 3px;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container {\n\tflex: 0 0 auto;\n\talign-self: flex-start;\n\tpadding-top: var(--dropdown-padding-top);\n\tpadding-bottom: var(--dropdown-padding-bottom);\n\tpadding-left: 1px;\n\tpadding-right: 1px;\n\twidth: 100%;\n\toverflow: hidden;\n\tbox-sizing:\tborder-box;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane {\n\tpadding: 5px;\n}\n\n.hc-black .monaco-select-box-dropdown-container > .select-box-dropdown-list-container {\n\tpadding-top: var(--dropdown-padding-top);\n\tpadding-bottom: var(--dropdown-padding-bottom);\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row {\n\tcursor: pointer;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-text {\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n\tpadding-left: 3.5px;\n\twhite-space: nowrap;\n\tfloat: left;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-detail {\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n\tpadding-left: 3.5px;\n\twhite-space: nowrap;\n\tfloat: left;\n\topacity: 0.7;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-decorator-right {\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n\tpadding-right: 10px;\n\twhite-space: nowrap;\n\tfloat: right;\n}\n\n\n/* Accepted CSS hiding technique for accessibility reader text */\n/* https://webaim.org/techniques/css/invisiblecontent/ */\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .visually-hidden {\n\t\tposition: absolute;\n\t\tleft: -10000px;\n\t\ttop: auto;\n\t\twidth: 1px;\n\t\theight: 1px;\n\t\toverflow: hidden;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control {\n\tflex: 1 1 auto;\n\talign-self: flex-start;\n\topacity: 0;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div {\n\toverflow: hidden;\n\tmax-height: 0px;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div > .option-text-width-control {\n\tpadding-left: 4px;\n\tpadding-right: 8px;\n\twhite-space: nowrap;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/splitview/splitview.css": +/*!*************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/splitview/splitview.css ***! + \*************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-split-view2 { + position: relative; + width: 100%; + height: 100%; +} + +.monaco-split-view2 > .sash-container { + position: absolute; + width: 100%; + height: 100%; + pointer-events: none; +} + +.monaco-split-view2 > .sash-container > .monaco-sash { + pointer-events: initial; +} + +.monaco-split-view2 > .monaco-scrollable-element { + width: 100%; + height: 100%; +} + +.monaco-split-view2 > .monaco-scrollable-element > .split-view-container { + width: 100%; + height: 100%; + white-space: nowrap; + position: relative; +} + +.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view { + white-space: initial; + position: absolute; +} + +.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view:not(.visible) { + display: none; +} + +.monaco-split-view2.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view { + width: 100%; +} + +.monaco-split-view2.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view { + height: 100%; +} + +.monaco-split-view2.separator-border > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before { + content: ' '; + position: absolute; + top: 0; + left: 0; + z-index: 5; + pointer-events: none; + background-color: var(--separator-border); +} + +.monaco-split-view2.separator-border.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before { + height: 100%; + width: 1px; +} + +.monaco-split-view2.separator-border.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before { + height: 1px; + width: 100%; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/splitview/splitview.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,WAAW;CACX,YAAY;AACb;;AAEA;CACC,kBAAkB;CAClB,WAAW;CACX,YAAY;CACZ,oBAAoB;AACrB;;AAEA;CACC,uBAAuB;AACxB;;AAEA;CACC,WAAW;CACX,YAAY;AACb;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,mBAAmB;CACnB,kBAAkB;AACnB;;AAEA;CACC,oBAAoB;CACpB,kBAAkB;AACnB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,WAAW;AACZ;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,YAAY;CACZ,kBAAkB;CAClB,MAAM;CACN,OAAO;CACP,UAAU;CACV,oBAAoB;CACpB,yCAAyC;AAC1C;;AAEA;CACC,YAAY;CACZ,UAAU;AACX;;AAEA;CACC,WAAW;CACX,WAAW;AACZ","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-split-view2 {\n\tposition: relative;\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-split-view2 > .sash-container {\n\tposition: absolute;\n\twidth: 100%;\n\theight: 100%;\n\tpointer-events: none;\n}\n\n.monaco-split-view2 > .sash-container > .monaco-sash {\n\tpointer-events: initial;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element {\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element > .split-view-container {\n\twidth: 100%;\n\theight: 100%;\n\twhite-space: nowrap;\n\tposition: relative;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view {\n\twhite-space: initial;\n\tposition: absolute;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view:not(.visible) {\n\tdisplay: none;\n}\n\n.monaco-split-view2.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view {\n\twidth: 100%;\n}\n\n.monaco-split-view2.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view {\n\theight: 100%;\n}\n\n.monaco-split-view2.separator-border > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before {\n\tcontent: ' ';\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\tz-index: 5;\n\tpointer-events: none;\n\tbackground-color: var(--separator-border);\n}\n\n.monaco-split-view2.separator-border.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before {\n\theight: 100%;\n\twidth: 1px;\n}\n\n.monaco-split-view2.separator-border.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before {\n\theight: 1px;\n\twidth: 100%;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/table/table.css": +/*!*****************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/table/table.css ***! + \*****************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-table { + display: flex; + flex-direction: column; + position: relative; + height: 100%; + width: 100%; + white-space: nowrap; + overflow: hidden; +} + +.monaco-table > .monaco-split-view2 { + border-bottom: 1px solid transparent; +} + +.monaco-table > .monaco-list { + flex: 1; +} + +.monaco-table-tr { + display: flex; + height: 100%; +} + +.monaco-table-th { + width: 100%; + height: 100%; + font-weight: bold; + overflow: hidden; + text-overflow: ellipsis; +} + +.monaco-table-th, +.monaco-table-td { + box-sizing: border-box; + flex-shrink: 0; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} + +.monaco-table > .monaco-split-view2 .monaco-sash.vertical::before { + content: ""; + position: absolute; + left: calc(var(--vscode-sash-size) / 2); + width: 0; + border-left: 1px solid transparent; +} + +.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2, +.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2 .monaco-sash.vertical::before { + transition: border-color 0.2s ease-out; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/table/table.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,aAAa;CACb,sBAAsB;CACtB,kBAAkB;CAClB,YAAY;CACZ,WAAW;CACX,mBAAmB;CACnB,gBAAgB;AACjB;;AAEA;CACC,oCAAoC;AACrC;;AAEA;CACC,OAAO;AACR;;AAEA;CACC,aAAa;CACb,YAAY;AACb;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,iBAAiB;CACjB,gBAAgB;CAChB,uBAAuB;AACxB;;AAEA;;CAEC,sBAAsB;CACtB,cAAc;CACd,gBAAgB;CAChB,mBAAmB;CACnB,uBAAuB;AACxB;;AAEA;CACC,WAAW;CACX,kBAAkB;CAClB,uCAAuC;CACvC,QAAQ;CACR,kCAAkC;AACnC;;AAEA;;CAEC,sCAAsC;AACvC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-table {\n\tdisplay: flex;\n\tflex-direction: column;\n\tposition: relative;\n\theight: 100%;\n\twidth: 100%;\n\twhite-space: nowrap;\n\toverflow: hidden;\n}\n\n.monaco-table > .monaco-split-view2 {\n\tborder-bottom: 1px solid transparent;\n}\n\n.monaco-table > .monaco-list {\n\tflex: 1;\n}\n\n.monaco-table-tr {\n\tdisplay: flex;\n\theight: 100%;\n}\n\n.monaco-table-th {\n\twidth: 100%;\n\theight: 100%;\n\tfont-weight: bold;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-table-th,\n.monaco-table-td {\n\tbox-sizing: border-box;\n\tflex-shrink: 0;\n\toverflow: hidden;\n\twhite-space: nowrap;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-table > .monaco-split-view2 .monaco-sash.vertical::before {\n\tcontent: \"\";\n\tposition: absolute;\n\tleft: calc(var(--vscode-sash-size) / 2);\n\twidth: 0;\n\tborder-left: 1px solid transparent;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2,\n.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2 .monaco-sash.vertical::before {\n\ttransition: border-color 0.2s ease-out;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/toggle/toggle.css": +/*!*******************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/toggle/toggle.css ***! + \*******************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-custom-toggle { + margin-left: 2px; + float: left; + cursor: pointer; + overflow: hidden; + width: 20px; + height: 20px; + border-radius: 3px; + border: 1px solid transparent; + padding: 1px; + box-sizing: border-box; + user-select: none; + -webkit-user-select: none; +} + +.monaco-custom-toggle:hover { + background-color: var(--vscode-inputOption-hoverBackground); +} + +.hc-black .monaco-custom-toggle:hover, +.hc-light .monaco-custom-toggle:hover { + border: 1px dashed var(--vscode-focusBorder); +} + +.hc-black .monaco-custom-toggle, +.hc-light .monaco-custom-toggle { + background: none; +} + +.hc-black .monaco-custom-toggle:hover, +.hc-light .monaco-custom-toggle:hover { + background: none; +} + +.monaco-custom-toggle.monaco-checkbox { + height: 18px; + width: 18px; + border: 1px solid transparent; + border-radius: 3px; + margin-right: 9px; + margin-left: 0px; + padding: 0px; + opacity: 1; + background-size: 16px !important; +} + +.monaco-action-bar .checkbox-action-item { + display: flex; + align-items: center; +} + +.monaco-action-bar .checkbox-action-item > .monaco-custom-toggle.monaco-checkbox { + margin-right: 4px; +} + +.monaco-action-bar .checkbox-action-item > .checkbox-label { + font-size: 12px; +} + +/* hide check when unchecked */ +.monaco-custom-toggle.monaco-checkbox:not(.checked)::before { + visibility: hidden; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/toggle/toggle.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,gBAAgB;CAChB,WAAW;CACX,eAAe;CACf,gBAAgB;CAChB,WAAW;CACX,YAAY;CACZ,kBAAkB;CAClB,6BAA6B;CAC7B,YAAY;CACZ,sBAAsB;CACtB,iBAAiB;CACjB,yBAAyB;AAC1B;;AAEA;CACC,2DAA2D;AAC5D;;AAEA;;CAEC,4CAA4C;AAC7C;;AAEA;;CAEC,gBAAgB;AACjB;;AAEA;;CAEC,gBAAgB;AACjB;;AAEA;CACC,YAAY;CACZ,WAAW;CACX,6BAA6B;CAC7B,kBAAkB;CAClB,iBAAiB;CACjB,gBAAgB;CAChB,YAAY;CACZ,UAAU;CACV,gCAAgC;AACjC;;AAEA;CACC,aAAa;CACb,mBAAmB;AACpB;;AAEA;CACC,iBAAiB;AAClB;;AAEA;CACC,eAAe;AAChB;;AAEA,8BAA8B;AAC9B;CACC,kBAAkB;AACnB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-custom-toggle {\n\tmargin-left: 2px;\n\tfloat: left;\n\tcursor: pointer;\n\toverflow: hidden;\n\twidth: 20px;\n\theight: 20px;\n\tborder-radius: 3px;\n\tborder: 1px solid transparent;\n\tpadding: 1px;\n\tbox-sizing:\tborder-box;\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n.monaco-custom-toggle:hover {\n\tbackground-color: var(--vscode-inputOption-hoverBackground);\n}\n\n.hc-black .monaco-custom-toggle:hover,\n.hc-light .monaco-custom-toggle:hover {\n\tborder: 1px dashed var(--vscode-focusBorder);\n}\n\n.hc-black .monaco-custom-toggle,\n.hc-light .monaco-custom-toggle {\n\tbackground: none;\n}\n\n.hc-black .monaco-custom-toggle:hover,\n.hc-light .monaco-custom-toggle:hover {\n\tbackground: none;\n}\n\n.monaco-custom-toggle.monaco-checkbox {\n\theight: 18px;\n\twidth: 18px;\n\tborder: 1px solid transparent;\n\tborder-radius: 3px;\n\tmargin-right: 9px;\n\tmargin-left: 0px;\n\tpadding: 0px;\n\topacity: 1;\n\tbackground-size: 16px !important;\n}\n\n.monaco-action-bar .checkbox-action-item {\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.monaco-action-bar .checkbox-action-item > .monaco-custom-toggle.monaco-checkbox {\n\tmargin-right: 4px;\n}\n\n.monaco-action-bar .checkbox-action-item > .checkbox-label {\n\tfont-size: 12px;\n}\n\n/* hide check when unchecked */\n.monaco-custom-toggle.monaco-checkbox:not(.checked)::before {\n\tvisibility: hidden;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/toolbar/toolbar.css": +/*!*********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/toolbar/toolbar.css ***! + \*********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-toolbar { + height: 100%; +} + +.monaco-toolbar .toolbar-toggle-more { + display: inline-block; + padding: 0; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/toolbar/toolbar.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,YAAY;AACb;;AAEA;CACC,qBAAqB;CACrB,UAAU;AACX","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-toolbar {\n\theight: 100%;\n}\n\n.monaco-toolbar .toolbar-toggle-more {\n\tdisplay: inline-block;\n\tpadding: 0;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/tree/media/tree.css": +/*!*********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/base/browser/ui/tree/media/tree.css ***! + \*********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-tl-row { + display: flex; + height: 100%; + align-items: center; + position: relative; +} + +.monaco-tl-row.disabled { + cursor: default; +} +.monaco-tl-indent { + height: 100%; + position: absolute; + top: 0; + left: 16px; + pointer-events: none; +} + +.hide-arrows .monaco-tl-indent { + left: 12px; +} + +.monaco-tl-indent > .indent-guide { + display: inline-block; + box-sizing: border-box; + height: 100%; + border-left: 1px solid transparent; +} + +.monaco-workbench:not(.reduce-motion) .monaco-tl-indent > .indent-guide { + transition: border-color 0.1s linear; +} + +.monaco-tl-twistie, +.monaco-tl-contents { + height: 100%; +} + +.monaco-tl-twistie { + font-size: 10px; + text-align: right; + padding-right: 6px; + flex-shrink: 0; + width: 16px; + display: flex !important; + align-items: center; + justify-content: center; + transform: translateX(3px); +} + +.monaco-tl-contents { + flex: 1; + overflow: hidden; +} + +.monaco-tl-twistie::before { + border-radius: 20px; +} + +.monaco-tl-twistie.collapsed::before { + transform: rotate(-90deg); +} + +.monaco-tl-twistie.codicon-tree-item-loading::before { + /* Use steps to throttle FPS to reduce CPU usage */ + animation: codicon-spin 1.25s steps(30) infinite; +} + +.monaco-tree-type-filter { + position: absolute; + top: 0; + display: flex; + padding: 3px; + max-width: 200px; + z-index: 100; + margin: 0 6px; + border: 1px solid var(--vscode-widget-border); + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; +} + +.monaco-workbench:not(.reduce-motion) .monaco-tree-type-filter { + transition: top 0.3s; +} + +.monaco-tree-type-filter.disabled { + top: -40px !important; +} + +.monaco-tree-type-filter-grab { + display: flex !important; + align-items: center; + justify-content: center; + cursor: grab; + margin-right: 2px; +} + +.monaco-tree-type-filter-grab.grabbing { + cursor: grabbing; +} + +.monaco-tree-type-filter-input { + flex: 1; +} + +.monaco-tree-type-filter-input .monaco-inputbox { + height: 23px; +} + +.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .input, +.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .mirror { + padding: 2px 4px; +} + +.monaco-tree-type-filter-input .monaco-findInput > .controls { + top: 2px; +} + +.monaco-tree-type-filter-actionbar { + margin-left: 4px; +} + +.monaco-tree-type-filter-actionbar .monaco-action-bar .action-label { + padding: 2px; +} + +.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container{ + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 0; + z-index: 13; /* Settings editor uses z-index: 12 */ + + /* TODO@benibenj temporary solution, all lists should provide their background */ + background-color: var(--vscode-sideBar-background); +} + +.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row.monaco-list-row{ + position: absolute; + width: 100%; + opacity: 1 !important; /* Settings editor uses opacity < 1 */ + overflow: hidden; + + /* TODO@benibenj temporary solution, all lists should provide their background */ + background-color: var(--vscode-sideBar-background); +} + +.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row:hover{ + background-color: var(--vscode-list-hoverBackground) !important; + cursor: pointer; +} + +.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-container-shadow{ + position: absolute; + bottom: -3px; + left: 0px; + height: 3px; + width: 100%; + box-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/base/browser/ui/tree/media/tree.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,aAAa;CACb,YAAY;CACZ,mBAAmB;CACnB,kBAAkB;AACnB;;AAEA;CACC,eAAe;AAChB;AACA;CACC,YAAY;CACZ,kBAAkB;CAClB,MAAM;CACN,UAAU;CACV,oBAAoB;AACrB;;AAEA;CACC,UAAU;AACX;;AAEA;CACC,qBAAqB;CACrB,sBAAsB;CACtB,YAAY;CACZ,kCAAkC;AACnC;;AAEA;CACC,oCAAoC;AACrC;;AAEA;;CAEC,YAAY;AACb;;AAEA;CACC,eAAe;CACf,iBAAiB;CACjB,kBAAkB;CAClB,cAAc;CACd,WAAW;CACX,wBAAwB;CACxB,mBAAmB;CACnB,uBAAuB;CACvB,0BAA0B;AAC3B;;AAEA;CACC,OAAO;CACP,gBAAgB;AACjB;;AAEA;CACC,mBAAmB;AACpB;;AAEA;CACC,yBAAyB;AAC1B;;AAEA;CACC,kDAAkD;CAClD,gDAAgD;AACjD;;AAEA;CACC,kBAAkB;CAClB,MAAM;CACN,aAAa;CACb,YAAY;CACZ,gBAAgB;CAChB,YAAY;CACZ,aAAa;CACb,6CAA6C;CAC7C,8BAA8B;CAC9B,+BAA+B;AAChC;;AAEA;CACC,oBAAoB;AACrB;;AAEA;CACC,qBAAqB;AACtB;;AAEA;CACC,wBAAwB;CACxB,mBAAmB;CACnB,uBAAuB;CACvB,YAAY;CACZ,iBAAiB;AAClB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,OAAO;AACR;;AAEA;CACC,YAAY;AACb;;AAEA;;CAEC,gBAAgB;AACjB;;AAEA;CACC,QAAQ;AACT;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,kBAAkB;CAClB,MAAM;CACN,OAAO;CACP,WAAW;CACX,SAAS;CACT,WAAW,EAAE,qCAAqC;;CAElD,gFAAgF;CAChF,kDAAkD;AACnD;;AAEA;CACC,kBAAkB;CAClB,WAAW;CACX,qBAAqB,EAAE,qCAAqC;CAC5D,gBAAgB;;CAEhB,gFAAgF;CAChF,kDAAkD;AACnD;;AAEA;CACC,+DAA+D;CAC/D,eAAe;AAChB;;AAEA;CACC,kBAAkB;CAClB,YAAY;CACZ,SAAS;CACT,WAAW;CACX,WAAW;CACX,+DAA+D;AAChE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-tl-row {\n\tdisplay: flex;\n\theight: 100%;\n\talign-items: center;\n\tposition: relative;\n}\n\n.monaco-tl-row.disabled {\n\tcursor: default;\n}\n.monaco-tl-indent {\n\theight: 100%;\n\tposition: absolute;\n\ttop: 0;\n\tleft: 16px;\n\tpointer-events: none;\n}\n\n.hide-arrows .monaco-tl-indent {\n\tleft: 12px;\n}\n\n.monaco-tl-indent > .indent-guide {\n\tdisplay: inline-block;\n\tbox-sizing: border-box;\n\theight: 100%;\n\tborder-left: 1px solid transparent;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-tl-indent > .indent-guide {\n\ttransition: border-color 0.1s linear;\n}\n\n.monaco-tl-twistie,\n.monaco-tl-contents {\n\theight: 100%;\n}\n\n.monaco-tl-twistie {\n\tfont-size: 10px;\n\ttext-align: right;\n\tpadding-right: 6px;\n\tflex-shrink: 0;\n\twidth: 16px;\n\tdisplay: flex !important;\n\talign-items: center;\n\tjustify-content: center;\n\ttransform: translateX(3px);\n}\n\n.monaco-tl-contents {\n\tflex: 1;\n\toverflow: hidden;\n}\n\n.monaco-tl-twistie::before {\n\tborder-radius: 20px;\n}\n\n.monaco-tl-twistie.collapsed::before {\n\ttransform: rotate(-90deg);\n}\n\n.monaco-tl-twistie.codicon-tree-item-loading::before {\n\t/* Use steps to throttle FPS to reduce CPU usage */\n\tanimation: codicon-spin 1.25s steps(30) infinite;\n}\n\n.monaco-tree-type-filter {\n\tposition: absolute;\n\ttop: 0;\n\tdisplay: flex;\n\tpadding: 3px;\n\tmax-width: 200px;\n\tz-index: 100;\n\tmargin: 0 6px;\n\tborder: 1px solid var(--vscode-widget-border);\n\tborder-bottom-left-radius: 4px;\n\tborder-bottom-right-radius: 4px;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-tree-type-filter {\n\ttransition: top 0.3s;\n}\n\n.monaco-tree-type-filter.disabled {\n\ttop: -40px !important;\n}\n\n.monaco-tree-type-filter-grab {\n\tdisplay: flex !important;\n\talign-items: center;\n\tjustify-content: center;\n\tcursor: grab;\n\tmargin-right: 2px;\n}\n\n.monaco-tree-type-filter-grab.grabbing {\n\tcursor: grabbing;\n}\n\n.monaco-tree-type-filter-input {\n\tflex: 1;\n}\n\n.monaco-tree-type-filter-input .monaco-inputbox {\n\theight: 23px;\n}\n\n.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .input,\n.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .mirror {\n\tpadding: 2px 4px;\n}\n\n.monaco-tree-type-filter-input .monaco-findInput > .controls {\n\ttop: 2px;\n}\n\n.monaco-tree-type-filter-actionbar {\n\tmargin-left: 4px;\n}\n\n.monaco-tree-type-filter-actionbar .monaco-action-bar .action-label {\n\tpadding: 2px;\n}\n\n.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container{\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\twidth: 100%;\n\theight: 0;\n\tz-index: 13; /* Settings editor uses z-index: 12 */\n\n\t/* TODO@benibenj temporary solution, all lists should provide their background */\n\tbackground-color: var(--vscode-sideBar-background);\n}\n\n.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row.monaco-list-row{\n\tposition: absolute;\n\twidth: 100%;\n\topacity: 1 !important; /* Settings editor uses opacity < 1 */\n\toverflow: hidden;\n\n\t/* TODO@benibenj temporary solution, all lists should provide their background */\n\tbackground-color: var(--vscode-sideBar-background);\n}\n\n.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row:hover{\n\tbackground-color: var(--vscode-list-hoverBackground) !important;\n\tcursor: pointer;\n}\n\n.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-container-shadow{\n\tposition: absolute;\n\tbottom: -3px;\n\tleft: 0px;\n\theight: 3px;\n\twidth: 100%;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/controller/textAreaHandler.css": +/*!*******************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/controller/textAreaHandler.css ***! + \*******************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .inputarea { + min-width: 0; + min-height: 0; + margin: 0; + padding: 0; + position: absolute; + outline: none !important; + resize: none; + border: none; + overflow: hidden; + color: transparent; + background-color: transparent; + z-index: -10; +} +/*.monaco-editor .inputarea { + position: fixed !important; + width: 800px !important; + height: 500px !important; + top: initial !important; + left: initial !important; + bottom: 0 !important; + right: 0 !important; + color: black !important; + background: white !important; + line-height: 15px !important; + font-size: 14px !important; + z-index: 10 !important; +}*/ +.monaco-editor .inputarea.ime-input { + z-index: 10; + caret-color: var(--vscode-editorCursor-foreground); + color: var(--vscode-editor-foreground); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/controller/textAreaHandler.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,YAAY;CACZ,aAAa;CACb,SAAS;CACT,UAAU;CACV,kBAAkB;CAClB,wBAAwB;CACxB,YAAY;CACZ,YAAY;CACZ,gBAAgB;CAChB,kBAAkB;CAClB,6BAA6B;CAC7B,YAAY;AACb;AACA;;;;;;;;;;;;;EAaE;AACF;CACC,WAAW;CACX,kDAAkD;CAClD,sCAAsC;AACvC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .inputarea {\n\tmin-width: 0;\n\tmin-height: 0;\n\tmargin: 0;\n\tpadding: 0;\n\tposition: absolute;\n\toutline: none !important;\n\tresize: none;\n\tborder: none;\n\toverflow: hidden;\n\tcolor: transparent;\n\tbackground-color: transparent;\n\tz-index: -10;\n}\n/*.monaco-editor .inputarea {\n\tposition: fixed !important;\n\twidth: 800px !important;\n\theight: 500px !important;\n\ttop: initial !important;\n\tleft: initial !important;\n\tbottom: 0 !important;\n\tright: 0 !important;\n\tcolor: black !important;\n\tbackground: white !important;\n\tline-height: 15px !important;\n\tfont-size: 14px !important;\n\tz-index: 10 !important;\n}*/\n.monaco-editor .inputarea.ime-input {\n\tz-index: 10;\n\tcaret-color: var(--vscode-editorCursor-foreground);\n\tcolor: var(--vscode-editor-foreground);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/blockDecorations/blockDecorations.css": +/*!************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/blockDecorations/blockDecorations.css ***! + \************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .blockDecorations-container { + position: absolute; + top: 0; + pointer-events: none; +} + +.monaco-editor .blockDecorations-block { + position: absolute; + box-sizing: border-box; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/blockDecorations/blockDecorations.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,MAAM;CACN,oBAAoB;AACrB;;AAEA;CACC,kBAAkB;CAClB,sBAAsB;AACvB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .blockDecorations-container {\n\tposition: absolute;\n\ttop: 0;\n\tpointer-events: none;\n}\n\n.monaco-editor .blockDecorations-block {\n\tposition: absolute;\n\tbox-sizing: border-box;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.css": +/*!********************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.css ***! + \********************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .view-overlays .current-line { + display: block; + position: absolute; + left: 0; + top: 0; + box-sizing: border-box; +} + +.monaco-editor .margin-view-overlays .current-line { + display: block; + position: absolute; + left: 0; + top: 0; + box-sizing: border-box; +} + +.monaco-editor .margin-view-overlays .current-line.current-line-margin.current-line-margin-both { + border-right: 0; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,cAAc;CACd,kBAAkB;CAClB,OAAO;CACP,MAAM;CACN,sBAAsB;AACvB;;AAEA;CACC,cAAc;CACd,kBAAkB;CAClB,OAAO;CACP,MAAM;CACN,sBAAsB;AACvB;;AAEA;CACC,eAAe;AAChB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .view-overlays .current-line {\n\tdisplay: block;\n\tposition: absolute;\n\tleft: 0;\n\ttop: 0;\n\tbox-sizing: border-box;\n}\n\n.monaco-editor .margin-view-overlays .current-line {\n\tdisplay: block;\n\tposition: absolute;\n\tleft: 0;\n\ttop: 0;\n\tbox-sizing: border-box;\n}\n\n.monaco-editor .margin-view-overlays .current-line.current-line-margin.current-line-margin-both {\n\tborder-right: 0;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/decorations/decorations.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/decorations/decorations.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* + Keeping name short for faster parsing. + cdr = core decorations rendering (div) +*/ +.monaco-editor .lines-content .cdr { + position: absolute; +}`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/decorations/decorations.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;;;CAGC;AACD;CACC,kBAAkB;AACnB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/*\n\tKeeping name short for faster parsing.\n\tcdr = core decorations rendering (div)\n*/\n.monaco-editor .lines-content .cdr {\n\tposition: absolute;\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/glyphMargin/glyphMargin.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/glyphMargin/glyphMargin.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .glyph-margin { + position: absolute; + top: 0; +} + +/* + Keeping name short for faster parsing. + cgmr = core glyph margin rendering (div) +*/ +.monaco-editor .glyph-margin-widgets .cgmr { + position: absolute; + display: flex; + align-items: center; + justify-content: center; +} + +/* + Ensure spinning icons are pixel-perfectly centered and avoid wobble. + This is only applied to icons that spin to avoid unnecessary + GPU layers and blurry subpixel AA. +*/ +.monaco-editor .glyph-margin-widgets .cgmr.codicon-modifier-spin::before { + position: absolute; + top: 50%; + left: 50%; + transform: translate(-50%, -50%); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/glyphMargin/glyphMargin.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,MAAM;AACP;;AAEA;;;CAGC;AACD;CACC,kBAAkB;CAClB,aAAa;CACb,mBAAmB;CACnB,uBAAuB;AACxB;;AAEA;;;;CAIC;AACD;CACC,kBAAkB;CAClB,QAAQ;CACR,SAAS;CACT,gCAAgC;AACjC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .glyph-margin {\n\tposition: absolute;\n\ttop: 0;\n}\n\n/*\n\tKeeping name short for faster parsing.\n\tcgmr = core glyph margin rendering (div)\n*/\n.monaco-editor .glyph-margin-widgets .cgmr {\n\tposition: absolute;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n/*\n\tEnsure spinning icons are pixel-perfectly centered and avoid wobble.\n\tThis is only applied to icons that spin to avoid unnecessary\n\tGPU layers and blurry subpixel AA.\n*/\n.monaco-editor .glyph-margin-widgets .cgmr.codicon-modifier-spin::before {\n\tposition: absolute;\n\ttop: 50%;\n\tleft: 50%;\n\ttransform: translate(-50%, -50%);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/indentGuides/indentGuides.css": +/*!****************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/indentGuides/indentGuides.css ***! + \****************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .lines-content .core-guide { + position: absolute; + box-sizing: border-box; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/indentGuides/indentGuides.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,sBAAsB;AACvB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .lines-content .core-guide {\n\tposition: absolute;\n\tbox-sizing: border-box;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lineNumbers/lineNumbers.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lineNumbers/lineNumbers.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .margin-view-overlays .line-numbers { + font-variant-numeric: tabular-nums; + position: absolute; + text-align: right; + display: inline-block; + vertical-align: middle; + box-sizing: border-box; + cursor: default; + height: 100%; +} + +.monaco-editor .relative-current-line-number { + text-align: left; + display: inline-block; + width: 100%; +} + +.monaco-editor .margin-view-overlays .line-numbers.lh-odd { + margin-top: 1px; +} + +.monaco-editor .line-numbers { + color: var(--vscode-editorLineNumber-foreground); +} + +.monaco-editor .line-numbers.active-line-number { + color: var(--vscode-editorLineNumber-activeForeground); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lineNumbers/lineNumbers.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kCAAkC;CAClC,kBAAkB;CAClB,iBAAiB;CACjB,qBAAqB;CACrB,sBAAsB;CACtB,sBAAsB;CACtB,eAAe;CACf,YAAY;AACb;;AAEA;CACC,gBAAgB;CAChB,qBAAqB;CACrB,WAAW;AACZ;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,gDAAgD;AACjD;;AAEA;CACC,sDAAsD;AACvD","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .margin-view-overlays .line-numbers {\n\tfont-variant-numeric: tabular-nums;\n\tposition: absolute;\n\ttext-align: right;\n\tdisplay: inline-block;\n\tvertical-align: middle;\n\tbox-sizing: border-box;\n\tcursor: default;\n\theight: 100%;\n}\n\n.monaco-editor .relative-current-line-number {\n\ttext-align: left;\n\tdisplay: inline-block;\n\twidth: 100%;\n}\n\n.monaco-editor .margin-view-overlays .line-numbers.lh-odd {\n\tmargin-top: 1px;\n}\n\n.monaco-editor .line-numbers {\n\tcolor: var(--vscode-editorLineNumber-foreground);\n}\n\n.monaco-editor .line-numbers.active-line-number {\n\tcolor: var(--vscode-editorLineNumber-activeForeground);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/linesDecorations/linesDecorations.css": +/*!************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/linesDecorations/linesDecorations.css ***! + \************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +.monaco-editor .lines-decorations { + position: absolute; + top: 0; + background: white; +} + +/* + Keeping name short for faster parsing. + cldr = core lines decorations rendering (div) +*/ +.monaco-editor .margin-view-overlays .cldr { + position: absolute; + height: 100%; +}`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/linesDecorations/linesDecorations.css"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;CACC,kBAAkB;CAClB,MAAM;CACN,iBAAiB;AAClB;;AAEA;;;CAGC;AACD;CACC,kBAAkB;CAClB,YAAY;AACb","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .lines-decorations {\n\tposition: absolute;\n\ttop: 0;\n\tbackground: white;\n}\n\n/*\n\tKeeping name short for faster parsing.\n\tcldr = core lines decorations rendering (div)\n*/\n.monaco-editor .margin-view-overlays .cldr {\n\tposition: absolute;\n\theight: 100%;\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lines/viewLines.css": +/*!******************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lines/viewLines.css ***! + \******************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* Uncomment to see lines flashing when they're painted */ +/*.monaco-editor .view-lines > .view-line { + background-color: none; + animation-name: flash-background; + animation-duration: 800ms; +} +@keyframes flash-background { + 0% { background-color: lightgreen; } + 100% { background-color: none } +}*/ + +.mtkcontrol { + color: rgb(255, 255, 255) !important; + background: rgb(150, 0, 0) !important; +} + +.mtkoverflow { + background-color: var(--vscode-button-background, var(--vscode-editor-background)); + color: var(--vscode-button-foreground, var(--vscode-editor-foreground)); + border-width: 1px; + border-style: solid; + border-color: var(--vscode-contrastBorder); + border-radius: 2px; + padding: 4px; + cursor: pointer; +} +.mtkoverflow:hover { + background-color: var(--vscode-button-hoverBackground); +} + +.monaco-editor.no-user-select .lines-content, +.monaco-editor.no-user-select .view-line, +.monaco-editor.no-user-select .view-lines { + user-select: none; + -webkit-user-select: none; +} +/* Use user-select: text for lookup feature on macOS */ +/* https://github.com/microsoft/vscode/issues/85632 */ +.monaco-editor.mac .lines-content:hover, +.monaco-editor.mac .view-line:hover, +.monaco-editor.mac .view-lines:hover { + user-select: text; + -webkit-user-select: text; + -ms-user-select: text; +} + +.monaco-editor.enable-user-select { + user-select: initial; + -webkit-user-select: initial; +} + +.monaco-editor .view-lines { + white-space: nowrap; +} + +.monaco-editor .view-line { + position: absolute; + width: 100%; +} + +.monaco-editor .mtkw { + color: var(--vscode-editorWhitespace-foreground) !important; +} + +.monaco-editor .mtkz { + display: inline-block; + color: var(--vscode-editorWhitespace-foreground) !important; +} + +/* TODO@tokenization bootstrap fix */ +/*.monaco-editor .view-line > span > span { + float: none; + min-height: inherit; + margin-left: inherit; +}*/ +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lines/viewLines.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,yDAAyD;AACzD;;;;;;;;EAQE;;AAEF;CACC,oCAAoC;CACpC,qCAAqC;AACtC;;AAEA;CACC,kFAAkF;CAClF,uEAAuE;CACvE,iBAAiB;CACjB,mBAAmB;CACnB,0CAA0C;CAC1C,kBAAkB;CAClB,YAAY;CACZ,eAAe;AAChB;AACA;CACC,sDAAsD;AACvD;;AAEA;;;CAGC,iBAAiB;CACjB,yBAAyB;AAC1B;AACA,sDAAsD;AACtD,qDAAqD;AACrD;;;CAGC,iBAAiB;CACjB,yBAAyB;CACzB,qBAAqB;AACtB;;AAEA;CACC,oBAAoB;CACpB,4BAA4B;AAC7B;;AAEA;CACC,mBAAmB;AACpB;;AAEA;CACC,kBAAkB;CAClB,WAAW;AACZ;;AAEA;CACC,2DAA2D;AAC5D;;AAEA;CACC,qBAAqB;CACrB,2DAA2D;AAC5D;;AAEA,oCAAoC;AACpC;;;;EAIE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Uncomment to see lines flashing when they're painted */\n/*.monaco-editor .view-lines > .view-line {\n\tbackground-color: none;\n\tanimation-name: flash-background;\n\tanimation-duration: 800ms;\n}\n@keyframes flash-background {\n\t0% { background-color: lightgreen; }\n\t100% { background-color: none }\n}*/\n\n.mtkcontrol {\n\tcolor: rgb(255, 255, 255) !important;\n\tbackground: rgb(150, 0, 0) !important;\n}\n\n.mtkoverflow {\n\tbackground-color: var(--vscode-button-background, var(--vscode-editor-background));\n\tcolor: var(--vscode-button-foreground, var(--vscode-editor-foreground));\n\tborder-width: 1px;\n\tborder-style: solid;\n\tborder-color: var(--vscode-contrastBorder);\n\tborder-radius: 2px;\n\tpadding: 4px;\n\tcursor: pointer;\n}\n.mtkoverflow:hover {\n\tbackground-color: var(--vscode-button-hoverBackground);\n}\n\n.monaco-editor.no-user-select .lines-content,\n.monaco-editor.no-user-select .view-line,\n.monaco-editor.no-user-select .view-lines {\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n/* Use user-select: text for lookup feature on macOS */\n/* https://github.com/microsoft/vscode/issues/85632 */\n.monaco-editor.mac .lines-content:hover,\n.monaco-editor.mac .view-line:hover,\n.monaco-editor.mac .view-lines:hover {\n\tuser-select: text;\n\t-webkit-user-select: text;\n\t-ms-user-select: text;\n}\n\n.monaco-editor.enable-user-select {\n\tuser-select: initial;\n\t-webkit-user-select: initial;\n}\n\n.monaco-editor .view-lines {\n\twhite-space: nowrap;\n}\n\n.monaco-editor .view-line {\n\tposition: absolute;\n\twidth: 100%;\n}\n\n.monaco-editor .mtkw {\n\tcolor: var(--vscode-editorWhitespace-foreground) !important;\n}\n\n.monaco-editor .mtkz {\n\tdisplay: inline-block;\n\tcolor: var(--vscode-editorWhitespace-foreground) !important;\n}\n\n/* TODO@tokenization bootstrap fix */\n/*.monaco-editor .view-line > span > span {\n\tfloat: none;\n\tmin-height: inherit;\n\tmargin-left: inherit;\n}*/\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/marginDecorations/marginDecorations.css": +/*!**************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/marginDecorations/marginDecorations.css ***! + \**************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* + Keeping name short for faster parsing. + cmdr = core margin decorations rendering (div) +*/ +.monaco-editor .margin-view-overlays .cmdr { + position: absolute; + left: 0; + width: 100%; + height: 100%; +}`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/marginDecorations/marginDecorations.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;;;CAGC;AACD;CACC,kBAAkB;CAClB,OAAO;CACP,WAAW;CACX,YAAY;AACb","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/*\n\tKeeping name short for faster parsing.\n\tcmdr = core margin decorations rendering (div)\n*/\n.monaco-editor .margin-view-overlays .cmdr {\n\tposition: absolute;\n\tleft: 0;\n\twidth: 100%;\n\theight: 100%;\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/margin/margin.css": +/*!****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/margin/margin.css ***! + \****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .margin { + background-color: var(--vscode-editorGutter-background); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/margin/margin.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,uDAAuD;AACxD","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .margin {\n\tbackground-color: var(--vscode-editorGutter-background);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/minimap/minimap.css": +/*!******************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/minimap/minimap.css ***! + \******************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* START cover the case that slider is visible on mouseover */ +.monaco-editor .minimap.slider-mouseover .minimap-slider { + opacity: 0; + transition: opacity 100ms linear; +} +.monaco-editor .minimap.slider-mouseover:hover .minimap-slider { + opacity: 1; +} +.monaco-editor .minimap.slider-mouseover .minimap-slider.active { + opacity: 1; +} +/* END cover the case that slider is visible on mouseover */ +.monaco-editor .minimap-slider .minimap-slider-horizontal { + background: var(--vscode-minimapSlider-background); +} +.monaco-editor .minimap-slider:hover .minimap-slider-horizontal { + background: var(--vscode-minimapSlider-hoverBackground); +} +.monaco-editor .minimap-slider.active .minimap-slider-horizontal { + background: var(--vscode-minimapSlider-activeBackground); +} +.monaco-editor .minimap-shadow-visible { + box-shadow: var(--vscode-scrollbar-shadow) -6px 0 6px -6px inset; +} +.monaco-editor .minimap-shadow-hidden { + position: absolute; + width: 0; +} +.monaco-editor .minimap-shadow-visible { + position: absolute; + left: -6px; + width: 6px; +} +.monaco-editor.no-minimap-shadow .minimap-shadow-visible { + position: absolute; + left: -1px; + width: 1px; +} + +/* 0.5s fade in/out for the minimap */ +.minimap.autohide { + opacity: 0; + transition: opacity 0.5s; +} +.minimap.autohide:hover { + opacity: 1; +} + +.monaco-editor .minimap { + z-index: 5; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/minimap/minimap.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,6DAA6D;AAC7D;CACC,UAAU;CACV,gCAAgC;AACjC;AACA;CACC,UAAU;AACX;AACA;CACC,UAAU;AACX;AACA,2DAA2D;AAC3D;CACC,kDAAkD;AACnD;AACA;CACC,uDAAuD;AACxD;AACA;CACC,wDAAwD;AACzD;AACA;CACC,gEAAgE;AACjE;AACA;CACC,kBAAkB;CAClB,QAAQ;AACT;AACA;CACC,kBAAkB;CAClB,UAAU;CACV,UAAU;AACX;AACA;CACC,kBAAkB;CAClB,UAAU;CACV,UAAU;AACX;;AAEA,qCAAqC;AACrC;CACC,UAAU;CACV,wBAAwB;AACzB;AACA;CACC,UAAU;AACX;;AAEA;CACC,UAAU;AACX","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* START cover the case that slider is visible on mouseover */\n.monaco-editor .minimap.slider-mouseover .minimap-slider {\n\topacity: 0;\n\ttransition: opacity 100ms linear;\n}\n.monaco-editor .minimap.slider-mouseover:hover .minimap-slider {\n\topacity: 1;\n}\n.monaco-editor .minimap.slider-mouseover .minimap-slider.active {\n\topacity: 1;\n}\n/* END cover the case that slider is visible on mouseover */\n.monaco-editor .minimap-slider .minimap-slider-horizontal {\n\tbackground: var(--vscode-minimapSlider-background);\n}\n.monaco-editor .minimap-slider:hover .minimap-slider-horizontal {\n\tbackground: var(--vscode-minimapSlider-hoverBackground);\n}\n.monaco-editor .minimap-slider.active .minimap-slider-horizontal {\n\tbackground: var(--vscode-minimapSlider-activeBackground);\n}\n.monaco-editor .minimap-shadow-visible {\n\tbox-shadow: var(--vscode-scrollbar-shadow) -6px 0 6px -6px inset;\n}\n.monaco-editor .minimap-shadow-hidden {\n\tposition: absolute;\n\twidth: 0;\n}\n.monaco-editor .minimap-shadow-visible {\n\tposition: absolute;\n\tleft: -6px;\n\twidth: 6px;\n}\n.monaco-editor.no-minimap-shadow .minimap-shadow-visible {\n\tposition: absolute;\n\tleft: -1px;\n\twidth: 1px;\n}\n\n/* 0.5s fade in/out for the minimap */\n.minimap.autohide {\n\topacity: 0;\n\ttransition: opacity 0.5s;\n}\n.minimap.autohide:hover {\n\topacity: 1;\n}\n\n.monaco-editor .minimap {\n\tz-index: 5;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.css": +/*!********************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.css ***! + \********************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +.monaco-editor .overlayWidgets { + position: absolute; + top: 0; + left:0; +}`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.css"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;CACC,kBAAkB;CAClB,MAAM;CACN,MAAM;AACP","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .overlayWidgets {\n\tposition: absolute;\n\ttop: 0;\n\tleft:0;\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/rulers/rulers.css": +/*!****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/rulers/rulers.css ***! + \****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .view-ruler { + position: absolute; + top: 0; + box-shadow: 1px 0 0 0 var(--vscode-editorRuler-foreground) inset; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/rulers/rulers.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,MAAM;CACN,gEAAgE;AACjE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .view-ruler {\n\tposition: absolute;\n\ttop: 0;\n\tbox-shadow: 1px 0 0 0 var(--vscode-editorRuler-foreground) inset;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.css": +/*!************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.css ***! + \************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .scroll-decoration { + position: absolute; + top: 0; + left: 0; + height: 6px; + box-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,MAAM;CACN,OAAO;CACP,WAAW;CACX,+DAA+D;AAChE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .scroll-decoration {\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\theight: 6px;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/selections/selections.css": +/*!************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/selections/selections.css ***! + \************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* + Keeping name short for faster parsing. + cslr = core selections layer rendering (div) +*/ +.monaco-editor .lines-content .cslr { + position: absolute; +} + +.monaco-editor .focused .selected-text { + background-color: var(--vscode-editor-selectionBackground); +} + +.monaco-editor .selected-text { + background-color: var(--vscode-editor-inactiveSelectionBackground); +} + +.monaco-editor .top-left-radius { border-top-left-radius: 3px; } +.monaco-editor .bottom-left-radius { border-bottom-left-radius: 3px; } +.monaco-editor .top-right-radius { border-top-right-radius: 3px; } +.monaco-editor .bottom-right-radius { border-bottom-right-radius: 3px; } + +.monaco-editor.hc-black .top-left-radius { border-top-left-radius: 0; } +.monaco-editor.hc-black .bottom-left-radius { border-bottom-left-radius: 0; } +.monaco-editor.hc-black .top-right-radius { border-top-right-radius: 0; } +.monaco-editor.hc-black .bottom-right-radius { border-bottom-right-radius: 0; } + +.monaco-editor.hc-light .top-left-radius { border-top-left-radius: 0; } +.monaco-editor.hc-light .bottom-left-radius { border-bottom-left-radius: 0; } +.monaco-editor.hc-light .top-right-radius { border-top-right-radius: 0; } +.monaco-editor.hc-light .bottom-right-radius { border-bottom-right-radius: 0; } +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/selections/selections.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;;;CAGC;AACD;CACC,kBAAkB;AACnB;;AAEA;CACC,0DAA0D;AAC3D;;AAEA;CACC,kEAAkE;AACnE;;AAEA,qCAAqC,2BAA2B,EAAE;AAClE,wCAAwC,8BAA8B,EAAE;AACxE,sCAAsC,4BAA4B,EAAE;AACpE,wCAAwC,+BAA+B,EAAE;;AAEzE,4CAA4C,yBAAyB,EAAE;AACvE,+CAA+C,4BAA4B,EAAE;AAC7E,6CAA6C,0BAA0B,EAAE;AACzE,+CAA+C,6BAA6B,EAAE;;AAE9E,4CAA4C,yBAAyB,EAAE;AACvE,+CAA+C,4BAA4B,EAAE;AAC7E,6CAA6C,0BAA0B,EAAE;AACzE,+CAA+C,6BAA6B,EAAE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/*\n\tKeeping name short for faster parsing.\n\tcslr = core selections layer rendering (div)\n*/\n.monaco-editor .lines-content .cslr {\n\tposition: absolute;\n}\n\n.monaco-editor .focused .selected-text {\n\tbackground-color: var(--vscode-editor-selectionBackground);\n}\n\n.monaco-editor .selected-text {\n\tbackground-color: var(--vscode-editor-inactiveSelectionBackground);\n}\n\n.monaco-editor\t\t\t.top-left-radius\t\t{ border-top-left-radius: 3px; }\n.monaco-editor\t\t\t.bottom-left-radius\t\t{ border-bottom-left-radius: 3px; }\n.monaco-editor\t\t\t.top-right-radius\t\t{ border-top-right-radius: 3px; }\n.monaco-editor\t\t\t.bottom-right-radius\t{ border-bottom-right-radius: 3px; }\n\n.monaco-editor.hc-black .top-left-radius\t\t{ border-top-left-radius: 0; }\n.monaco-editor.hc-black .bottom-left-radius\t\t{ border-bottom-left-radius: 0; }\n.monaco-editor.hc-black .top-right-radius\t\t{ border-top-right-radius: 0; }\n.monaco-editor.hc-black .bottom-right-radius\t{ border-bottom-right-radius: 0; }\n\n.monaco-editor.hc-light .top-left-radius\t\t{ border-top-left-radius: 0; }\n.monaco-editor.hc-light .bottom-left-radius\t\t{ border-bottom-left-radius: 0; }\n.monaco-editor.hc-light .top-right-radius\t\t{ border-top-right-radius: 0; }\n.monaco-editor.hc-light .bottom-right-radius\t{ border-bottom-right-radius: 0; }\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/viewCursors/viewCursors.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/viewCursors/viewCursors.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +.monaco-editor .cursors-layer { + position: absolute; + top: 0; +} + +.monaco-editor .cursors-layer > .cursor { + position: absolute; + overflow: hidden; + box-sizing: border-box; +} + +/* -- smooth-caret-animation -- */ +.monaco-editor .cursors-layer.cursor-smooth-caret-animation > .cursor { + transition: all 80ms; +} + +/* -- block-outline-style -- */ +.monaco-editor .cursors-layer.cursor-block-outline-style > .cursor { + background: transparent !important; + border-style: solid; + border-width: 1px; +} + +/* -- underline-style -- */ +.monaco-editor .cursors-layer.cursor-underline-style > .cursor { + border-bottom-width: 2px; + border-bottom-style: solid; + background: transparent !important; +} + +/* -- underline-thin-style -- */ +.monaco-editor .cursors-layer.cursor-underline-thin-style > .cursor { + border-bottom-width: 1px; + border-bottom-style: solid; + background: transparent !important; +} + +@keyframes monaco-cursor-smooth { + 0%, + 20% { + opacity: 1; + } + 60%, + 100% { + opacity: 0; + } +} + +@keyframes monaco-cursor-phase { + 0%, + 20% { + opacity: 1; + } + 90%, + 100% { + opacity: 0; + } +} + +@keyframes monaco-cursor-expand { + 0%, + 20% { + transform: scaleY(1); + } + 80%, + 100% { + transform: scaleY(0); + } +} + +.cursor-smooth { + animation: monaco-cursor-smooth 0.5s ease-in-out 0s 20 alternate; +} + +.cursor-phase { + animation: monaco-cursor-phase 0.5s ease-in-out 0s 20 alternate; +} + +.cursor-expand > .cursor { + animation: monaco-cursor-expand 0.5s ease-in-out 0s 20 alternate; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/viewCursors/viewCursors.css"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;CACC,kBAAkB;CAClB,MAAM;AACP;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;CAChB,sBAAsB;AACvB;;AAEA,iCAAiC;AACjC;CACC,oBAAoB;AACrB;;AAEA,8BAA8B;AAC9B;CACC,kCAAkC;CAClC,mBAAmB;CACnB,iBAAiB;AAClB;;AAEA,0BAA0B;AAC1B;CACC,wBAAwB;CACxB,0BAA0B;CAC1B,kCAAkC;AACnC;;AAEA,+BAA+B;AAC/B;CACC,wBAAwB;CACxB,0BAA0B;CAC1B,kCAAkC;AACnC;;AAEA;CACC;;EAEC,UAAU;CACX;CACA;;EAEC,UAAU;CACX;AACD;;AAEA;CACC;;EAEC,UAAU;CACX;CACA;;EAEC,UAAU;CACX;AACD;;AAEA;CACC;;EAEC,oBAAoB;CACrB;CACA;;EAEC,oBAAoB;CACrB;AACD;;AAEA;CACC,gEAAgE;AACjE;;AAEA;CACC,+DAA+D;AAChE;;AAEA;CACC,gEAAgE;AACjE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .cursors-layer {\n\tposition: absolute;\n\ttop: 0;\n}\n\n.monaco-editor .cursors-layer > .cursor {\n\tposition: absolute;\n\toverflow: hidden;\n\tbox-sizing: border-box;\n}\n\n/* -- smooth-caret-animation -- */\n.monaco-editor .cursors-layer.cursor-smooth-caret-animation > .cursor {\n\ttransition: all 80ms;\n}\n\n/* -- block-outline-style -- */\n.monaco-editor .cursors-layer.cursor-block-outline-style > .cursor {\n\tbackground: transparent !important;\n\tborder-style: solid;\n\tborder-width: 1px;\n}\n\n/* -- underline-style -- */\n.monaco-editor .cursors-layer.cursor-underline-style > .cursor {\n\tborder-bottom-width: 2px;\n\tborder-bottom-style: solid;\n\tbackground: transparent !important;\n}\n\n/* -- underline-thin-style -- */\n.monaco-editor .cursors-layer.cursor-underline-thin-style > .cursor {\n\tborder-bottom-width: 1px;\n\tborder-bottom-style: solid;\n\tbackground: transparent !important;\n}\n\n@keyframes monaco-cursor-smooth {\n\t0%,\n\t20% {\n\t\topacity: 1;\n\t}\n\t60%,\n\t100% {\n\t\topacity: 0;\n\t}\n}\n\n@keyframes monaco-cursor-phase {\n\t0%,\n\t20% {\n\t\topacity: 1;\n\t}\n\t90%,\n\t100% {\n\t\topacity: 0;\n\t}\n}\n\n@keyframes monaco-cursor-expand {\n\t0%,\n\t20% {\n\t\ttransform: scaleY(1);\n\t}\n\t80%,\n\t100% {\n\t\ttransform: scaleY(0);\n\t}\n}\n\n.cursor-smooth {\n\tanimation: monaco-cursor-smooth 0.5s ease-in-out 0s 20 alternate;\n}\n\n.cursor-phase {\n\tanimation: monaco-cursor-phase 0.5s ease-in-out 0s 20 alternate;\n}\n\n.cursor-expand > .cursor {\n\tanimation: monaco-cursor-expand 0.5s ease-in-out 0s 20 alternate;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/whitespace/whitespace.css": +/*!************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/whitespace/whitespace.css ***! + \************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .mwh { + position: absolute; + color: var(--vscode-editorWhitespace-foreground) !important; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/viewParts/whitespace/whitespace.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,2DAA2D;AAC5D","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .mwh {\n\tposition: absolute;\n\tcolor: var(--vscode-editorWhitespace-foreground) !important;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/accessibleDiffViewer.css": +/*!*******************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/accessibleDiffViewer.css ***! + \*******************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-diff-editor .diff-review-line-number { + text-align: right; + display: inline-block; + color: var(--vscode-editorLineNumber-foreground); +} + +.monaco-diff-editor .diff-review { + position: absolute; + user-select: none; + -webkit-user-select: none; + z-index: 99; +} + +.monaco-diff-editor .diff-review-summary { + padding-left: 10px; +} + +.monaco-diff-editor .diff-review-shadow { + position: absolute; + box-shadow: var(--vscode-scrollbar-shadow) 0 -6px 6px -6px inset; +} + +.monaco-diff-editor .diff-review-row { + white-space: pre; +} + +.monaco-diff-editor .diff-review-table { + display: table; + min-width: 100%; +} + +.monaco-diff-editor .diff-review-row { + display: table-row; + width: 100%; +} + +.monaco-diff-editor .diff-review-spacer { + display: inline-block; + width: 10px; + vertical-align: middle; +} + +.monaco-diff-editor .diff-review-spacer > .codicon { + font-size: 9px !important; +} + +.monaco-diff-editor .diff-review-actions { + display: inline-block; + position: absolute; + right: 10px; + top: 2px; + z-index: 100; +} + +.monaco-diff-editor .diff-review-actions .action-label { + width: 16px; + height: 16px; + margin: 2px 0; +} + +.monaco-diff-editor .revertButton { + cursor: pointer; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/accessibleDiffViewer.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,iBAAiB;CACjB,qBAAqB;CACrB,gDAAgD;AACjD;;AAEA;CACC,kBAAkB;CAClB,iBAAiB;CACjB,yBAAyB;CACzB,WAAW;AACZ;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,kBAAkB;CAClB,gEAAgE;AACjE;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,cAAc;CACd,eAAe;AAChB;;AAEA;CACC,kBAAkB;CAClB,WAAW;AACZ;;AAEA;CACC,qBAAqB;CACrB,WAAW;CACX,sBAAsB;AACvB;;AAEA;CACC,yBAAyB;AAC1B;;AAEA;CACC,qBAAqB;CACrB,kBAAkB;CAClB,WAAW;CACX,QAAQ;CACR,YAAY;AACb;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,aAAa;AACd;;AAEA;CACC,eAAe;AAChB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-diff-editor .diff-review-line-number {\n\ttext-align: right;\n\tdisplay: inline-block;\n\tcolor: var(--vscode-editorLineNumber-foreground);\n}\n\n.monaco-diff-editor .diff-review {\n\tposition: absolute;\n\tuser-select: none;\n\t-webkit-user-select: none;\n\tz-index: 99;\n}\n\n.monaco-diff-editor .diff-review-summary {\n\tpadding-left: 10px;\n}\n\n.monaco-diff-editor .diff-review-shadow {\n\tposition: absolute;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 -6px 6px -6px inset;\n}\n\n.monaco-diff-editor .diff-review-row {\n\twhite-space: pre;\n}\n\n.monaco-diff-editor .diff-review-table {\n\tdisplay: table;\n\tmin-width: 100%;\n}\n\n.monaco-diff-editor .diff-review-row {\n\tdisplay: table-row;\n\twidth: 100%;\n}\n\n.monaco-diff-editor .diff-review-spacer {\n\tdisplay: inline-block;\n\twidth: 10px;\n\tvertical-align: middle;\n}\n\n.monaco-diff-editor .diff-review-spacer > .codicon {\n\tfont-size: 9px !important;\n}\n\n.monaco-diff-editor .diff-review-actions {\n\tdisplay: inline-block;\n\tposition: absolute;\n\tright: 10px;\n\ttop: 2px;\n\tz-index: 100;\n}\n\n.monaco-diff-editor .diff-review-actions .action-label {\n\twidth: 16px;\n\theight: 16px;\n\tmargin: 2px 0;\n}\n\n.monaco-diff-editor .revertButton {\n\tcursor: pointer;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/style.css": +/*!****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/style.css ***! + \****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .diff-hidden-lines-widget { + width: 100%; +} + +.monaco-editor .diff-hidden-lines { + height: 0px; /* The children each have a fixed height, the transform confuses the browser */ + transform: translate(0px, -10px); + font-size: 13px; + line-height: 14px; +} + +.monaco-editor .diff-hidden-lines:not(.dragging) .top:hover, +.monaco-editor .diff-hidden-lines:not(.dragging) .bottom:hover, +.monaco-editor .diff-hidden-lines .top.dragging, +.monaco-editor .diff-hidden-lines .bottom.dragging { + background-color: var(--vscode-focusBorder); +} + +.monaco-editor .diff-hidden-lines .top, +.monaco-editor .diff-hidden-lines .bottom { + transition: background-color 0.1s ease-out; + height: 4px; + background-color: transparent; + background-clip: padding-box; + border-bottom: 2px solid transparent; + border-top: 4px solid transparent; + /*cursor: n-resize;*/ +} + +.monaco-editor.draggingUnchangedRegion.canMoveTop:not(.canMoveBottom) *, +.monaco-editor .diff-hidden-lines .top.canMoveTop:not(.canMoveBottom), +.monaco-editor .diff-hidden-lines .bottom.canMoveTop:not(.canMoveBottom) { + cursor: n-resize !important; +} + +.monaco-editor.draggingUnchangedRegion:not(.canMoveTop).canMoveBottom *, +.monaco-editor .diff-hidden-lines .top:not(.canMoveTop).canMoveBottom, +.monaco-editor .diff-hidden-lines .bottom:not(.canMoveTop).canMoveBottom { + cursor: s-resize !important; +} + +.monaco-editor.draggingUnchangedRegion.canMoveTop.canMoveBottom *, +.monaco-editor .diff-hidden-lines .top.canMoveTop.canMoveBottom, +.monaco-editor .diff-hidden-lines .bottom.canMoveTop.canMoveBottom { + cursor: ns-resize !important; +} + +.monaco-editor .diff-hidden-lines .top { + transform: translate(0px, 4px); +} + +.monaco-editor .diff-hidden-lines .bottom { + transform: translate(0px, -6px); +} + +.monaco-editor .diff-unchanged-lines { + background: var(--vscode-diffEditor-unchangedCodeBackground); +} + +.monaco-editor .noModificationsOverlay { + z-index: 1; + background: var(--vscode-editor-background); + + display: flex; + justify-content: center; + align-items: center; +} + + +.monaco-editor .diff-hidden-lines .center { + background: var(--vscode-diffEditor-unchangedRegionBackground); + color: var(--vscode-diffEditor-unchangedRegionForeground); + overflow: hidden; + display: block; + text-overflow: ellipsis; + white-space: nowrap; + + height: 24px; + box-shadow: inset 0 -5px 5px -7px var(--vscode-diffEditor-unchangedRegionShadow), inset 0 5px 5px -7px var(--vscode-diffEditor-unchangedRegionShadow); +} + +.monaco-editor .diff-hidden-lines .center span.codicon { + vertical-align: middle; +} + +.monaco-editor .diff-hidden-lines .center a:hover .codicon { + cursor: pointer; + color: var(--vscode-editorLink-activeForeground) !important; +} + +.monaco-editor .diff-hidden-lines div.breadcrumb-item { + cursor: pointer; +} + +.monaco-editor .diff-hidden-lines div.breadcrumb-item:hover { + color: var(--vscode-editorLink-activeForeground); +} + +.monaco-editor .movedOriginal { + border: 2px solid var(--vscode-diffEditor-move-border); +} + +.monaco-editor .movedModified { + border: 2px solid var(--vscode-diffEditor-move-border); +} + +.monaco-editor .movedOriginal.currentMove, .monaco-editor .movedModified.currentMove { + border: 2px solid var(--vscode-diffEditor-moveActive-border); +} + +.monaco-diff-editor .moved-blocks-lines path.currentMove { + stroke: var(--vscode-diffEditor-moveActive-border); +} + +.monaco-diff-editor .moved-blocks-lines path { + pointer-events: visiblestroke; +} + +.monaco-diff-editor .moved-blocks-lines .arrow { + fill: var(--vscode-diffEditor-move-border); +} + +.monaco-diff-editor .moved-blocks-lines .arrow.currentMove { + fill: var(--vscode-diffEditor-moveActive-border); +} + +.monaco-diff-editor .moved-blocks-lines .arrow-rectangle { + fill: var(--vscode-editor-background); +} + +.monaco-diff-editor .moved-blocks-lines { + position: absolute; + pointer-events: none; +} + +.monaco-diff-editor .moved-blocks-lines path { + fill: none; + stroke: var(--vscode-diffEditor-move-border); + stroke-width: 2; +} + +.monaco-editor .char-delete.diff-range-empty { + margin-left: -1px; + border-left: solid var(--vscode-diffEditor-removedTextBackground) 3px; +} + +.monaco-editor .char-insert.diff-range-empty { + border-left: solid var(--vscode-diffEditor-insertedTextBackground) 3px; +} + +.monaco-editor .fold-unchanged { + cursor: pointer; +} + +.monaco-diff-editor .diff-moved-code-block { + display: flex; + justify-content: flex-end; + margin-top: -4px; +} + +.monaco-diff-editor .diff-moved-code-block .action-bar .action-label.codicon { + width: 12px; + height: 12px; + font-size: 12px; +} + +/* ---------- DiffEditor ---------- */ + +.monaco-diff-editor .diffOverview { + z-index: 9; +} + +.monaco-diff-editor .diffOverview .diffViewport { + z-index: 10; +} + +/* colors not externalized: using transparancy on background */ +.monaco-diff-editor.vs .diffOverview { background: rgba(0, 0, 0, 0.03); } +.monaco-diff-editor.vs-dark .diffOverview { background: rgba(255, 255, 255, 0.01); } + +.monaco-scrollable-element.modified-in-monaco-diff-editor.vs .scrollbar { background: rgba(0,0,0,0); } +.monaco-scrollable-element.modified-in-monaco-diff-editor.vs-dark .scrollbar { background: rgba(0,0,0,0); } +.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-black .scrollbar { background: none; } +.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-light .scrollbar { background: none; } + +.monaco-scrollable-element.modified-in-monaco-diff-editor .slider { + z-index: 10; +} +.modified-in-monaco-diff-editor .slider.active { background: rgba(171, 171, 171, .4); } +.modified-in-monaco-diff-editor.hc-black .slider.active { background: none; } +.modified-in-monaco-diff-editor.hc-light .slider.active { background: none; } + +/* ---------- Diff ---------- */ + +.monaco-editor .insert-sign, +.monaco-diff-editor .insert-sign, +.monaco-editor .delete-sign, +.monaco-diff-editor .delete-sign { + font-size: 11px !important; + opacity: 0.7 !important; + display: flex !important; + align-items: center; +} +.monaco-editor.hc-black .insert-sign, +.monaco-diff-editor.hc-black .insert-sign, +.monaco-editor.hc-black .delete-sign, +.monaco-diff-editor.hc-black .delete-sign, +.monaco-editor.hc-light .insert-sign, +.monaco-diff-editor.hc-light .insert-sign, +.monaco-editor.hc-light .delete-sign, +.monaco-diff-editor.hc-light .delete-sign { + opacity: 1; +} + +.monaco-editor .inline-deleted-margin-view-zone { + text-align: right; +} +.monaco-editor .inline-added-margin-view-zone { + text-align: right; +} + +.monaco-editor .arrow-revert-change { + z-index: 10; + position: absolute; +} + +.monaco-editor .arrow-revert-change:hover { + cursor: pointer; +} + +/* ---------- Inline Diff ---------- */ + +.monaco-editor .view-zones .view-lines .view-line span { + display: inline-block; +} + +.monaco-editor .margin-view-zones .lightbulb-glyph:hover { + cursor: pointer; +} + +.monaco-editor .char-insert, .monaco-diff-editor .char-insert { + background-color: var(--vscode-diffEditor-insertedTextBackground); +} + +.monaco-editor .line-insert, .monaco-diff-editor .line-insert { + background-color: var(--vscode-diffEditor-insertedLineBackground, var(--vscode-diffEditor-insertedTextBackground)); +} + +.monaco-editor .line-insert, +.monaco-editor .char-insert { + box-sizing: border-box; + border: 1px solid var(--vscode-diffEditor-insertedTextBorder); +} +.monaco-editor.hc-black .line-insert, .monaco-editor.hc-light .line-insert, +.monaco-editor.hc-black .char-insert, .monaco-editor.hc-light .char-insert { + border-style: dashed; +} + +.monaco-editor .line-delete, +.monaco-editor .char-delete { + box-sizing: border-box; + border: 1px solid var(--vscode-diffEditor-removedTextBorder); +} +.monaco-editor.hc-black .line-delete, .monaco-editor.hc-light .line-delete, +.monaco-editor.hc-black .char-delete, .monaco-editor.hc-light .char-delete { + border-style: dashed; +} + +.monaco-editor .inline-added-margin-view-zone, +.monaco-editor .gutter-insert, .monaco-diff-editor .gutter-insert { + background-color: var(--vscode-diffEditorGutter-insertedLineBackground, var(--vscode-diffEditor-insertedLineBackground), var(--vscode-diffEditor-insertedTextBackground)); +} + +.monaco-editor .char-delete, .monaco-diff-editor .char-delete { + background-color: var(--vscode-diffEditor-removedTextBackground); +} + +.monaco-editor .line-delete, .monaco-diff-editor .line-delete { + background-color: var(--vscode-diffEditor-removedLineBackground, var(--vscode-diffEditor-removedTextBackground)); +} + +.monaco-editor .inline-deleted-margin-view-zone, +.monaco-editor .gutter-delete, .monaco-diff-editor .gutter-delete { + background-color: var(--vscode-diffEditorGutter-removedLineBackground, var(--vscode-diffEditor-removedLineBackground), var(--vscode-diffEditor-removedTextBackground)); +} + +.monaco-diff-editor.side-by-side .editor.modified { + box-shadow: -6px 0 5px -5px var(--vscode-scrollbar-shadow); + border-left: 1px solid var(--vscode-diffEditor-border); +} + +.monaco-diff-editor .diffViewport { + background: var(--vscode-scrollbarSlider-background); +} + +.monaco-diff-editor .diffViewport:hover { + background: var(--vscode-scrollbarSlider-hoverBackground); +} + +.monaco-diff-editor .diffViewport:active { + background: var(--vscode-scrollbarSlider-activeBackground); +} + +.monaco-editor .diagonal-fill { + background-image: linear-gradient( + -45deg, + var(--vscode-diffEditor-diagonalFill) 12.5%, + #0000 12.5%, #0000 50%, + var(--vscode-diffEditor-diagonalFill) 50%, var(--vscode-diffEditor-diagonalFill) 62.5%, + #0000 62.5%, #0000 100% + ); + background-size: 8px 8px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/style.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,WAAW;AACZ;;AAEA;CACC,WAAW,EAAE,8EAA8E;CAC3F,gCAAgC;CAChC,eAAe;CACf,iBAAiB;AAClB;;AAEA;;;;CAIC,2CAA2C;AAC5C;;AAEA;;CAEC,0CAA0C;CAC1C,WAAW;CACX,6BAA6B;CAC7B,4BAA4B;CAC5B,oCAAoC;CACpC,iCAAiC;CACjC,oBAAoB;AACrB;;AAEA;;;CAGC,2BAA2B;AAC5B;;AAEA;;;CAGC,2BAA2B;AAC5B;;AAEA;;;CAGC,4BAA4B;AAC7B;;AAEA;CACC,8BAA8B;AAC/B;;AAEA;CACC,+BAA+B;AAChC;;AAEA;CACC,4DAA4D;AAC7D;;AAEA;CACC,UAAU;CACV,2CAA2C;;CAE3C,aAAa;CACb,uBAAuB;CACvB,mBAAmB;AACpB;;;AAGA;CACC,8DAA8D;CAC9D,yDAAyD;CACzD,gBAAgB;CAChB,cAAc;CACd,uBAAuB;CACvB,mBAAmB;;CAEnB,YAAY;CACZ,qJAAqJ;AACtJ;;AAEA;CACC,sBAAsB;AACvB;;AAEA;CACC,eAAe;CACf,2DAA2D;AAC5D;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,gDAAgD;AACjD;;AAEA;CACC,sDAAsD;AACvD;;AAEA;CACC,sDAAsD;AACvD;;AAEA;CACC,4DAA4D;AAC7D;;AAEA;CACC,kDAAkD;AACnD;;AAEA;CACC,6BAA6B;AAC9B;;AAEA;CACC,0CAA0C;AAC3C;;AAEA;CACC,gDAAgD;AACjD;;AAEA;CACC,qCAAqC;AACtC;;AAEA;CACC,kBAAkB;CAClB,oBAAoB;AACrB;;AAEA;CACC,UAAU;CACV,4CAA4C;CAC5C,eAAe;AAChB;;AAEA;CACC,iBAAiB;CACjB,qEAAqE;AACtE;;AAEA;CACC,sEAAsE;AACvE;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,aAAa;CACb,yBAAyB;CACzB,gBAAgB;AACjB;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,eAAe;AAChB;;AAEA,qCAAqC;;AAErC;CACC,UAAU;AACX;;AAEA;CACC,WAAW;AACZ;;AAEA,8DAA8D;AAC9D,yCAAyC,+BAA+B,EAAE;AAC1E,6CAA6C,qCAAqC,EAAE;;AAEpF,2EAA2E,yBAAyB,EAAE;AACtG,+EAA+E,yBAAyB,EAAE;AAC1G,gFAAgF,gBAAgB,EAAE;AAClG,gFAAgF,gBAAgB,EAAE;;AAElG;CACC,WAAW;AACZ;AACA,oDAAoD,mCAAmC,EAAE;AACzF,0DAA0D,gBAAgB,EAAE;AAC5E,0DAA0D,gBAAgB,EAAE;;AAE5E,+BAA+B;;AAE/B;;;;CAIC,0BAA0B;CAC1B,uBAAuB;CACvB,wBAAwB;CACxB,mBAAmB;AACpB;AACA;;;;;;;;CAQC,UAAU;AACX;;AAEA;CACC,iBAAiB;AAClB;AACA;CACC,iBAAiB;AAClB;;AAEA;CACC,WAAW;CACX,kBAAkB;AACnB;;AAEA;CACC,eAAe;AAChB;;AAEA,sCAAsC;;AAEtC;CACC,qBAAqB;AACtB;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,iEAAiE;AAClE;;AAEA;CACC,kHAAkH;AACnH;;AAEA;;CAEC,sBAAsB;CACtB,6DAA6D;AAC9D;AACA;;CAEC,oBAAoB;AACrB;;AAEA;;CAEC,sBAAsB;CACtB,4DAA4D;AAC7D;AACA;;CAEC,oBAAoB;AACrB;;AAEA;;CAEC,yKAAyK;AAC1K;;AAEA;CACC,gEAAgE;AACjE;;AAEA;CACC,gHAAgH;AACjH;;AAEA;;CAEC,sKAAsK;AACvK;;AAEA;CACC,0DAA0D;CAC1D,sDAAsD;AACvD;;AAEA;CACC,oDAAoD;AACrD;;AAEA;CACC,yDAAyD;AAC1D;;AAEA;CACC,0DAA0D;AAC3D;;AAEA;CACC;;;;;;EAMC;CACD,wBAAwB;AACzB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .diff-hidden-lines-widget {\n\twidth: 100%;\n}\n\n.monaco-editor .diff-hidden-lines {\n\theight: 0px; /* The children each have a fixed height, the transform confuses the browser */\n\ttransform: translate(0px, -10px);\n\tfont-size: 13px;\n\tline-height: 14px;\n}\n\n.monaco-editor .diff-hidden-lines:not(.dragging) .top:hover,\n.monaco-editor .diff-hidden-lines:not(.dragging) .bottom:hover,\n.monaco-editor .diff-hidden-lines .top.dragging,\n.monaco-editor .diff-hidden-lines .bottom.dragging {\n\tbackground-color: var(--vscode-focusBorder);\n}\n\n.monaco-editor .diff-hidden-lines .top,\n.monaco-editor .diff-hidden-lines .bottom {\n\ttransition: background-color 0.1s ease-out;\n\theight: 4px;\n\tbackground-color: transparent;\n\tbackground-clip: padding-box;\n\tborder-bottom: 2px solid transparent;\n\tborder-top: 4px solid transparent;\n\t/*cursor: n-resize;*/\n}\n\n.monaco-editor.draggingUnchangedRegion.canMoveTop:not(.canMoveBottom) *,\n.monaco-editor .diff-hidden-lines .top.canMoveTop:not(.canMoveBottom),\n.monaco-editor .diff-hidden-lines .bottom.canMoveTop:not(.canMoveBottom) {\n\tcursor: n-resize !important;\n}\n\n.monaco-editor.draggingUnchangedRegion:not(.canMoveTop).canMoveBottom *,\n.monaco-editor .diff-hidden-lines .top:not(.canMoveTop).canMoveBottom,\n.monaco-editor .diff-hidden-lines .bottom:not(.canMoveTop).canMoveBottom {\n\tcursor: s-resize !important;\n}\n\n.monaco-editor.draggingUnchangedRegion.canMoveTop.canMoveBottom *,\n.monaco-editor .diff-hidden-lines .top.canMoveTop.canMoveBottom,\n.monaco-editor .diff-hidden-lines .bottom.canMoveTop.canMoveBottom {\n\tcursor: ns-resize !important;\n}\n\n.monaco-editor .diff-hidden-lines .top {\n\ttransform: translate(0px, 4px);\n}\n\n.monaco-editor .diff-hidden-lines .bottom {\n\ttransform: translate(0px, -6px);\n}\n\n.monaco-editor .diff-unchanged-lines {\n\tbackground: var(--vscode-diffEditor-unchangedCodeBackground);\n}\n\n.monaco-editor .noModificationsOverlay {\n\tz-index: 1;\n\tbackground: var(--vscode-editor-background);\n\n\tdisplay: flex;\n\tjustify-content: center;\n\talign-items: center;\n}\n\n\n.monaco-editor .diff-hidden-lines .center {\n\tbackground: var(--vscode-diffEditor-unchangedRegionBackground);\n\tcolor: var(--vscode-diffEditor-unchangedRegionForeground);\n\toverflow: hidden;\n\tdisplay: block;\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n\n\theight: 24px;\n\tbox-shadow: inset 0 -5px 5px -7px var(--vscode-diffEditor-unchangedRegionShadow), inset 0 5px 5px -7px var(--vscode-diffEditor-unchangedRegionShadow);\n}\n\n.monaco-editor .diff-hidden-lines .center span.codicon {\n\tvertical-align: middle;\n}\n\n.monaco-editor .diff-hidden-lines .center a:hover .codicon {\n\tcursor: pointer;\n\tcolor: var(--vscode-editorLink-activeForeground) !important;\n}\n\n.monaco-editor .diff-hidden-lines div.breadcrumb-item {\n\tcursor: pointer;\n}\n\n.monaco-editor .diff-hidden-lines div.breadcrumb-item:hover {\n\tcolor: var(--vscode-editorLink-activeForeground);\n}\n\n.monaco-editor .movedOriginal {\n\tborder: 2px solid var(--vscode-diffEditor-move-border);\n}\n\n.monaco-editor .movedModified {\n\tborder: 2px solid var(--vscode-diffEditor-move-border);\n}\n\n.monaco-editor .movedOriginal.currentMove, .monaco-editor .movedModified.currentMove {\n\tborder: 2px solid var(--vscode-diffEditor-moveActive-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines path.currentMove {\n\tstroke: var(--vscode-diffEditor-moveActive-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines path {\n\tpointer-events: visiblestroke;\n}\n\n.monaco-diff-editor .moved-blocks-lines .arrow {\n\tfill: var(--vscode-diffEditor-move-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines .arrow.currentMove {\n\tfill: var(--vscode-diffEditor-moveActive-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines .arrow-rectangle {\n\tfill: var(--vscode-editor-background);\n}\n\n.monaco-diff-editor .moved-blocks-lines {\n\tposition: absolute;\n\tpointer-events: none;\n}\n\n.monaco-diff-editor .moved-blocks-lines path {\n\tfill: none;\n\tstroke: var(--vscode-diffEditor-move-border);\n\tstroke-width: 2;\n}\n\n.monaco-editor .char-delete.diff-range-empty {\n\tmargin-left: -1px;\n\tborder-left: solid var(--vscode-diffEditor-removedTextBackground) 3px;\n}\n\n.monaco-editor .char-insert.diff-range-empty {\n\tborder-left: solid var(--vscode-diffEditor-insertedTextBackground) 3px;\n}\n\n.monaco-editor .fold-unchanged {\n\tcursor: pointer;\n}\n\n.monaco-diff-editor .diff-moved-code-block {\n\tdisplay: flex;\n\tjustify-content: flex-end;\n\tmargin-top: -4px;\n}\n\n.monaco-diff-editor .diff-moved-code-block .action-bar .action-label.codicon {\n\twidth: 12px;\n\theight: 12px;\n\tfont-size: 12px;\n}\n\n/* ---------- DiffEditor ---------- */\n\n.monaco-diff-editor .diffOverview {\n\tz-index: 9;\n}\n\n.monaco-diff-editor .diffOverview .diffViewport {\n\tz-index: 10;\n}\n\n/* colors not externalized: using transparancy on background */\n.monaco-diff-editor.vs\t\t\t.diffOverview { background: rgba(0, 0, 0, 0.03); }\n.monaco-diff-editor.vs-dark\t\t.diffOverview { background: rgba(255, 255, 255, 0.01); }\n\n.monaco-scrollable-element.modified-in-monaco-diff-editor.vs\t\t.scrollbar { background: rgba(0,0,0,0); }\n.monaco-scrollable-element.modified-in-monaco-diff-editor.vs-dark\t.scrollbar { background: rgba(0,0,0,0); }\n.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-black\t.scrollbar { background: none; }\n.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-light\t.scrollbar { background: none; }\n\n.monaco-scrollable-element.modified-in-monaco-diff-editor .slider {\n\tz-index: 10;\n}\n.modified-in-monaco-diff-editor\t\t\t\t.slider.active { background: rgba(171, 171, 171, .4); }\n.modified-in-monaco-diff-editor.hc-black\t.slider.active { background: none; }\n.modified-in-monaco-diff-editor.hc-light\t.slider.active { background: none; }\n\n/* ---------- Diff ---------- */\n\n.monaco-editor .insert-sign,\n.monaco-diff-editor .insert-sign,\n.monaco-editor .delete-sign,\n.monaco-diff-editor .delete-sign {\n\tfont-size: 11px !important;\n\topacity: 0.7 !important;\n\tdisplay: flex !important;\n\talign-items: center;\n}\n.monaco-editor.hc-black .insert-sign,\n.monaco-diff-editor.hc-black .insert-sign,\n.monaco-editor.hc-black .delete-sign,\n.monaco-diff-editor.hc-black .delete-sign,\n.monaco-editor.hc-light .insert-sign,\n.monaco-diff-editor.hc-light .insert-sign,\n.monaco-editor.hc-light .delete-sign,\n.monaco-diff-editor.hc-light .delete-sign {\n\topacity: 1;\n}\n\n.monaco-editor .inline-deleted-margin-view-zone {\n\ttext-align: right;\n}\n.monaco-editor .inline-added-margin-view-zone {\n\ttext-align: right;\n}\n\n.monaco-editor .arrow-revert-change {\n\tz-index: 10;\n\tposition: absolute;\n}\n\n.monaco-editor .arrow-revert-change:hover {\n\tcursor: pointer;\n}\n\n/* ---------- Inline Diff ---------- */\n\n.monaco-editor .view-zones .view-lines .view-line span {\n\tdisplay: inline-block;\n}\n\n.monaco-editor .margin-view-zones .lightbulb-glyph:hover {\n\tcursor: pointer;\n}\n\n.monaco-editor .char-insert, .monaco-diff-editor .char-insert {\n\tbackground-color: var(--vscode-diffEditor-insertedTextBackground);\n}\n\n.monaco-editor .line-insert, .monaco-diff-editor .line-insert {\n\tbackground-color: var(--vscode-diffEditor-insertedLineBackground, var(--vscode-diffEditor-insertedTextBackground));\n}\n\n.monaco-editor .line-insert,\n.monaco-editor .char-insert {\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-diffEditor-insertedTextBorder);\n}\n.monaco-editor.hc-black .line-insert, .monaco-editor.hc-light .line-insert,\n.monaco-editor.hc-black .char-insert, .monaco-editor.hc-light .char-insert {\n\tborder-style: dashed;\n}\n\n.monaco-editor .line-delete,\n.monaco-editor .char-delete {\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-diffEditor-removedTextBorder);\n}\n.monaco-editor.hc-black .line-delete, .monaco-editor.hc-light .line-delete,\n.monaco-editor.hc-black .char-delete, .monaco-editor.hc-light .char-delete {\n\tborder-style: dashed;\n}\n\n.monaco-editor .inline-added-margin-view-zone,\n.monaco-editor .gutter-insert, .monaco-diff-editor .gutter-insert {\n\tbackground-color: var(--vscode-diffEditorGutter-insertedLineBackground, var(--vscode-diffEditor-insertedLineBackground), var(--vscode-diffEditor-insertedTextBackground));\n}\n\n.monaco-editor .char-delete, .monaco-diff-editor .char-delete {\n\tbackground-color: var(--vscode-diffEditor-removedTextBackground);\n}\n\n.monaco-editor .line-delete, .monaco-diff-editor .line-delete {\n\tbackground-color: var(--vscode-diffEditor-removedLineBackground, var(--vscode-diffEditor-removedTextBackground));\n}\n\n.monaco-editor .inline-deleted-margin-view-zone,\n.monaco-editor .gutter-delete, .monaco-diff-editor .gutter-delete {\n\tbackground-color: var(--vscode-diffEditorGutter-removedLineBackground, var(--vscode-diffEditor-removedLineBackground), var(--vscode-diffEditor-removedTextBackground));\n}\n\n.monaco-diff-editor.side-by-side .editor.modified {\n\tbox-shadow: -6px 0 5px -5px var(--vscode-scrollbar-shadow);\n\tborder-left: 1px solid var(--vscode-diffEditor-border);\n}\n\n.monaco-diff-editor .diffViewport {\n\tbackground: var(--vscode-scrollbarSlider-background);\n}\n\n.monaco-diff-editor .diffViewport:hover {\n\tbackground: var(--vscode-scrollbarSlider-hoverBackground);\n}\n\n.monaco-diff-editor .diffViewport:active {\n\tbackground: var(--vscode-scrollbarSlider-activeBackground);\n}\n\n.monaco-editor .diagonal-fill {\n\tbackground-image: linear-gradient(\n\t\t-45deg,\n\t\tvar(--vscode-diffEditor-diagonalFill) 12.5%,\n\t\t#0000 12.5%, #0000 50%,\n\t\tvar(--vscode-diffEditor-diagonalFill) 50%, var(--vscode-diffEditor-diagonalFill) 62.5%,\n\t\t#0000 62.5%, #0000 100%\n\t);\n\tbackground-size: 8px 8px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/media/editor.css": +/*!************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/media/editor.css ***! + \************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* -------------------- IE10 remove auto clear button -------------------- */ + +::-ms-clear { + display: none; +} + +/* All widgets */ +/* I am not a big fan of this rule */ +.monaco-editor .editor-widget input { + color: inherit; +} + +/* -------------------- Editor -------------------- */ + +.monaco-editor { + position: relative; + overflow: visible; + -webkit-text-size-adjust: 100%; + color: var(--vscode-editor-foreground); + background-color: var(--vscode-editor-background); +} +.monaco-editor-background { + background-color: var(--vscode-editor-background); +} +.monaco-editor .rangeHighlight { + background-color: var(--vscode-editor-rangeHighlightBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-rangeHighlightBorder); +} +.monaco-editor.hc-black .rangeHighlight, .monaco-editor.hc-light .rangeHighlight { + border-style: dotted; +} +.monaco-editor .symbolHighlight { + background-color: var(--vscode-editor-symbolHighlightBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-symbolHighlightBorder); +} +.monaco-editor.hc-black .symbolHighlight, .monaco-editor.hc-light .symbolHighlight { + border-style: dotted; +} + +/* -------------------- Misc -------------------- */ + +.monaco-editor .overflow-guard { + position: relative; + overflow: hidden; +} + +.monaco-editor .view-overlays { + position: absolute; + top: 0; +} + +/* +.monaco-editor .auto-closed-character { + opacity: 0.3; +} +*/ + + +.monaco-editor .squiggly-error { + border-bottom: 4px double var(--vscode-editorError-border); +} +.monaco-editor .squiggly-error::before { + display: block; + content: ''; + width: 100%; + height: 100%; + background: var(--vscode-editorError-background); +} +.monaco-editor .squiggly-warning { + border-bottom: 4px double var(--vscode-editorWarning-border); +} +.monaco-editor .squiggly-warning::before { + display: block; + content: ''; + width: 100%; + height: 100%; + background: var(--vscode-editorWarning-background); +} +.monaco-editor .squiggly-info { + border-bottom: 4px double var(--vscode-editorInfo-border); +} +.monaco-editor .squiggly-info::before { + display: block; + content: ''; + width: 100%; + height: 100%; + background: var(--vscode-editorInfo-background); +} +.monaco-editor .squiggly-hint { + border-bottom: 2px dotted var(--vscode-editorHint-border); +} +.monaco-editor.showUnused .squiggly-unnecessary { + border-bottom: 2px dashed var(--vscode-editorUnnecessaryCode-border); +} +.monaco-editor.showDeprecated .squiggly-inline-deprecated { + text-decoration: line-through; + text-decoration-color: var(--vscode-editor-foreground, inherit); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/widget/media/editor.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,4EAA4E;;AAE5E;CACC,aAAa;AACd;;AAEA,gBAAgB;AAChB,oCAAoC;AACpC;CACC,cAAc;AACf;;AAEA,qDAAqD;;AAErD;CACC,kBAAkB;CAClB,iBAAiB;CACjB,8BAA8B;CAC9B,sCAAsC;CACtC,iDAAiD;AAClD;AACA;CACC,iDAAiD;AAClD;AACA;CACC,+DAA+D;CAC/D,sBAAsB;CACtB,2DAA2D;AAC5D;AACA;CACC,oBAAoB;AACrB;AACA;CACC,gEAAgE;CAChE,sBAAsB;CACtB,4DAA4D;AAC7D;AACA;CACC,oBAAoB;AACrB;;AAEA,mDAAmD;;AAEnD;CACC,kBAAkB;CAClB,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;CAClB,MAAM;AACP;;AAEA;;;;CAIC;;;AAGD;CACC,0DAA0D;AAC3D;AACA;CACC,cAAc;CACd,WAAW;CACX,WAAW;CACX,YAAY;CACZ,gDAAgD;AACjD;AACA;CACC,4DAA4D;AAC7D;AACA;CACC,cAAc;CACd,WAAW;CACX,WAAW;CACX,YAAY;CACZ,kDAAkD;AACnD;AACA;CACC,yDAAyD;AAC1D;AACA;CACC,cAAc;CACd,WAAW;CACX,WAAW;CACX,YAAY;CACZ,+CAA+C;AAChD;AACA;CACC,yDAAyD;AAC1D;AACA;CACC,oEAAoE;AACrE;AACA;CACC,6BAA6B;CAC7B,+DAA+D;AAChE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* -------------------- IE10 remove auto clear button -------------------- */\n\n::-ms-clear {\n\tdisplay: none;\n}\n\n/* All widgets */\n/* I am not a big fan of this rule */\n.monaco-editor .editor-widget input {\n\tcolor: inherit;\n}\n\n/* -------------------- Editor -------------------- */\n\n.monaco-editor {\n\tposition: relative;\n\toverflow: visible;\n\t-webkit-text-size-adjust: 100%;\n\tcolor: var(--vscode-editor-foreground);\n\tbackground-color: var(--vscode-editor-background);\n}\n.monaco-editor-background {\n\tbackground-color: var(--vscode-editor-background);\n}\n.monaco-editor .rangeHighlight {\n\tbackground-color: var(--vscode-editor-rangeHighlightBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-rangeHighlightBorder);\n}\n.monaco-editor.hc-black .rangeHighlight, .monaco-editor.hc-light .rangeHighlight {\n\tborder-style: dotted;\n}\n.monaco-editor .symbolHighlight {\n\tbackground-color: var(--vscode-editor-symbolHighlightBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-symbolHighlightBorder);\n}\n.monaco-editor.hc-black .symbolHighlight, .monaco-editor.hc-light .symbolHighlight {\n\tborder-style: dotted;\n}\n\n/* -------------------- Misc -------------------- */\n\n.monaco-editor .overflow-guard {\n\tposition: relative;\n\toverflow: hidden;\n}\n\n.monaco-editor .view-overlays {\n\tposition: absolute;\n\ttop: 0;\n}\n\n/*\n.monaco-editor .auto-closed-character {\n\topacity: 0.3;\n}\n*/\n\n\n.monaco-editor .squiggly-error {\n\tborder-bottom: 4px double var(--vscode-editorError-border);\n}\n.monaco-editor .squiggly-error::before {\n\tdisplay: block;\n\tcontent: '';\n\twidth: 100%;\n\theight: 100%;\n\tbackground: var(--vscode-editorError-background);\n}\n.monaco-editor .squiggly-warning {\n\tborder-bottom: 4px double var(--vscode-editorWarning-border);\n}\n.monaco-editor .squiggly-warning::before {\n\tdisplay: block;\n\tcontent: '';\n\twidth: 100%;\n\theight: 100%;\n\tbackground: var(--vscode-editorWarning-background);\n}\n.monaco-editor .squiggly-info {\n\tborder-bottom: 4px double var(--vscode-editorInfo-border);\n}\n.monaco-editor .squiggly-info::before {\n\tdisplay: block;\n\tcontent: '';\n\twidth: 100%;\n\theight: 100%;\n\tbackground: var(--vscode-editorInfo-background);\n}\n.monaco-editor .squiggly-hint {\n\tborder-bottom: 2px dotted var(--vscode-editorHint-border);\n}\n.monaco-editor.showUnused .squiggly-unnecessary {\n\tborder-bottom: 2px dashed var(--vscode-editorUnnecessaryCode-border);\n}\n.monaco-editor.showDeprecated .squiggly-inline-deprecated {\n\ttext-decoration: line-through;\n\ttext-decoration-color: var(--vscode-editor-foreground, inherit);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/multiDiffEditorWidget/style.css": +/*!***************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/browser/widget/multiDiffEditorWidget/style.css ***! + \***************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-component .multiDiffEntry { + display: flex; + flex-direction: column; +} + +.monaco-component .multiDiffEntry .editorParent { + border-left: 2px var(--vscode-tab-inactiveBackground) solid; +} + +.monaco-component .multiDiffEntry.focused .editorParent { + border-left: 2px var(--vscode-notebook-focusedCellBorder) solid; +} + +.monaco-component .multiDiffEntry .editorParent .editorContainer { + border-left: 17px var(--vscode-tab-inactiveBackground) solid; +} + +.monaco-component .multiDiffEntry .collapse-button { + margin: 0 5px; + cursor: pointer; +} + +.monaco-component .multiDiffEntry .collapse-button a { + display: block; +} + +.monaco-component .multiDiffEntry .header { + display: flex; + align-items: center; + padding: 8px 5px; + color: var(--vscode-foreground); + background: var(--vscode-editor-background); + z-index: 1000; + + border-bottom: 1px var(--vscode-sideBarSectionHeader-border) solid; + border-top: 1px var(--vscode-sideBarSectionHeader-border) solid; + + border-left: 2px var(--vscode-editor-background) solid; +} +.monaco-component .multiDiffEntry.focused .header { + border-left: 2px var(--vscode-notebook-focusedCellBorder) solid; +} + +.monaco-component .multiDiffEntry .header.shadow { + box-shadow: var(--vscode-scrollbar-shadow) 0px 6px 6px -6px; +} + +.monaco-component .multiDiffEntry .header .title { + flex: 1; + font-size: 14px; + line-height: 22px; +} + +.monaco-component .multiDiffEntry .header .actions { + padding: 0 8px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/browser/widget/multiDiffEditorWidget/style.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,aAAa;CACb,sBAAsB;AACvB;;AAEA;CACC,2DAA2D;AAC5D;;AAEA;CACC,+DAA+D;AAChE;;AAEA;CACC,4DAA4D;AAC7D;;AAEA;CACC,aAAa;CACb,eAAe;AAChB;;AAEA;CACC,cAAc;AACf;;AAEA;CACC,aAAa;CACb,mBAAmB;CACnB,gBAAgB;CAChB,+BAA+B;CAC/B,2CAA2C;CAC3C,aAAa;;CAEb,mEAAmE;CACnE,gEAAgE;;CAEhE,sDAAsD;AACvD;AACA;CACC,+DAA+D;AAChE;;AAEA;CACC,2DAA2D;AAC5D;;AAEA;CACC,OAAO;CACP,eAAe;CACf,iBAAiB;AAClB;;AAEA;CACC,cAAc;AACf","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-component .multiDiffEntry {\n\tdisplay: flex;\n\tflex-direction: column;\n}\n\n.monaco-component .multiDiffEntry .editorParent {\n\tborder-left: 2px var(--vscode-tab-inactiveBackground) solid;\n}\n\n.monaco-component .multiDiffEntry.focused .editorParent {\n\tborder-left: 2px var(--vscode-notebook-focusedCellBorder) solid;\n}\n\n.monaco-component .multiDiffEntry .editorParent .editorContainer {\n\tborder-left: 17px var(--vscode-tab-inactiveBackground) solid;\n}\n\n.monaco-component .multiDiffEntry .collapse-button {\n\tmargin: 0 5px;\n\tcursor: pointer;\n}\n\n.monaco-component .multiDiffEntry .collapse-button a {\n\tdisplay: block;\n}\n\n.monaco-component .multiDiffEntry .header {\n\tdisplay: flex;\n\talign-items: center;\n\tpadding: 8px 5px;\n\tcolor: var(--vscode-foreground);\n\tbackground: var(--vscode-editor-background);\n\tz-index: 1000;\n\n\tborder-bottom: 1px var(--vscode-sideBarSectionHeader-border) solid;\n\tborder-top: 1px var(--vscode-sideBarSectionHeader-border) solid;\n\n\tborder-left: 2px var(--vscode-editor-background) solid;\n}\n.monaco-component .multiDiffEntry.focused .header {\n\tborder-left: 2px var(--vscode-notebook-focusedCellBorder) solid;\n}\n\n.monaco-component .multiDiffEntry .header.shadow {\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0px 6px 6px -6px;\n}\n\n.monaco-component .multiDiffEntry .header .title {\n\tflex: 1;\n\tfont-size: 14px;\n\tline-height: 22px;\n}\n\n.monaco-component .multiDiffEntry .header .actions {\n\tpadding: 0 8px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/anchorSelect/browser/anchorSelect.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/anchorSelect/browser/anchorSelect.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .selection-anchor { + background-color: #007ACC; + width: 2px !important; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/anchorSelect/browser/anchorSelect.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,yBAAyB;CACzB,qBAAqB;AACtB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .selection-anchor {\n\tbackground-color: #007ACC;\n\twidth: 2px !important;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/bracketMatching/browser/bracketMatching.css": +/*!********************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/bracketMatching/browser/bracketMatching.css ***! + \********************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .bracket-match { + box-sizing: border-box; + background-color: var(--vscode-editorBracketMatch-background); + border: 1px solid var(--vscode-editorBracketMatch-border); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/bracketMatching/browser/bracketMatching.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,sBAAsB;CACtB,6DAA6D;CAC7D,yDAAyD;AAC1D","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .bracket-match {\n\tbox-sizing: border-box;\n\tbackground-color: var(--vscode-editorBracketMatch-background);\n\tborder: 1px solid var(--vscode-editorBracketMatch-border);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/codeAction/browser/lightBulbWidget.css": +/*!***************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/codeAction/browser/lightBulbWidget.css ***! + \***************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .lightBulbWidget { + display: flex; + align-items: center; + justify-content: center; +} + +.monaco-editor .lightBulbWidget:hover{ + cursor: pointer; +} + +.monaco-editor .lightBulbWidget.codicon-light-bulb, +.monaco-editor .lightBulbWidget.codicon-lightbulb-sparkle { + color: var(--vscode-editorLightBulb-foreground); +} + +.monaco-editor .lightBulbWidget.codicon-lightbulb-autofix, +.monaco-editor .lightBulbWidget.codicon-lightbulb-sparkle-autofix { + color: var(--vscode-editorLightBulbAutoFix-foreground, var(--vscode-editorLightBulb-foreground)); +} + +.monaco-editor .lightBulbWidget.codicon-sparkle-filled { + color: var(--vscode-editorLightBulbAi-foreground, var(--vscode-icon-foreground)); +} + +.monaco-editor .lightBulbWidget:before { + position: relative; + z-index: 2; +} + +.monaco-editor .lightBulbWidget:after { + position: absolute; + top: 0; + left: 0; + content: ''; + display: block; + width: 100%; + height: 100%; + opacity: 0.3; + background-color: var(--vscode-editor-background); + z-index: 1; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/codeAction/browser/lightBulbWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,aAAa;CACb,mBAAmB;CACnB,uBAAuB;AACxB;;AAEA;CACC,eAAe;AAChB;;AAEA;;CAEC,+CAA+C;AAChD;;AAEA;;CAEC,gGAAgG;AACjG;;AAEA;CACC,gFAAgF;AACjF;;AAEA;CACC,kBAAkB;CAClB,UAAU;AACX;;AAEA;CACC,kBAAkB;CAClB,MAAM;CACN,OAAO;CACP,WAAW;CACX,cAAc;CACd,WAAW;CACX,YAAY;CACZ,YAAY;CACZ,iDAAiD;CACjD,UAAU;AACX","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .lightBulbWidget {\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n.monaco-editor .lightBulbWidget:hover{\n\tcursor: pointer;\n}\n\n.monaco-editor .lightBulbWidget.codicon-light-bulb,\n.monaco-editor .lightBulbWidget.codicon-lightbulb-sparkle {\n\tcolor: var(--vscode-editorLightBulb-foreground);\n}\n\n.monaco-editor .lightBulbWidget.codicon-lightbulb-autofix,\n.monaco-editor .lightBulbWidget.codicon-lightbulb-sparkle-autofix {\n\tcolor: var(--vscode-editorLightBulbAutoFix-foreground, var(--vscode-editorLightBulb-foreground));\n}\n\n.monaco-editor .lightBulbWidget.codicon-sparkle-filled {\n\tcolor: var(--vscode-editorLightBulbAi-foreground, var(--vscode-icon-foreground));\n}\n\n.monaco-editor .lightBulbWidget:before {\n\tposition: relative;\n\tz-index: 2;\n}\n\n.monaco-editor .lightBulbWidget:after {\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\tcontent: '';\n\tdisplay: block;\n\twidth: 100%;\n\theight: 100%;\n\topacity: 0.3;\n\tbackground-color: var(--vscode-editor-background);\n\tz-index: 1;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/codelens/browser/codelensWidget.css": +/*!************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/codelens/browser/codelensWidget.css ***! + \************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .codelens-decoration { + overflow: hidden; + display: inline-block; + text-overflow: ellipsis; + white-space: nowrap; + color: var(--vscode-editorCodeLens-foreground); + line-height: var(--vscode-editorCodeLens-lineHeight); + font-size: var(--vscode-editorCodeLens-fontSize); + padding-right: calc(var(--vscode-editorCodeLens-fontSize)*0.5); + font-feature-settings: var(--vscode-editorCodeLens-fontFeatureSettings); + font-family: var(--vscode-editorCodeLens-fontFamily), var(--vscode-editorCodeLens-fontFamilyDefault); +} + +.monaco-editor .codelens-decoration>span, +.monaco-editor .codelens-decoration>a { + user-select: none; + -webkit-user-select: none; + white-space: nowrap; + vertical-align: sub; +} + +.monaco-editor .codelens-decoration>a { + text-decoration: none; +} + +.monaco-editor .codelens-decoration>a:hover { + cursor: pointer; + color: var(--vscode-editorLink-activeForeground) !important; +} + +.monaco-editor .codelens-decoration>a:hover .codicon { + color: var(--vscode-editorLink-activeForeground) !important; +} + +.monaco-editor .codelens-decoration .codicon { + vertical-align: middle; + color: currentColor !important; + color: var(--vscode-editorCodeLens-foreground); + line-height: var(--vscode-editorCodeLens-lineHeight); + font-size: var(--vscode-editorCodeLens-fontSize); +} + +.monaco-editor .codelens-decoration>a:hover .codicon::before { + cursor: pointer; +} + +@keyframes fadein { + 0% { + opacity: 0; + visibility: visible; + } + + 100% { + opacity: 1; + } +} + +.monaco-editor .codelens-decoration.fadein { + animation: fadein 0.1s linear; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/codelens/browser/codelensWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,gBAAgB;CAChB,qBAAqB;CACrB,uBAAuB;CACvB,mBAAmB;CACnB,8CAA8C;CAC9C,oDAAoD;CACpD,gDAAgD;CAChD,8DAA8D;CAC9D,uEAAuE;CACvE,oGAAoG;AACrG;;AAEA;;CAEC,iBAAiB;CACjB,yBAAyB;CACzB,mBAAmB;CACnB,mBAAmB;AACpB;;AAEA;CACC,qBAAqB;AACtB;;AAEA;CACC,eAAe;CACf,2DAA2D;AAC5D;;AAEA;CACC,2DAA2D;AAC5D;;AAEA;CACC,sBAAsB;CACtB,8BAA8B;CAC9B,8CAA8C;CAC9C,oDAAoD;CACpD,gDAAgD;AACjD;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC;EACC,UAAU;EACV,mBAAmB;CACpB;;CAEA;EACC,UAAU;CACX;AACD;;AAEA;CACC,6BAA6B;AAC9B","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .codelens-decoration {\n\toverflow: hidden;\n\tdisplay: inline-block;\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n\tcolor: var(--vscode-editorCodeLens-foreground);\n\tline-height: var(--vscode-editorCodeLens-lineHeight);\n\tfont-size: var(--vscode-editorCodeLens-fontSize);\n\tpadding-right: calc(var(--vscode-editorCodeLens-fontSize)*0.5);\n\tfont-feature-settings: var(--vscode-editorCodeLens-fontFeatureSettings);\n\tfont-family: var(--vscode-editorCodeLens-fontFamily), var(--vscode-editorCodeLens-fontFamilyDefault);\n}\n\n.monaco-editor .codelens-decoration>span,\n.monaco-editor .codelens-decoration>a {\n\tuser-select: none;\n\t-webkit-user-select: none;\n\twhite-space: nowrap;\n\tvertical-align: sub;\n}\n\n.monaco-editor .codelens-decoration>a {\n\ttext-decoration: none;\n}\n\n.monaco-editor .codelens-decoration>a:hover {\n\tcursor: pointer;\n\tcolor: var(--vscode-editorLink-activeForeground) !important;\n}\n\n.monaco-editor .codelens-decoration>a:hover .codicon {\n\tcolor: var(--vscode-editorLink-activeForeground) !important;\n}\n\n.monaco-editor .codelens-decoration .codicon {\n\tvertical-align: middle;\n\tcolor: currentColor !important;\n\tcolor: var(--vscode-editorCodeLens-foreground);\n\tline-height: var(--vscode-editorCodeLens-lineHeight);\n\tfont-size: var(--vscode-editorCodeLens-fontSize);\n}\n\n.monaco-editor .codelens-decoration>a:hover .codicon::before {\n\tcursor: pointer;\n}\n\n@keyframes fadein {\n\t0% {\n\t\topacity: 0;\n\t\tvisibility: visible;\n\t}\n\n\t100% {\n\t\topacity: 1;\n\t}\n}\n\n.monaco-editor .codelens-decoration.fadein {\n\tanimation: fadein 0.1s linear;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/colorPicker/browser/colorPicker.css": +/*!************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/colorPicker/browser/colorPicker.css ***! + \************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/getUrl.js */ "./node_modules/css-loader/dist/runtime/getUrl.js"); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__); +// Imports + + + +var ___CSS_LOADER_URL_IMPORT_0___ = new URL(/* asset import */ __webpack_require__(/*! data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAYAAACp8Z5+AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuMTZEaa/1AAAAHUlEQVQYV2PYvXu3JAi7uLiAMaYAjAGTQBPYLQkAa/0Zef3qRswAAAAASUVORK5CYII= */ "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAYAAACp8Z5+AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuMTZEaa/1AAAAHUlEQVQYV2PYvXu3JAi7uLiAMaYAjAGTQBPYLQkAa/0Zef3qRswAAAAASUVORK5CYII="), __webpack_require__.b); +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +var ___CSS_LOADER_URL_REPLACEMENT_0___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_0___); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.colorpicker-widget { + height: 190px; + user-select: none; + -webkit-user-select: none; +} + +/* Decoration */ + +.colorpicker-color-decoration, +.hc-light .colorpicker-color-decoration { + border: solid 0.1em #000; + box-sizing: border-box; + margin: 0.1em 0.2em 0 0.2em; + width: 0.8em; + height: 0.8em; + line-height: 0.8em; + display: inline-block; + cursor: pointer; +} + +.hc-black .colorpicker-color-decoration, +.vs-dark .colorpicker-color-decoration { + border: solid 0.1em #eee; +} + +/* Header */ + +.colorpicker-header { + display: flex; + height: 24px; + position: relative; + background: url(${___CSS_LOADER_URL_REPLACEMENT_0___}); + background-size: 9px 9px; + image-rendering: pixelated; +} + +.colorpicker-header .picked-color { + width: 240px; + display: flex; + align-items: center; + justify-content: center; + line-height: 24px; + cursor: pointer; + color: white; + flex: 1; + white-space: nowrap; + overflow: hidden; +} + +.colorpicker-header .picked-color .picked-color-presentation { + white-space: nowrap; + margin-left: 5px; + margin-right: 5px; +} + +.colorpicker-header .picked-color .codicon { + color: inherit; + font-size: 14px; +} + +.colorpicker-header .picked-color.light { + color: black; +} + +.colorpicker-header .original-color { + width: 74px; + z-index: inherit; + cursor: pointer; +} + +.standalone-colorpicker { + color: var(--vscode-editorHoverWidget-foreground); + background-color: var(--vscode-editorHoverWidget-background); + border: 1px solid var(--vscode-editorHoverWidget-border); +} + +.colorpicker-header.standalone-colorpicker { + border-bottom: none; +} + +.colorpicker-header .close-button { + cursor: pointer; + background-color: var(--vscode-editorHoverWidget-background); + border-left: 1px solid var(--vscode-editorHoverWidget-border); +} + +.colorpicker-header .close-button-inner-div { + width: 100%; + height: 100%; + text-align: center; +} + +.colorpicker-header .close-button-inner-div:hover { + background-color: var(--vscode-toolbar-hoverBackground); +} + +.colorpicker-header .close-icon { + padding: 3px; +} + +/* Body */ + +.colorpicker-body { + display: flex; + padding: 8px; + position: relative; +} + +.colorpicker-body .saturation-wrap { + overflow: hidden; + height: 150px; + position: relative; + min-width: 220px; + flex: 1; +} + +.colorpicker-body .saturation-box { + height: 150px; + position: absolute; +} + +.colorpicker-body .saturation-selection { + width: 9px; + height: 9px; + margin: -5px 0 0 -5px; + border: 1px solid rgb(255, 255, 255); + border-radius: 100%; + box-shadow: 0px 0px 2px rgba(0, 0, 0, 0.8); + position: absolute; +} + +.colorpicker-body .strip { + width: 25px; + height: 150px; +} + +.colorpicker-body .standalone-strip { + width: 25px; + height: 122px; +} + +.colorpicker-body .hue-strip { + position: relative; + margin-left: 8px; + cursor: grab; + background: linear-gradient(to bottom, #ff0000 0%, #ffff00 17%, #00ff00 33%, #00ffff 50%, #0000ff 67%, #ff00ff 83%, #ff0000 100%); +} + +.colorpicker-body .opacity-strip { + position: relative; + margin-left: 8px; + cursor: grab; + background: url(${___CSS_LOADER_URL_REPLACEMENT_0___}); + background-size: 9px 9px; + image-rendering: pixelated; +} + +.colorpicker-body .strip.grabbing { + cursor: grabbing; +} + +.colorpicker-body .slider { + position: absolute; + top: 0; + left: -2px; + width: calc(100% + 4px); + height: 4px; + box-sizing: border-box; + border: 1px solid rgba(255, 255, 255, 0.71); + box-shadow: 0px 0px 1px rgba(0, 0, 0, 0.85); +} + +.colorpicker-body .strip .overlay { + height: 150px; + pointer-events: none; +} + +.colorpicker-body .standalone-strip .standalone-overlay { + height: 122px; + pointer-events: none; +} + +.standalone-colorpicker-body { + display: block; + border: 1px solid transparent; + border-bottom: 1px solid var(--vscode-editorHoverWidget-border); + overflow: hidden; +} + +.colorpicker-body .insert-button { + position: absolute; + height: 20px; + width: 58px; + padding: 0px; + right: 8px; + bottom: 8px; + background: var(--vscode-button-background); + color: var(--vscode-button-foreground); + border-radius: 2px; + border: none; + cursor: pointer; +} + +.colorpicker-body .insert-button:hover{ + background: var(--vscode-button-hoverBackground); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/colorPicker/browser/colorPicker.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,aAAa;CACb,iBAAiB;CACjB,yBAAyB;AAC1B;;AAEA,eAAe;;AAEf;;CAEC,wBAAwB;CACxB,sBAAsB;CACtB,2BAA2B;CAC3B,YAAY;CACZ,aAAa;CACb,kBAAkB;CAClB,qBAAqB;CACrB,eAAe;AAChB;;AAEA;;CAEC,wBAAwB;AACzB;;AAEA,WAAW;;AAEX;CACC,aAAa;CACb,YAAY;CACZ,kBAAkB;CAClB,mDAAiR;CACjR,wBAAwB;CACxB,0BAA0B;AAC3B;;AAEA;CACC,YAAY;CACZ,aAAa;CACb,mBAAmB;CACnB,uBAAuB;CACvB,iBAAiB;CACjB,eAAe;CACf,YAAY;CACZ,OAAO;CACP,mBAAmB;CACnB,gBAAgB;AACjB;;AAEA;CACC,mBAAmB;CACnB,gBAAgB;CAChB,iBAAiB;AAClB;;AAEA;CACC,cAAc;CACd,eAAe;AAChB;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,WAAW;CACX,gBAAgB;CAChB,eAAe;AAChB;;AAEA;CACC,iDAAiD;CACjD,4DAA4D;CAC5D,wDAAwD;AACzD;;AAEA;CACC,mBAAmB;AACpB;;AAEA;CACC,eAAe;CACf,4DAA4D;CAC5D,6DAA6D;AAC9D;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,kBAAkB;AACnB;;AAEA;CACC,uDAAuD;AACxD;;AAEA;CACC,YAAY;AACb;;AAEA,SAAS;;AAET;CACC,aAAa;CACb,YAAY;CACZ,kBAAkB;AACnB;;AAEA;CACC,gBAAgB;CAChB,aAAa;CACb,kBAAkB;CAClB,gBAAgB;CAChB,OAAO;AACR;;AAEA;CACC,aAAa;CACb,kBAAkB;AACnB;;AAEA;CACC,UAAU;CACV,WAAW;CACX,qBAAqB;CACrB,oCAAoC;CACpC,mBAAmB;CACnB,0CAA0C;CAC1C,kBAAkB;AACnB;;AAEA;CACC,WAAW;CACX,aAAa;AACd;;AAEA;CACC,WAAW;CACX,aAAa;AACd;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;CAChB,YAAY;CACZ,iIAAiI;AAClI;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;CAChB,YAAY;CACZ,mDAAiR;CACjR,wBAAwB;CACxB,0BAA0B;AAC3B;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;CAClB,MAAM;CACN,UAAU;CACV,uBAAuB;CACvB,WAAW;CACX,sBAAsB;CACtB,2CAA2C;CAC3C,2CAA2C;AAC5C;;AAEA;CACC,aAAa;CACb,oBAAoB;AACrB;;AAEA;CACC,aAAa;CACb,oBAAoB;AACrB;;AAEA;CACC,cAAc;CACd,6BAA6B;CAC7B,+DAA+D;CAC/D,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;CAClB,YAAY;CACZ,WAAW;CACX,YAAY;CACZ,UAAU;CACV,WAAW;CACX,2CAA2C;CAC3C,sCAAsC;CACtC,kBAAkB;CAClB,YAAY;CACZ,eAAe;AAChB;;AAEA;CACC,gDAAgD;AACjD","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.colorpicker-widget {\n\theight: 190px;\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n/* Decoration */\n\n.colorpicker-color-decoration,\n.hc-light .colorpicker-color-decoration {\n\tborder: solid 0.1em #000;\n\tbox-sizing: border-box;\n\tmargin: 0.1em 0.2em 0 0.2em;\n\twidth: 0.8em;\n\theight: 0.8em;\n\tline-height: 0.8em;\n\tdisplay: inline-block;\n\tcursor: pointer;\n}\n\n.hc-black .colorpicker-color-decoration,\n.vs-dark .colorpicker-color-decoration {\n\tborder: solid 0.1em #eee;\n}\n\n/* Header */\n\n.colorpicker-header {\n\tdisplay: flex;\n\theight: 24px;\n\tposition: relative;\n\tbackground: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAYAAACp8Z5+AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuMTZEaa/1AAAAHUlEQVQYV2PYvXu3JAi7uLiAMaYAjAGTQBPYLQkAa/0Zef3qRswAAAAASUVORK5CYII=\");\n\tbackground-size: 9px 9px;\n\timage-rendering: pixelated;\n}\n\n.colorpicker-header .picked-color {\n\twidth: 240px;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n\tline-height: 24px;\n\tcursor: pointer;\n\tcolor: white;\n\tflex: 1;\n\twhite-space: nowrap;\n\toverflow: hidden;\n}\n\n.colorpicker-header .picked-color .picked-color-presentation {\n\twhite-space: nowrap;\n\tmargin-left: 5px;\n\tmargin-right: 5px;\n}\n\n.colorpicker-header .picked-color .codicon {\n\tcolor: inherit;\n\tfont-size: 14px;\n}\n\n.colorpicker-header .picked-color.light {\n\tcolor: black;\n}\n\n.colorpicker-header .original-color {\n\twidth: 74px;\n\tz-index: inherit;\n\tcursor: pointer;\n}\n\n.standalone-colorpicker {\n\tcolor: var(--vscode-editorHoverWidget-foreground);\n\tbackground-color: var(--vscode-editorHoverWidget-background);\n\tborder: 1px solid var(--vscode-editorHoverWidget-border);\n}\n\n.colorpicker-header.standalone-colorpicker {\n\tborder-bottom: none;\n}\n\n.colorpicker-header .close-button {\n\tcursor: pointer;\n\tbackground-color: var(--vscode-editorHoverWidget-background);\n\tborder-left: 1px solid var(--vscode-editorHoverWidget-border);\n}\n\n.colorpicker-header .close-button-inner-div {\n\twidth: 100%;\n\theight: 100%;\n\ttext-align: center;\n}\n\n.colorpicker-header .close-button-inner-div:hover {\n\tbackground-color: var(--vscode-toolbar-hoverBackground);\n}\n\n.colorpicker-header .close-icon {\n\tpadding: 3px;\n}\n\n/* Body */\n\n.colorpicker-body {\n\tdisplay: flex;\n\tpadding: 8px;\n\tposition: relative;\n}\n\n.colorpicker-body .saturation-wrap {\n\toverflow: hidden;\n\theight: 150px;\n\tposition: relative;\n\tmin-width: 220px;\n\tflex: 1;\n}\n\n.colorpicker-body .saturation-box {\n\theight: 150px;\n\tposition: absolute;\n}\n\n.colorpicker-body .saturation-selection {\n\twidth: 9px;\n\theight: 9px;\n\tmargin: -5px 0 0 -5px;\n\tborder: 1px solid rgb(255, 255, 255);\n\tborder-radius: 100%;\n\tbox-shadow: 0px 0px 2px rgba(0, 0, 0, 0.8);\n\tposition: absolute;\n}\n\n.colorpicker-body .strip {\n\twidth: 25px;\n\theight: 150px;\n}\n\n.colorpicker-body .standalone-strip {\n\twidth: 25px;\n\theight: 122px;\n}\n\n.colorpicker-body .hue-strip {\n\tposition: relative;\n\tmargin-left: 8px;\n\tcursor: grab;\n\tbackground: linear-gradient(to bottom, #ff0000 0%, #ffff00 17%, #00ff00 33%, #00ffff 50%, #0000ff 67%, #ff00ff 83%, #ff0000 100%);\n}\n\n.colorpicker-body .opacity-strip {\n\tposition: relative;\n\tmargin-left: 8px;\n\tcursor: grab;\n\tbackground: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAYAAACp8Z5+AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuMTZEaa/1AAAAHUlEQVQYV2PYvXu3JAi7uLiAMaYAjAGTQBPYLQkAa/0Zef3qRswAAAAASUVORK5CYII=\");\n\tbackground-size: 9px 9px;\n\timage-rendering: pixelated;\n}\n\n.colorpicker-body .strip.grabbing {\n\tcursor: grabbing;\n}\n\n.colorpicker-body .slider {\n\tposition: absolute;\n\ttop: 0;\n\tleft: -2px;\n\twidth: calc(100% + 4px);\n\theight: 4px;\n\tbox-sizing: border-box;\n\tborder: 1px solid rgba(255, 255, 255, 0.71);\n\tbox-shadow: 0px 0px 1px rgba(0, 0, 0, 0.85);\n}\n\n.colorpicker-body .strip .overlay {\n\theight: 150px;\n\tpointer-events: none;\n}\n\n.colorpicker-body .standalone-strip .standalone-overlay {\n\theight: 122px;\n\tpointer-events: none;\n}\n\n.standalone-colorpicker-body {\n\tdisplay: block;\n\tborder: 1px solid transparent;\n\tborder-bottom: 1px solid var(--vscode-editorHoverWidget-border);\n\toverflow: hidden;\n}\n\n.colorpicker-body .insert-button {\n\tposition: absolute;\n\theight: 20px;\n\twidth: 58px;\n\tpadding: 0px;\n\tright: 8px;\n\tbottom: 8px;\n\tbackground: var(--vscode-button-background);\n\tcolor: var(--vscode-button-foreground);\n\tborder-radius: 2px;\n\tborder: none;\n\tcursor: pointer;\n}\n\n.colorpicker-body .insert-button:hover{\n\tbackground: var(--vscode-button-hoverBackground);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/dnd/browser/dnd.css": +/*!********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/dnd/browser/dnd.css ***! + \********************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor.vs .dnd-target, +.monaco-editor.hc-light .dnd-target { + border-right: 2px dotted black; + color: white; /* opposite of black */ +} +.monaco-editor.vs-dark .dnd-target { + border-right: 2px dotted #AEAFAD; + color: #51504f; /* opposite of #AEAFAD */ +} +.monaco-editor.hc-black .dnd-target { + border-right: 2px dotted #fff; + color: #000; /* opposite of #fff */ +} + +.monaco-editor.mouse-default .view-lines, +.monaco-editor.vs-dark.mac.mouse-default .view-lines, +.monaco-editor.hc-black.mac.mouse-default .view-lines, +.monaco-editor.hc-light.mac.mouse-default .view-lines { + cursor: default; +} +.monaco-editor.mouse-copy .view-lines, +.monaco-editor.vs-dark.mac.mouse-copy .view-lines, +.monaco-editor.hc-black.mac.mouse-copy .view-lines, +.monaco-editor.hc-light.mac.mouse-copy .view-lines { + cursor: copy; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/dnd/browser/dnd.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;;CAEC,8BAA8B;CAC9B,YAAY,EAAE,sBAAsB;AACrC;AACA;CACC,gCAAgC;CAChC,cAAc,EAAE,wBAAwB;AACzC;AACA;CACC,6BAA6B;CAC7B,WAAW,EAAE,qBAAqB;AACnC;;AAEA;;;;CAIC,eAAe;AAChB;AACA;;;;CAIC,YAAY;AACb","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor.vs .dnd-target,\n.monaco-editor.hc-light .dnd-target {\n\tborder-right: 2px dotted black;\n\tcolor: white; /* opposite of black */\n}\n.monaco-editor.vs-dark .dnd-target {\n\tborder-right: 2px dotted #AEAFAD;\n\tcolor: #51504f; /* opposite of #AEAFAD */\n}\n.monaco-editor.hc-black .dnd-target {\n\tborder-right: 2px dotted #fff;\n\tcolor: #000; /* opposite of #fff */\n}\n\n.monaco-editor.mouse-default .view-lines,\n.monaco-editor.vs-dark.mac.mouse-default .view-lines,\n.monaco-editor.hc-black.mac.mouse-default .view-lines,\n.monaco-editor.hc-light.mac.mouse-default .view-lines {\n\tcursor: default;\n}\n.monaco-editor.mouse-copy .view-lines,\n.monaco-editor.vs-dark.mac.mouse-copy .view-lines,\n.monaco-editor.hc-black.mac.mouse-copy .view-lines,\n.monaco-editor.hc-light.mac.mouse-copy .view-lines {\n\tcursor: copy;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/dropOrPasteInto/browser/postEditWidget.css": +/*!*******************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/dropOrPasteInto/browser/postEditWidget.css ***! + \*******************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.post-edit-widget { + box-shadow: 0 0 8px 2px var(--vscode-widget-shadow); + border: 1px solid var(--vscode-widget-border, transparent); + border-radius: 4px; + background-color: var(--vscode-editorWidget-background); + overflow: hidden; +} + +.post-edit-widget .monaco-button { + padding: 2px; + border: none; + border-radius: 0; +} + +.post-edit-widget .monaco-button:hover { + background-color: var(--vscode-button-secondaryHoverBackground) !important; +} + +.post-edit-widget .monaco-button .codicon { + margin: 0; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/dropOrPasteInto/browser/postEditWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,mDAAmD;CACnD,0DAA0D;CAC1D,kBAAkB;CAClB,uDAAuD;CACvD,gBAAgB;AACjB;;AAEA;CACC,YAAY;CACZ,YAAY;CACZ,gBAAgB;AACjB;;AAEA;CACC,0EAA0E;AAC3E;;AAEA;CACC,SAAS;AACV","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.post-edit-widget {\n\tbox-shadow: 0 0 8px 2px var(--vscode-widget-shadow);\n\tborder: 1px solid var(--vscode-widget-border, transparent);\n\tborder-radius: 4px;\n\tbackground-color: var(--vscode-editorWidget-background);\n\toverflow: hidden;\n}\n\n.post-edit-widget .monaco-button {\n\tpadding: 2px;\n\tborder: none;\n\tborder-radius: 0;\n}\n\n.post-edit-widget .monaco-button:hover {\n\tbackground-color: var(--vscode-button-secondaryHoverBackground) !important;\n}\n\n.post-edit-widget .monaco-button .codicon {\n\tmargin: 0;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/find/browser/findOptionsWidget.css": +/*!***********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/find/browser/findOptionsWidget.css ***! + \***********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .findOptionsWidget { + background-color: var(--vscode-editorWidget-background); + color: var(--vscode-editorWidget-foreground); + box-shadow: 0 0 8px 2px var(--vscode-widget-shadow); + border: 2px solid var(--vscode-contrastBorder); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/find/browser/findOptionsWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,uDAAuD;CACvD,4CAA4C;CAC5C,mDAAmD;CACnD,8CAA8C;AAC/C","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .findOptionsWidget {\n\tbackground-color: var(--vscode-editorWidget-background);\n\tcolor: var(--vscode-editorWidget-foreground);\n\tbox-shadow: 0 0 8px 2px var(--vscode-widget-shadow);\n\tborder: 2px solid var(--vscode-contrastBorder);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/find/browser/findWidget.css": +/*!****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/find/browser/findWidget.css ***! + \****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* Find widget */ +.monaco-editor .find-widget { + position: absolute; + z-index: 35; + height: 33px; + overflow: hidden; + line-height: 19px; + transition: transform 200ms linear; + padding: 0 4px; + box-sizing: border-box; + transform: translateY(calc(-100% - 10px)); /* shadow (10px) */ + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; +} + +.monaco-workbench.reduce-motion .monaco-editor .find-widget { + transition: transform 0ms linear; +} + +.monaco-editor .find-widget textarea { + margin: 0px; +} + +.monaco-editor .find-widget.hiddenEditor { + display: none; +} + +/* Find widget when replace is toggled on */ +.monaco-editor .find-widget.replaceToggled > .replace-part { + display: flex; +} + +.monaco-editor .find-widget.visible { + transform: translateY(0); +} + +.monaco-editor .find-widget .monaco-inputbox.synthetic-focus { + outline: 1px solid -webkit-focus-ring-color; + outline-offset: -1px; +} + +.monaco-editor .find-widget .monaco-inputbox .input { + background-color: transparent; + min-height: 0; +} + +.monaco-editor .find-widget .monaco-findInput .input { + font-size: 13px; +} + +.monaco-editor .find-widget > .find-part, +.monaco-editor .find-widget > .replace-part { + margin: 3px 25px 0 17px; + font-size: 12px; + display: flex; +} + +.monaco-editor .find-widget > .find-part .monaco-inputbox, +.monaco-editor .find-widget > .replace-part .monaco-inputbox { + min-height: 25px; +} + + +.monaco-editor .find-widget > .replace-part .monaco-inputbox > .ibwrapper > .mirror { + padding-right: 22px; +} + +.monaco-editor .find-widget > .find-part .monaco-inputbox > .ibwrapper > .input, +.monaco-editor .find-widget > .find-part .monaco-inputbox > .ibwrapper > .mirror, +.monaco-editor .find-widget > .replace-part .monaco-inputbox > .ibwrapper > .input, +.monaco-editor .find-widget > .replace-part .monaco-inputbox > .ibwrapper > .mirror { + padding-top: 2px; + padding-bottom: 2px; +} + +.monaco-editor .find-widget > .find-part .find-actions { + height: 25px; + display: flex; + align-items: center; +} + +.monaco-editor .find-widget > .replace-part .replace-actions { + height: 25px; + display: flex; + align-items: center; +} + +.monaco-editor .find-widget .monaco-findInput { + vertical-align: middle; + display: flex; + flex:1; +} + +.monaco-editor .find-widget .monaco-findInput .monaco-scrollable-element { + /* Make sure textarea inherits the width correctly */ + width: 100%; +} + +.monaco-editor .find-widget .monaco-findInput .monaco-scrollable-element .scrollbar.vertical { + /* Hide vertical scrollbar */ + opacity: 0; +} + +.monaco-editor .find-widget .matchesCount { + display: flex; + flex: initial; + margin: 0 0 0 3px; + padding: 2px 0 0 2px; + height: 25px; + vertical-align: middle; + box-sizing: border-box; + text-align: center; + line-height: 23px; +} + +.monaco-editor .find-widget .button { + width: 16px; + height: 16px; + padding: 3px; + border-radius: 5px; + display: flex; + flex: initial; + margin-left: 3px; + background-position: center center; + background-repeat: no-repeat; + cursor: pointer; + display: flex; + align-items: center; + justify-content: center; +} + +/* find in selection button */ +.monaco-editor .find-widget .codicon-find-selection { + width: 22px; + height: 22px; + padding: 3px; + border-radius: 5px; +} + +.monaco-editor .find-widget .button.left { + margin-left: 0; + margin-right: 3px; +} + +.monaco-editor .find-widget .button.wide { + width: auto; + padding: 1px 6px; + top: -1px; +} + +.monaco-editor .find-widget .button.toggle { + position: absolute; + top: 0; + left: 3px; + width: 18px; + height: 100%; + border-radius: 0; + box-sizing: border-box; +} + +.monaco-editor .find-widget .button.toggle.disabled { + display: none; +} + +.monaco-editor .find-widget .disabled { + color: var(--vscode-disabledForeground); + cursor: default; +} + +.monaco-editor .find-widget > .replace-part { + display: none; +} + +.monaco-editor .find-widget > .replace-part > .monaco-findInput { + position: relative; + display: flex; + vertical-align: middle; + flex: auto; + flex-grow: 0; + flex-shrink: 0; +} + +.monaco-editor .find-widget > .replace-part > .monaco-findInput > .controls { + position: absolute; + top: 3px; + right: 2px; +} + +/* REDUCED */ +.monaco-editor .find-widget.reduced-find-widget .matchesCount { + display:none; +} + +/* NARROW (SMALLER THAN REDUCED) */ +.monaco-editor .find-widget.narrow-find-widget { + max-width: 257px !important; +} + +/* COLLAPSED (SMALLER THAN NARROW) */ +.monaco-editor .find-widget.collapsed-find-widget { + max-width: 170px !important; +} + +.monaco-editor .find-widget.collapsed-find-widget .button.previous, +.monaco-editor .find-widget.collapsed-find-widget .button.next, +.monaco-editor .find-widget.collapsed-find-widget .button.replace, +.monaco-editor .find-widget.collapsed-find-widget .button.replace-all, +.monaco-editor .find-widget.collapsed-find-widget > .find-part .monaco-findInput .controls { + display:none; +} + +.monaco-editor .findMatch { + animation-duration: 0; + animation-name: inherit !important; +} + +.monaco-editor .find-widget .monaco-sash { + left: 0 !important; +} + +.monaco-editor.hc-black .find-widget .button:before { + position: relative; + top: 1px; + left: 2px; +} + +/* Close button position. */ +.monaco-editor .find-widget > .button.codicon-widget-close { + position: absolute; + top: 5px; + right: 4px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/find/browser/findWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,gBAAgB;AAChB;CACC,kBAAkB;CAClB,WAAW;CACX,YAAY;CACZ,gBAAgB;CAChB,iBAAiB;CACjB,kCAAkC;CAClC,cAAc;CACd,sBAAsB;CACtB,yCAAyC,EAAE,kBAAkB;CAC7D,8BAA8B;CAC9B,+BAA+B;AAChC;;AAEA;CACC,gCAAgC;AACjC;;AAEA;CACC,WAAW;AACZ;;AAEA;CACC,aAAa;AACd;;AAEA,2CAA2C;AAC3C;CACC,aAAa;AACd;;AAEA;CACC,wBAAwB;AACzB;;AAEA;CACC,2CAA2C;CAC3C,oBAAoB;AACrB;;AAEA;CACC,6BAA6B;CAC7B,aAAa;AACd;;AAEA;CACC,eAAe;AAChB;;AAEA;;CAEC,uBAAuB;CACvB,eAAe;CACf,aAAa;AACd;;AAEA;;CAEC,gBAAgB;AACjB;;;AAGA;CACC,mBAAmB;AACpB;;AAEA;;;;CAIC,gBAAgB;CAChB,mBAAmB;AACpB;;AAEA;CACC,YAAY;CACZ,aAAa;CACb,mBAAmB;AACpB;;AAEA;CACC,YAAY;CACZ,aAAa;CACb,mBAAmB;AACpB;;AAEA;CACC,sBAAsB;CACtB,aAAa;CACb,MAAM;AACP;;AAEA;CACC,oDAAoD;CACpD,WAAW;AACZ;;AAEA;CACC,4BAA4B;CAC5B,UAAU;AACX;;AAEA;CACC,aAAa;CACb,aAAa;CACb,iBAAiB;CACjB,oBAAoB;CACpB,YAAY;CACZ,sBAAsB;CACtB,sBAAsB;CACtB,kBAAkB;CAClB,iBAAiB;AAClB;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,YAAY;CACZ,kBAAkB;CAClB,aAAa;CACb,aAAa;CACb,gBAAgB;CAChB,kCAAkC;CAClC,4BAA4B;CAC5B,eAAe;CACf,aAAa;CACb,mBAAmB;CACnB,uBAAuB;AACxB;;AAEA,6BAA6B;AAC7B;CACC,WAAW;CACX,YAAY;CACZ,YAAY;CACZ,kBAAkB;AACnB;;AAEA;CACC,cAAc;CACd,iBAAiB;AAClB;;AAEA;CACC,WAAW;CACX,gBAAgB;CAChB,SAAS;AACV;;AAEA;CACC,kBAAkB;CAClB,MAAM;CACN,SAAS;CACT,WAAW;CACX,YAAY;CACZ,gBAAgB;CAChB,sBAAsB;AACvB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,uCAAuC;CACvC,eAAe;AAChB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,kBAAkB;CAClB,aAAa;CACb,sBAAsB;CACtB,UAAU;CACV,YAAY;CACZ,cAAc;AACf;;AAEA;CACC,kBAAkB;CAClB,QAAQ;CACR,UAAU;AACX;;AAEA,YAAY;AACZ;CACC,YAAY;AACb;;AAEA,kCAAkC;AAClC;CACC,2BAA2B;AAC5B;;AAEA,oCAAoC;AACpC;CACC,2BAA2B;AAC5B;;AAEA;;;;;CAKC,YAAY;AACb;;AAEA;CACC,qBAAqB;CACrB,kCAAkC;AACnC;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,kBAAkB;CAClB,QAAQ;CACR,SAAS;AACV;;AAEA,2BAA2B;AAC3B;CACC,kBAAkB;CAClB,QAAQ;CACR,UAAU;AACX","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Find widget */\n.monaco-editor .find-widget {\n\tposition: absolute;\n\tz-index: 35;\n\theight: 33px;\n\toverflow: hidden;\n\tline-height: 19px;\n\ttransition: transform 200ms linear;\n\tpadding: 0 4px;\n\tbox-sizing: border-box;\n\ttransform: translateY(calc(-100% - 10px)); /* shadow (10px) */\n\tborder-bottom-left-radius: 4px;\n\tborder-bottom-right-radius: 4px;\n}\n\n.monaco-workbench.reduce-motion .monaco-editor .find-widget {\n\ttransition: transform 0ms linear;\n}\n\n.monaco-editor .find-widget textarea {\n\tmargin: 0px;\n}\n\n.monaco-editor .find-widget.hiddenEditor {\n\tdisplay: none;\n}\n\n/* Find widget when replace is toggled on */\n.monaco-editor .find-widget.replaceToggled > .replace-part {\n\tdisplay: flex;\n}\n\n.monaco-editor .find-widget.visible {\n\ttransform: translateY(0);\n}\n\n.monaco-editor .find-widget .monaco-inputbox.synthetic-focus {\n\toutline: 1px solid -webkit-focus-ring-color;\n\toutline-offset: -1px;\n}\n\n.monaco-editor .find-widget .monaco-inputbox .input {\n\tbackground-color: transparent;\n\tmin-height: 0;\n}\n\n.monaco-editor .find-widget .monaco-findInput .input {\n\tfont-size: 13px;\n}\n\n.monaco-editor .find-widget > .find-part,\n.monaco-editor .find-widget > .replace-part {\n\tmargin: 3px 25px 0 17px;\n\tfont-size: 12px;\n\tdisplay: flex;\n}\n\n.monaco-editor .find-widget > .find-part .monaco-inputbox,\n.monaco-editor .find-widget > .replace-part .monaco-inputbox {\n\tmin-height: 25px;\n}\n\n\n.monaco-editor .find-widget > .replace-part .monaco-inputbox > .ibwrapper > .mirror {\n\tpadding-right: 22px;\n}\n\n.monaco-editor .find-widget > .find-part .monaco-inputbox > .ibwrapper > .input,\n.monaco-editor .find-widget > .find-part .monaco-inputbox > .ibwrapper > .mirror,\n.monaco-editor .find-widget > .replace-part .monaco-inputbox > .ibwrapper > .input,\n.monaco-editor .find-widget > .replace-part .monaco-inputbox > .ibwrapper > .mirror {\n\tpadding-top: 2px;\n\tpadding-bottom: 2px;\n}\n\n.monaco-editor .find-widget > .find-part .find-actions {\n\theight: 25px;\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.monaco-editor .find-widget > .replace-part .replace-actions {\n\theight: 25px;\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.monaco-editor .find-widget .monaco-findInput {\n\tvertical-align: middle;\n\tdisplay: flex;\n\tflex:1;\n}\n\n.monaco-editor .find-widget .monaco-findInput .monaco-scrollable-element {\n\t/* Make sure textarea inherits the width correctly */\n\twidth: 100%;\n}\n\n.monaco-editor .find-widget .monaco-findInput .monaco-scrollable-element .scrollbar.vertical {\n\t/* Hide vertical scrollbar */\n\topacity: 0;\n}\n\n.monaco-editor .find-widget .matchesCount {\n\tdisplay: flex;\n\tflex: initial;\n\tmargin: 0 0 0 3px;\n\tpadding: 2px 0 0 2px;\n\theight: 25px;\n\tvertical-align: middle;\n\tbox-sizing: border-box;\n\ttext-align: center;\n\tline-height: 23px;\n}\n\n.monaco-editor .find-widget .button {\n\twidth: 16px;\n\theight: 16px;\n\tpadding: 3px;\n\tborder-radius: 5px;\n\tdisplay: flex;\n\tflex: initial;\n\tmargin-left: 3px;\n\tbackground-position: center center;\n\tbackground-repeat: no-repeat;\n\tcursor: pointer;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n/* find in selection button */\n.monaco-editor .find-widget .codicon-find-selection {\n\twidth: 22px;\n\theight: 22px;\n\tpadding: 3px;\n\tborder-radius: 5px;\n}\n\n.monaco-editor .find-widget .button.left {\n\tmargin-left: 0;\n\tmargin-right: 3px;\n}\n\n.monaco-editor .find-widget .button.wide {\n\twidth: auto;\n\tpadding: 1px 6px;\n\ttop: -1px;\n}\n\n.monaco-editor .find-widget .button.toggle {\n\tposition: absolute;\n\ttop: 0;\n\tleft: 3px;\n\twidth: 18px;\n\theight: 100%;\n\tborder-radius: 0;\n\tbox-sizing: border-box;\n}\n\n.monaco-editor .find-widget .button.toggle.disabled {\n\tdisplay: none;\n}\n\n.monaco-editor .find-widget .disabled {\n\tcolor: var(--vscode-disabledForeground);\n\tcursor: default;\n}\n\n.monaco-editor .find-widget > .replace-part {\n\tdisplay: none;\n}\n\n.monaco-editor .find-widget > .replace-part > .monaco-findInput {\n\tposition: relative;\n\tdisplay: flex;\n\tvertical-align: middle;\n\tflex: auto;\n\tflex-grow: 0;\n\tflex-shrink: 0;\n}\n\n.monaco-editor .find-widget > .replace-part > .monaco-findInput > .controls {\n\tposition: absolute;\n\ttop: 3px;\n\tright: 2px;\n}\n\n/* REDUCED */\n.monaco-editor .find-widget.reduced-find-widget .matchesCount {\n\tdisplay:none;\n}\n\n/* NARROW (SMALLER THAN REDUCED) */\n.monaco-editor .find-widget.narrow-find-widget {\n\tmax-width: 257px !important;\n}\n\n/* COLLAPSED (SMALLER THAN NARROW) */\n.monaco-editor .find-widget.collapsed-find-widget {\n\tmax-width: 170px !important;\n}\n\n.monaco-editor .find-widget.collapsed-find-widget .button.previous,\n.monaco-editor .find-widget.collapsed-find-widget .button.next,\n.monaco-editor .find-widget.collapsed-find-widget .button.replace,\n.monaco-editor .find-widget.collapsed-find-widget .button.replace-all,\n.monaco-editor .find-widget.collapsed-find-widget > .find-part .monaco-findInput .controls {\n\tdisplay:none;\n}\n\n.monaco-editor .findMatch {\n\tanimation-duration: 0;\n\tanimation-name: inherit !important;\n}\n\n.monaco-editor .find-widget .monaco-sash {\n\tleft: 0 !important;\n}\n\n.monaco-editor.hc-black .find-widget .button:before {\n\tposition: relative;\n\ttop: 1px;\n\tleft: 2px;\n}\n\n/* Close button position. */\n.monaco-editor .find-widget > .button.codicon-widget-close {\n\tposition: absolute;\n\ttop: 5px;\n\tright: 4px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/folding.css": +/*!****************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/folding.css ***! + \****************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +.monaco-editor .margin-view-overlays .codicon-folding-manual-collapsed, +.monaco-editor .margin-view-overlays .codicon-folding-manual-expanded, +.monaco-editor .margin-view-overlays .codicon-folding-expanded, +.monaco-editor .margin-view-overlays .codicon-folding-collapsed { + cursor: pointer; + opacity: 0; + transition: opacity 0.5s; + display: flex; + align-items: center; + justify-content: center; + font-size: 140%; + margin-left: 2px; +} + +.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-manual-collapsed, +.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-manual-expanded, +.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-expanded, +.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-collapsed { + transition: initial; +} + +.monaco-editor .margin-view-overlays:hover .codicon, +.monaco-editor .margin-view-overlays .codicon.codicon-folding-collapsed, +.monaco-editor .margin-view-overlays .codicon.codicon-folding-manual-collapsed, +.monaco-editor .margin-view-overlays .codicon.alwaysShowFoldIcons { + opacity: 1; +} + +.monaco-editor .inline-folded:after { + color: grey; + margin: 0.1em 0.2em 0 0.2em; + content: "\\22EF"; /* ellipses unicode character */ + display: inline; + line-height: 1em; + cursor: pointer; +} + +.monaco-editor .folded-background { + background-color: var(--vscode-editor-foldBackground); +} + +.monaco-editor .cldr.codicon.codicon-folding-expanded, +.monaco-editor .cldr.codicon.codicon-folding-collapsed, +.monaco-editor .cldr.codicon.codicon-folding-manual-expanded, +.monaco-editor .cldr.codicon.codicon-folding-manual-collapsed { + color: var(--vscode-editorGutter-foldingControlForeground) !important; +} + +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/folding.css"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;;;CAIC,eAAe;CACf,UAAU;CACV,wBAAwB;CACxB,aAAa;CACb,mBAAmB;CACnB,uBAAuB;CACvB,eAAe;CACf,gBAAgB;AACjB;;AAEA;;;;CAIC,mBAAmB;AACpB;;AAEA;;;;CAIC,UAAU;AACX;;AAEA;CACC,WAAW;CACX,2BAA2B;CAC3B,gBAAgB,EAAE,+BAA+B;CACjD,eAAe;CACf,gBAAgB;CAChB,eAAe;AAChB;;AAEA;CACC,qDAAqD;AACtD;;AAEA;;;;CAIC,qEAAqE;AACtE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .margin-view-overlays .codicon-folding-manual-collapsed,\n.monaco-editor .margin-view-overlays .codicon-folding-manual-expanded,\n.monaco-editor .margin-view-overlays .codicon-folding-expanded,\n.monaco-editor .margin-view-overlays .codicon-folding-collapsed {\n\tcursor: pointer;\n\topacity: 0;\n\ttransition: opacity 0.5s;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n\tfont-size: 140%;\n\tmargin-left: 2px;\n}\n\n.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-manual-collapsed,\n.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-manual-expanded,\n.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-expanded,\n.monaco-workbench.reduce-motion .monaco-editor .margin-view-overlays .codicon-folding-collapsed {\n\ttransition: initial;\n}\n\n.monaco-editor .margin-view-overlays:hover .codicon,\n.monaco-editor .margin-view-overlays .codicon.codicon-folding-collapsed,\n.monaco-editor .margin-view-overlays .codicon.codicon-folding-manual-collapsed,\n.monaco-editor .margin-view-overlays .codicon.alwaysShowFoldIcons {\n\topacity: 1;\n}\n\n.monaco-editor .inline-folded:after {\n\tcolor: grey;\n\tmargin: 0.1em 0.2em 0 0.2em;\n\tcontent: \"\\22EF\"; /* ellipses unicode character */\n\tdisplay: inline;\n\tline-height: 1em;\n\tcursor: pointer;\n}\n\n.monaco-editor .folded-background {\n\tbackground-color: var(--vscode-editor-foldBackground);\n}\n\n.monaco-editor .cldr.codicon.codicon-folding-expanded,\n.monaco-editor .cldr.codicon.codicon-folding-collapsed,\n.monaco-editor .cldr.codicon.codicon-folding-manual-expanded,\n.monaco-editor .cldr.codicon.codicon-folding-manual-collapsed {\n\tcolor: var(--vscode-editorGutter-foldingControlForeground) !important;\n}\n\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/gotoError/browser/media/gotoErrorWidget.css": +/*!********************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/gotoError/browser/media/gotoErrorWidget.css ***! + \********************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* marker zone */ + +.monaco-editor .peekview-widget .head .peekview-title .severity-icon { + display: inline-block; + vertical-align: text-top; + margin-right: 4px; +} + +.monaco-editor .marker-widget { + text-overflow: ellipsis; + white-space: nowrap; +} + +.monaco-editor .marker-widget > .stale { + opacity: 0.6; + font-style: italic; +} + +.monaco-editor .marker-widget .title { + display: inline-block; + padding-right: 5px; +} + +.monaco-editor .marker-widget .descriptioncontainer { + position: absolute; + white-space: pre; + user-select: text; + -webkit-user-select: text; + padding: 8px 12px 0 20px; +} + +.monaco-editor .marker-widget .descriptioncontainer .message { + display: flex; + flex-direction: column; +} + +.monaco-editor .marker-widget .descriptioncontainer .message .details { + padding-left: 6px; +} + +.monaco-editor .marker-widget .descriptioncontainer .message .source, +.monaco-editor .marker-widget .descriptioncontainer .message span.code { + opacity: 0.6; +} + +.monaco-editor .marker-widget .descriptioncontainer .message a.code-link { + opacity: 0.6; + color: inherit; +} + +.monaco-editor .marker-widget .descriptioncontainer .message a.code-link:before { + content: '('; +} + +.monaco-editor .marker-widget .descriptioncontainer .message a.code-link:after { + content: ')'; +} + +.monaco-editor .marker-widget .descriptioncontainer .message a.code-link > span { + text-decoration: underline; + /** Hack to force underline to show **/ + border-bottom: 1px solid transparent; + text-underline-position: under; + color: var(--vscode-textLink-foreground); +} + +.monaco-editor .marker-widget .descriptioncontainer .message a.code-link > span { + color: var(--vscode-textLink-activeForeground); +} + +.monaco-editor .marker-widget .descriptioncontainer .filename { + cursor: pointer; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/gotoError/browser/media/gotoErrorWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,gBAAgB;;AAEhB;CACC,qBAAqB;CACrB,wBAAwB;CACxB,iBAAiB;AAClB;;AAEA;CACC,uBAAuB;CACvB,mBAAmB;AACpB;;AAEA;CACC,YAAY;CACZ,kBAAkB;AACnB;;AAEA;CACC,qBAAqB;CACrB,kBAAkB;AACnB;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;CAChB,iBAAiB;CACjB,yBAAyB;CACzB,wBAAwB;AACzB;;AAEA;CACC,aAAa;CACb,sBAAsB;AACvB;;AAEA;CACC,iBAAiB;AAClB;;AAEA;;CAEC,YAAY;AACb;;AAEA;CACC,YAAY;CACZ,cAAc;AACf;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,0BAA0B;CAC1B,sCAAsC;CACtC,oCAAoC;CACpC,8BAA8B;CAC9B,wCAAwC;AACzC;;AAEA;CACC,8CAA8C;AAC/C;;AAEA;CACC,eAAe;AAChB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* marker zone */\n\n.monaco-editor .peekview-widget .head .peekview-title .severity-icon {\n\tdisplay: inline-block;\n\tvertical-align: text-top;\n\tmargin-right: 4px;\n}\n\n.monaco-editor .marker-widget {\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n}\n\n.monaco-editor .marker-widget > .stale {\n\topacity: 0.6;\n\tfont-style: italic;\n}\n\n.monaco-editor .marker-widget .title {\n\tdisplay: inline-block;\n\tpadding-right: 5px;\n}\n\n.monaco-editor .marker-widget .descriptioncontainer {\n\tposition: absolute;\n\twhite-space: pre;\n\tuser-select: text;\n\t-webkit-user-select: text;\n\tpadding: 8px 12px 0 20px;\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message {\n\tdisplay: flex;\n\tflex-direction: column;\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message .details {\n\tpadding-left: 6px;\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message .source,\n.monaco-editor .marker-widget .descriptioncontainer .message span.code {\n\topacity: 0.6;\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message a.code-link {\n\topacity: 0.6;\n\tcolor: inherit;\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message a.code-link:before {\n\tcontent: '(';\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message a.code-link:after {\n\tcontent: ')';\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message a.code-link > span {\n\ttext-decoration: underline;\n\t/** Hack to force underline to show **/\n\tborder-bottom: 1px solid transparent;\n\ttext-underline-position: under;\n\tcolor: var(--vscode-textLink-foreground);\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .message a.code-link > span {\n\tcolor: var(--vscode-textLink-activeForeground);\n}\n\n.monaco-editor .marker-widget .descriptioncontainer .filename {\n\tcursor: pointer;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.css": +/*!*****************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.css ***! + \*****************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .goto-definition-link { + text-decoration: underline; + cursor: pointer; + color: var(--vscode-editorLink-activeForeground) !important; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,0BAA0B;CAC1B,eAAe;CACf,2DAA2D;AAC5D","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .goto-definition-link {\n\ttext-decoration: underline;\n\tcursor: pointer;\n\tcolor: var(--vscode-editorLink-activeForeground) !important;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/peek/referencesWidget.css": +/*!*********************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/peek/referencesWidget.css ***! + \*********************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* -- zone widget */ +.monaco-editor .zone-widget .zone-widget-container.reference-zone-widget { + border-top-width: 1px; + border-bottom-width: 1px; +} + +.monaco-editor .reference-zone-widget .inline { + display: inline-block; + vertical-align: top; +} + +.monaco-editor .reference-zone-widget .messages { + height: 100%; + width: 100%; + text-align: center; + padding: 3em 0; +} + +.monaco-editor .reference-zone-widget .ref-tree { + line-height: 23px; + background-color: var(--vscode-peekViewResult-background); + color: var(--vscode-peekViewResult-lineForeground); +} + +.monaco-editor .reference-zone-widget .ref-tree .reference { + text-overflow: ellipsis; + overflow: hidden; +} + +.monaco-editor .reference-zone-widget .ref-tree .reference-file { + display: inline-flex; + width: 100%; + height: 100%; + color: var(--vscode-peekViewResult-fileForeground); +} + +.monaco-editor .reference-zone-widget .ref-tree .monaco-list:focus .selected .reference-file { + color: inherit !important; +} + +.monaco-editor .reference-zone-widget .ref-tree .monaco-list:focus .monaco-list-rows > .monaco-list-row.selected:not(.highlighted) { + background-color: var(--vscode-peekViewResult-selectionBackground); + color: var(--vscode-peekViewResult-selectionForeground) !important; +} + +.monaco-editor .reference-zone-widget .ref-tree .reference-file .count { + margin-right: 12px; + margin-left: auto; +} + +.monaco-editor .reference-zone-widget .ref-tree .referenceMatch .highlight { + background-color: var(--vscode-peekViewResult-matchHighlightBackground); +} + +.monaco-editor .reference-zone-widget .preview .reference-decoration { + background-color: var(--vscode-peekViewEditor-matchHighlightBackground); + border: 2px solid var(--vscode-peekViewEditor-matchHighlightBorder); + box-sizing: border-box; +} + +.monaco-editor .reference-zone-widget .preview .monaco-editor .monaco-editor-background, +.monaco-editor .reference-zone-widget .preview .monaco-editor .inputarea.ime-input { + background-color: var(--vscode-peekViewEditor-background); +} + +.monaco-editor .reference-zone-widget .preview .monaco-editor .margin { + background-color: var(--vscode-peekViewEditorGutter-background); +} + +/* High Contrast Theming */ + +.monaco-editor.hc-black .reference-zone-widget .ref-tree .reference-file, +.monaco-editor.hc-light .reference-zone-widget .ref-tree .reference-file { + font-weight: bold; +} + +.monaco-editor.hc-black .reference-zone-widget .ref-tree .referenceMatch .highlight, +.monaco-editor.hc-light .reference-zone-widget .ref-tree .referenceMatch .highlight { + border: 1px dotted var(--vscode-contrastActiveBorder, transparent); + box-sizing: border-box; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/peek/referencesWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,mBAAmB;AACnB;CACC,qBAAqB;CACrB,wBAAwB;AACzB;;AAEA;CACC,qBAAqB;CACrB,mBAAmB;AACpB;;AAEA;CACC,YAAY;CACZ,WAAW;CACX,kBAAkB;CAClB,cAAc;AACf;;AAEA;CACC,iBAAiB;CACjB,yDAAyD;CACzD,kDAAkD;AACnD;;AAEA;CACC,uBAAuB;CACvB,gBAAgB;AACjB;;AAEA;CACC,oBAAoB;CACpB,WAAW;CACX,YAAY;CACZ,kDAAkD;AACnD;;AAEA;CACC,yBAAyB;AAC1B;;AAEA;CACC,kEAAkE;CAClE,kEAAkE;AACnE;;AAEA;CACC,kBAAkB;CAClB,iBAAiB;AAClB;;AAEA;CACC,uEAAuE;AACxE;;AAEA;CACC,uEAAuE;CACvE,mEAAmE;CACnE,sBAAsB;AACvB;;AAEA;;CAEC,yDAAyD;AAC1D;;AAEA;CACC,+DAA+D;AAChE;;AAEA,0BAA0B;;AAE1B;;CAEC,iBAAiB;AAClB;;AAEA;;CAEC,kEAAkE;CAClE,sBAAsB;AACvB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* -- zone widget */\n.monaco-editor .zone-widget .zone-widget-container.reference-zone-widget {\n\tborder-top-width: 1px;\n\tborder-bottom-width: 1px;\n}\n\n.monaco-editor .reference-zone-widget .inline {\n\tdisplay: inline-block;\n\tvertical-align: top;\n}\n\n.monaco-editor .reference-zone-widget .messages {\n\theight: 100%;\n\twidth: 100%;\n\ttext-align: center;\n\tpadding: 3em 0;\n}\n\n.monaco-editor .reference-zone-widget .ref-tree {\n\tline-height: 23px;\n\tbackground-color: var(--vscode-peekViewResult-background);\n\tcolor: var(--vscode-peekViewResult-lineForeground);\n}\n\n.monaco-editor .reference-zone-widget .ref-tree .reference {\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n}\n\n.monaco-editor .reference-zone-widget .ref-tree .reference-file {\n\tdisplay: inline-flex;\n\twidth: 100%;\n\theight: 100%;\n\tcolor: var(--vscode-peekViewResult-fileForeground);\n}\n\n.monaco-editor .reference-zone-widget .ref-tree .monaco-list:focus .selected .reference-file {\n\tcolor: inherit !important;\n}\n\n.monaco-editor .reference-zone-widget .ref-tree .monaco-list:focus .monaco-list-rows > .monaco-list-row.selected:not(.highlighted) {\n\tbackground-color: var(--vscode-peekViewResult-selectionBackground);\n\tcolor: var(--vscode-peekViewResult-selectionForeground) !important;\n}\n\n.monaco-editor .reference-zone-widget .ref-tree .reference-file .count {\n\tmargin-right: 12px;\n\tmargin-left: auto;\n}\n\n.monaco-editor .reference-zone-widget .ref-tree .referenceMatch .highlight {\n\tbackground-color: var(--vscode-peekViewResult-matchHighlightBackground);\n}\n\n.monaco-editor .reference-zone-widget .preview .reference-decoration {\n\tbackground-color: var(--vscode-peekViewEditor-matchHighlightBackground);\n\tborder: 2px solid var(--vscode-peekViewEditor-matchHighlightBorder);\n\tbox-sizing: border-box;\n}\n\n.monaco-editor .reference-zone-widget .preview .monaco-editor .monaco-editor-background,\n.monaco-editor .reference-zone-widget .preview .monaco-editor .inputarea.ime-input {\n\tbackground-color: var(--vscode-peekViewEditor-background);\n}\n\n.monaco-editor .reference-zone-widget .preview .monaco-editor .margin {\n\tbackground-color: var(--vscode-peekViewEditorGutter-background);\n}\n\n/* High Contrast Theming */\n\n.monaco-editor.hc-black .reference-zone-widget .ref-tree .reference-file,\n.monaco-editor.hc-light .reference-zone-widget .ref-tree .reference-file {\n\tfont-weight: bold;\n}\n\n.monaco-editor.hc-black .reference-zone-widget .ref-tree .referenceMatch .highlight,\n.monaco-editor.hc-light .reference-zone-widget .ref-tree .referenceMatch .highlight {\n\tborder: 1px dotted var(--vscode-contrastActiveBorder, transparent);\n\tbox-sizing: border-box;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/hover/browser/hover.css": +/*!************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/hover/browser/hover.css ***! + \************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .hoverHighlight { + background-color: var(--vscode-editor-hoverHighlightBackground); +} + +.monaco-editor .monaco-hover { + color: var(--vscode-editorHoverWidget-foreground); + background-color: var(--vscode-editorHoverWidget-background); + border: 1px solid var(--vscode-editorHoverWidget-border); + border-radius: 3px; +} + +.monaco-editor .monaco-hover a { + color: var(--vscode-textLink-foreground); +} + +.monaco-editor .monaco-hover a:hover { + color: var(--vscode-textLink-activeForeground); +} + +.monaco-editor .monaco-hover .hover-row .actions { + background-color: var(--vscode-editorHoverWidget-statusBarBackground); +} + +.monaco-editor .monaco-hover code { + background-color: var(--vscode-textCodeBlock-background); +} + + +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/hover/browser/hover.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,+DAA+D;AAChE;;AAEA;CACC,iDAAiD;CACjD,4DAA4D;CAC5D,wDAAwD;CACxD,kBAAkB;AACnB;;AAEA;CACC,wCAAwC;AACzC;;AAEA;CACC,8CAA8C;AAC/C;;AAEA;CACC,qEAAqE;AACtE;;AAEA;CACC,wDAAwD;AACzD","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .hoverHighlight {\n\tbackground-color: var(--vscode-editor-hoverHighlightBackground);\n}\n\n.monaco-editor .monaco-hover {\n\tcolor: var(--vscode-editorHoverWidget-foreground);\n\tbackground-color: var(--vscode-editorHoverWidget-background);\n\tborder: 1px solid var(--vscode-editorHoverWidget-border);\n\tborder-radius: 3px;\n}\n\n.monaco-editor .monaco-hover a {\n\tcolor: var(--vscode-textLink-foreground);\n}\n\n.monaco-editor .monaco-hover a:hover {\n\tcolor: var(--vscode-textLink-activeForeground);\n}\n\n.monaco-editor .monaco-hover .hover-row .actions {\n\tbackground-color: var(--vscode-editorHoverWidget-statusBarBackground);\n}\n\n.monaco-editor .monaco-hover code {\n\tbackground-color: var(--vscode-textCodeBlock-background);\n}\n\n\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.css": +/*!******************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.css ***! + \******************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +.monaco-editor.vs .valueSetReplacement { + outline: solid 2px var(--vscode-editorBracketMatch-border); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;;AAG/F;CACC,0DAA0D;AAC3D","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\n.monaco-editor.vs .valueSetReplacement {\n\toutline: solid 2px var(--vscode-editorBracketMatch-border);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/ghostText.css": +/*!****************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/ghostText.css ***! + \****************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .suggest-preview-additional-widget { + white-space: nowrap; +} + +.monaco-editor .suggest-preview-additional-widget .content-spacer { + color: transparent; + white-space: pre; +} + +.monaco-editor .suggest-preview-additional-widget .button { + display: inline-block; + cursor: pointer; + text-decoration: underline; + text-underline-position: under; +} + +.monaco-editor .ghost-text-hidden { + opacity: 0; + font-size: 0; +} + +.monaco-editor .ghost-text-decoration, .monaco-editor .suggest-preview-text .ghost-text { + font-style: italic; +} + +.monaco-editor .inline-completion-text-to-replace { + text-decoration: underline; + text-underline-position: under; +} + +.monaco-editor .ghost-text-decoration, +.monaco-editor .ghost-text-decoration-preview, +.monaco-editor .suggest-preview-text .ghost-text { + color: var(--vscode-editorGhostText-foreground) !important; + background-color: var(--vscode-editorGhostText-background); + border: 1px solid var(--vscode-editorGhostText-border); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/ghostText.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,mBAAmB;AACpB;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;AACjB;;AAEA;CACC,qBAAqB;CACrB,eAAe;CACf,0BAA0B;CAC1B,8BAA8B;AAC/B;;AAEA;CACC,UAAU;CACV,YAAY;AACb;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,0BAA0B;CAC1B,8BAA8B;AAC/B;;AAEA;;;CAGC,0DAA0D;CAC1D,0DAA0D;CAC1D,sDAAsD;AACvD","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .suggest-preview-additional-widget {\n\twhite-space: nowrap;\n}\n\n.monaco-editor .suggest-preview-additional-widget .content-spacer {\n\tcolor: transparent;\n\twhite-space: pre;\n}\n\n.monaco-editor .suggest-preview-additional-widget .button {\n\tdisplay: inline-block;\n\tcursor: pointer;\n\ttext-decoration: underline;\n\ttext-underline-position: under;\n}\n\n.monaco-editor .ghost-text-hidden {\n\topacity: 0;\n\tfont-size: 0;\n}\n\n.monaco-editor .ghost-text-decoration, .monaco-editor .suggest-preview-text .ghost-text {\n\tfont-style: italic;\n}\n\n.monaco-editor .inline-completion-text-to-replace {\n\ttext-decoration: underline;\n\ttext-underline-position: under;\n}\n\n.monaco-editor .ghost-text-decoration,\n.monaco-editor .ghost-text-decoration-preview,\n.monaco-editor .suggest-preview-text .ghost-text {\n\tcolor: var(--vscode-editorGhostText-foreground) !important;\n\tbackground-color: var(--vscode-editorGhostText-background);\n\tborder: 1px solid var(--vscode-editorGhostText-border);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsHintsWidget.css": +/*!***********************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsHintsWidget.css ***! + \***********************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .inlineSuggestionsHints.withBorder { + z-index: 39; + color: var(--vscode-editorHoverWidget-foreground); + background-color: var(--vscode-editorHoverWidget-background); + border: 1px solid var(--vscode-editorHoverWidget-border); +} + +.monaco-editor .inlineSuggestionsHints a { + color: var(--vscode-foreground); +} + +.monaco-editor .inlineSuggestionsHints a:hover { + color: var(--vscode-foreground); +} + +.monaco-editor .inlineSuggestionsHints .keybinding { + display: flex; + margin-left: 4px; + opacity: 0.6; +} + +.monaco-editor .inlineSuggestionsHints .keybinding .monaco-keybinding-key { + font-size: 8px; + padding: 2px 3px; +} + +.monaco-editor .inlineSuggestionsHints .availableSuggestionCount a { + display: flex; + min-width: 19px; + justify-content: center; +} + +.monaco-editor .inlineSuggestionStatusBarItemLabel { + margin-right: 2px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsHintsWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,WAAW;CACX,iDAAiD;CACjD,4DAA4D;CAC5D,wDAAwD;AACzD;;AAEA;CACC,+BAA+B;AAChC;;AAEA;CACC,+BAA+B;AAChC;;AAEA;CACC,aAAa;CACb,gBAAgB;CAChB,YAAY;AACb;;AAEA;CACC,cAAc;CACd,gBAAgB;AACjB;;AAEA;CACC,aAAa;CACb,eAAe;CACf,uBAAuB;AACxB;;AAEA;CACC,iBAAiB;AAClB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .inlineSuggestionsHints.withBorder {\n\tz-index: 39;\n\tcolor: var(--vscode-editorHoverWidget-foreground);\n\tbackground-color: var(--vscode-editorHoverWidget-background);\n\tborder: 1px solid var(--vscode-editorHoverWidget-border);\n}\n\n.monaco-editor .inlineSuggestionsHints a {\n\tcolor: var(--vscode-foreground);\n}\n\n.monaco-editor .inlineSuggestionsHints a:hover {\n\tcolor: var(--vscode-foreground);\n}\n\n.monaco-editor .inlineSuggestionsHints .keybinding {\n\tdisplay: flex;\n\tmargin-left: 4px;\n\topacity: 0.6;\n}\n\n.monaco-editor .inlineSuggestionsHints .keybinding .monaco-keybinding-key {\n\tfont-size: 8px;\n\tpadding: 2px 3px;\n}\n\n.monaco-editor .inlineSuggestionsHints .availableSuggestionCount a {\n\tdisplay: flex;\n\tmin-width: 19px;\n\tjustify-content: center;\n}\n\n.monaco-editor .inlineSuggestionStatusBarItemLabel {\n\tmargin-right: 2px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inlineProgress/browser/inlineProgressWidget.css": +/*!************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/inlineProgress/browser/inlineProgressWidget.css ***! + \************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.inline-editor-progress-decoration { + display: inline-block; + width: 1em; + height: 1em; +} + +.inline-progress-widget { + display: flex !important; + justify-content: center; + align-items: center; +} + +.inline-progress-widget .icon { + font-size: 80% !important; +} + +.inline-progress-widget:hover .icon { + font-size: 90% !important; + animation: none; +} + +.inline-progress-widget:hover .icon::before { + content: "\\ea76"; /* codicon-x */ +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/inlineProgress/browser/inlineProgressWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,qBAAqB;CACrB,UAAU;CACV,WAAW;AACZ;;AAEA;CACC,wBAAwB;CACxB,uBAAuB;CACvB,mBAAmB;AACpB;;AAEA;CACC,yBAAyB;AAC1B;;AAEA;CACC,yBAAyB;CACzB,eAAe;AAChB;;AAEA;CACC,gBAAgB,EAAE,cAAc;AACjC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.inline-editor-progress-decoration {\n\tdisplay: inline-block;\n\twidth: 1em;\n\theight: 1em;\n}\n\n.inline-progress-widget {\n\tdisplay: flex !important;\n\tjustify-content: center;\n\talign-items: center;\n}\n\n.inline-progress-widget .icon {\n\tfont-size: 80% !important;\n}\n\n.inline-progress-widget:hover .icon {\n\tfont-size: 90% !important;\n\tanimation: none;\n}\n\n.inline-progress-widget:hover .icon::before {\n\tcontent: \"\\ea76\"; /* codicon-x */\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/linkedEditing/browser/linkedEditing.css": +/*!****************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/linkedEditing/browser/linkedEditing.css ***! + \****************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .linked-editing-decoration { + background-color: var(--vscode-editor-linkedEditingBackground); + + /* Ensure decoration is visible even if range is empty */ + min-width: 1px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/linkedEditing/browser/linkedEditing.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,8DAA8D;;CAE9D,wDAAwD;CACxD,cAAc;AACf","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .linked-editing-decoration {\n\tbackground-color: var(--vscode-editor-linkedEditingBackground);\n\n\t/* Ensure decoration is visible even if range is empty */\n\tmin-width: 1px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/links/browser/links.css": +/*!************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/links/browser/links.css ***! + \************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +.monaco-editor .detected-link, +.monaco-editor .detected-link-active { + text-decoration: underline; + text-underline-position: under; +} + +.monaco-editor .detected-link-active { + cursor: pointer; + color: var(--vscode-editorLink-activeForeground) !important; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/links/browser/links.css"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;CAEC,0BAA0B;CAC1B,8BAA8B;AAC/B;;AAEA;CACC,eAAe;CACf,2DAA2D;AAC5D","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .detected-link,\n.monaco-editor .detected-link-active {\n\ttext-decoration: underline;\n\ttext-underline-position: under;\n}\n\n.monaco-editor .detected-link-active {\n\tcursor: pointer;\n\tcolor: var(--vscode-editorLink-activeForeground) !important;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/renderedMarkdown.css": +/*!**********************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/renderedMarkdown.css ***! + \**********************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .rendered-markdown kbd { + background-color: var(--vscode-keybindingLabel-background); + color: var(--vscode-keybindingLabel-foreground); + border-style: solid; + border-width: 1px; + border-radius: 3px; + border-color: var(--vscode-keybindingLabel-border); + border-bottom-color: var(--vscode-keybindingLabel-bottomBorder); + box-shadow: inset 0 -1px 0 var(--vscode-widget-shadow); + vertical-align: middle; + padding: 1px 3px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/renderedMarkdown.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,0DAA0D;CAC1D,+CAA+C;CAC/C,mBAAmB;CACnB,iBAAiB;CACjB,kBAAkB;CAClB,kDAAkD;CAClD,+DAA+D;CAC/D,sDAAsD;CACtD,sBAAsB;CACtB,gBAAgB;AACjB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .rendered-markdown kbd {\n\tbackground-color: var(--vscode-keybindingLabel-background);\n\tcolor: var(--vscode-keybindingLabel-foreground);\n\tborder-style: solid;\n\tborder-width: 1px;\n\tborder-radius: 3px;\n\tborder-color: var(--vscode-keybindingLabel-border);\n\tborder-bottom-color: var(--vscode-keybindingLabel-bottomBorder);\n\tbox-shadow: inset 0 -1px 0 var(--vscode-widget-shadow);\n\tvertical-align: middle;\n\tpadding: 1px 3px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/message/browser/messageController.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/message/browser/messageController.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .monaco-editor-overlaymessage { + padding-bottom: 8px; + z-index: 10000; +} + +.monaco-editor .monaco-editor-overlaymessage.below { + padding-bottom: 0; + padding-top: 8px; + z-index: 10000; +} + +@keyframes fadeIn { + from { opacity: 0; } + to { opacity: 1; } +} +.monaco-editor .monaco-editor-overlaymessage.fadeIn { + animation: fadeIn 150ms ease-out; +} + +@keyframes fadeOut { + from { opacity: 1; } + to { opacity: 0; } +} +.monaco-editor .monaco-editor-overlaymessage.fadeOut { + animation: fadeOut 100ms ease-out; +} + +.monaco-editor .monaco-editor-overlaymessage .message { + padding: 2px 4px; + color: var(--vscode-editorHoverWidget-foreground); + background-color: var(--vscode-editorHoverWidget-background); + border: 1px solid var(--vscode-inputValidation-infoBorder); + border-radius: 3px; +} + +.monaco-editor .monaco-editor-overlaymessage .message p { + margin-block: 0px; +} + +.monaco-editor .monaco-editor-overlaymessage .message a { + color: var(--vscode-textLink-foreground); +} + +.monaco-editor .monaco-editor-overlaymessage .message a:hover { + color: var(--vscode-textLink-activeForeground); +} + +.monaco-editor.hc-black .monaco-editor-overlaymessage .message, +.monaco-editor.hc-light .monaco-editor-overlaymessage .message { + border-width: 2px; +} + +.monaco-editor .monaco-editor-overlaymessage .anchor { + width: 0 !important; + height: 0 !important; + border-color: transparent; + border-style: solid; + z-index: 1000; + border-width: 8px; + position: absolute; + left: 2px; +} + +.monaco-editor .monaco-editor-overlaymessage .anchor.top { + border-bottom-color: var(--vscode-inputValidation-infoBorder); +} + +.monaco-editor .monaco-editor-overlaymessage .anchor.below { + border-top-color: var(--vscode-inputValidation-infoBorder); +} + +.monaco-editor .monaco-editor-overlaymessage:not(.below) .anchor.top, +.monaco-editor .monaco-editor-overlaymessage.below .anchor.below { + display: none; +} + +.monaco-editor .monaco-editor-overlaymessage.below .anchor.top { + display: inherit; + top: -8px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/message/browser/messageController.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,mBAAmB;CACnB,cAAc;AACf;;AAEA;CACC,iBAAiB;CACjB,gBAAgB;CAChB,cAAc;AACf;;AAEA;CACC,OAAO,UAAU,EAAE;CACnB,KAAK,UAAU,EAAE;AAClB;AACA;CACC,gCAAgC;AACjC;;AAEA;CACC,OAAO,UAAU,EAAE;CACnB,KAAK,UAAU,EAAE;AAClB;AACA;CACC,iCAAiC;AAClC;;AAEA;CACC,gBAAgB;CAChB,iDAAiD;CACjD,4DAA4D;CAC5D,0DAA0D;CAC1D,kBAAkB;AACnB;;AAEA;CACC,iBAAiB;AAClB;;AAEA;CACC,wCAAwC;AACzC;;AAEA;CACC,8CAA8C;AAC/C;;AAEA;;CAEC,iBAAiB;AAClB;;AAEA;CACC,mBAAmB;CACnB,oBAAoB;CACpB,yBAAyB;CACzB,mBAAmB;CACnB,aAAa;CACb,iBAAiB;CACjB,kBAAkB;CAClB,SAAS;AACV;;AAEA;CACC,6DAA6D;AAC9D;;AAEA;CACC,0DAA0D;AAC3D;;AAEA;;CAEC,aAAa;AACd;;AAEA;CACC,gBAAgB;CAChB,SAAS;AACV","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .monaco-editor-overlaymessage {\n\tpadding-bottom: 8px;\n\tz-index: 10000;\n}\n\n.monaco-editor .monaco-editor-overlaymessage.below {\n\tpadding-bottom: 0;\n\tpadding-top: 8px;\n\tz-index: 10000;\n}\n\n@keyframes fadeIn {\n\tfrom { opacity: 0; }\n\tto { opacity: 1; }\n}\n.monaco-editor .monaco-editor-overlaymessage.fadeIn {\n\tanimation: fadeIn 150ms ease-out;\n}\n\n@keyframes fadeOut {\n\tfrom { opacity: 1; }\n\tto { opacity: 0; }\n}\n.monaco-editor .monaco-editor-overlaymessage.fadeOut {\n\tanimation: fadeOut 100ms ease-out;\n}\n\n.monaco-editor .monaco-editor-overlaymessage .message {\n\tpadding: 2px 4px;\n\tcolor: var(--vscode-editorHoverWidget-foreground);\n\tbackground-color: var(--vscode-editorHoverWidget-background);\n\tborder: 1px solid var(--vscode-inputValidation-infoBorder);\n\tborder-radius: 3px;\n}\n\n.monaco-editor .monaco-editor-overlaymessage .message p {\n\tmargin-block: 0px;\n}\n\n.monaco-editor .monaco-editor-overlaymessage .message a {\n\tcolor: var(--vscode-textLink-foreground);\n}\n\n.monaco-editor .monaco-editor-overlaymessage .message a:hover {\n\tcolor: var(--vscode-textLink-activeForeground);\n}\n\n.monaco-editor.hc-black .monaco-editor-overlaymessage .message,\n.monaco-editor.hc-light .monaco-editor-overlaymessage .message {\n\tborder-width: 2px;\n}\n\n.monaco-editor .monaco-editor-overlaymessage .anchor {\n\twidth: 0 !important;\n\theight: 0 !important;\n\tborder-color: transparent;\n\tborder-style: solid;\n\tz-index: 1000;\n\tborder-width: 8px;\n\tposition: absolute;\n\tleft: 2px;\n}\n\n.monaco-editor .monaco-editor-overlaymessage .anchor.top {\n\tborder-bottom-color: var(--vscode-inputValidation-infoBorder);\n}\n\n.monaco-editor .monaco-editor-overlaymessage .anchor.below {\n\tborder-top-color: var(--vscode-inputValidation-infoBorder);\n}\n\n.monaco-editor .monaco-editor-overlaymessage:not(.below) .anchor.top,\n.monaco-editor .monaco-editor-overlaymessage.below .anchor.below {\n\tdisplay: none;\n}\n\n.monaco-editor .monaco-editor-overlaymessage.below .anchor.top {\n\tdisplay: inherit;\n\ttop: -8px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/parameterHints/browser/parameterHints.css": +/*!******************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/parameterHints/browser/parameterHints.css ***! + \******************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .parameter-hints-widget { + /* Must be higher than the sash's z-index and terminal canvases but lower than the suggest widget */ + z-index: 39; + display: flex; + flex-direction: column; + line-height: 1.5em; + cursor: default; + color: var(--vscode-editorHoverWidget-foreground); + background-color: var(--vscode-editorHoverWidget-background); + border: 1px solid var(--vscode-editorHoverWidget-border); +} + +.hc-black .monaco-editor .parameter-hints-widget, +.hc-light .monaco-editor .parameter-hints-widget { + border-width: 2px; +} + +.monaco-editor .parameter-hints-widget > .phwrapper { + max-width: 440px; + display: flex; + flex-direction: row; +} + +.monaco-editor .parameter-hints-widget.multiple { + min-height: 3.3em; + padding: 0; +} + +.monaco-editor .parameter-hints-widget.multiple .body::before { + content: ""; + display: block; + height: 100%; + position: absolute; + opacity: 0.5; + border-left: 1px solid var(--vscode-editorHoverWidget-border); +} + +.monaco-editor .parameter-hints-widget p, +.monaco-editor .parameter-hints-widget ul { + margin: 8px 0; +} + +.monaco-editor .parameter-hints-widget .monaco-scrollable-element, +.monaco-editor .parameter-hints-widget .body { + display: flex; + flex: 1; + flex-direction: column; + min-height: 100%; +} + +.monaco-editor .parameter-hints-widget .signature { + padding: 4px 5px; + position: relative; +} + +.monaco-editor .parameter-hints-widget .signature.has-docs::after { + content: ""; + display: block; + position: absolute; + left: 0; + width: 100%; + padding-top: 4px; + opacity: 0.5; + border-bottom: 1px solid var(--vscode-editorHoverWidget-border); +} + +.monaco-editor .parameter-hints-widget .docs { + padding: 0 10px 0 5px; + white-space: pre-wrap; +} + +.monaco-editor .parameter-hints-widget .docs.empty { + display: none; +} + +.monaco-editor .parameter-hints-widget .docs a { + color: var(--vscode-textLink-foreground); +} + +.monaco-editor .parameter-hints-widget .docs a:hover { + color: var(--vscode-textLink-activeForeground); + cursor: pointer; +} + +.monaco-editor .parameter-hints-widget .docs .markdown-docs { + white-space: initial; +} + +.monaco-editor .parameter-hints-widget .docs code { + font-family: var(--monaco-monospace-font); + border-radius: 3px; + padding: 0 0.4em; + background-color: var(--vscode-textCodeBlock-background); +} + +.monaco-editor .parameter-hints-widget .docs .monaco-tokenized-source, +.monaco-editor .parameter-hints-widget .docs .code { + white-space: pre-wrap; +} + +.monaco-editor .parameter-hints-widget .controls { + display: none; + flex-direction: column; + align-items: center; + min-width: 22px; + justify-content: flex-end; +} + +.monaco-editor .parameter-hints-widget.multiple .controls { + display: flex; + padding: 0 2px; +} + +.monaco-editor .parameter-hints-widget.multiple .button { + width: 16px; + height: 16px; + background-repeat: no-repeat; + cursor: pointer; +} + +.monaco-editor .parameter-hints-widget .button.previous { + bottom: 24px; +} + +.monaco-editor .parameter-hints-widget .overloads { + text-align: center; + height: 12px; + line-height: 12px; + font-family: var(--monaco-monospace-font); +} + +.monaco-editor .parameter-hints-widget .signature .parameter.active { + color: var(--vscode-editorHoverWidget-highlightForeground); + font-weight: bold; +} + +.monaco-editor .parameter-hints-widget .documentation-parameter > .parameter { + font-weight: bold; + margin-right: 0.5em; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/parameterHints/browser/parameterHints.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,mGAAmG;CACnG,WAAW;CACX,aAAa;CACb,sBAAsB;CACtB,kBAAkB;CAClB,eAAe;CACf,iDAAiD;CACjD,4DAA4D;CAC5D,wDAAwD;AACzD;;AAEA;;CAEC,iBAAiB;AAClB;;AAEA;CACC,gBAAgB;CAChB,aAAa;CACb,mBAAmB;AACpB;;AAEA;CACC,iBAAiB;CACjB,UAAU;AACX;;AAEA;CACC,WAAW;CACX,cAAc;CACd,YAAY;CACZ,kBAAkB;CAClB,YAAY;CACZ,6DAA6D;AAC9D;;AAEA;;CAEC,aAAa;AACd;;AAEA;;CAEC,aAAa;CACb,OAAO;CACP,sBAAsB;CACtB,gBAAgB;AACjB;;AAEA;CACC,gBAAgB;CAChB,kBAAkB;AACnB;;AAEA;CACC,WAAW;CACX,cAAc;CACd,kBAAkB;CAClB,OAAO;CACP,WAAW;CACX,gBAAgB;CAChB,YAAY;CACZ,+DAA+D;AAChE;;AAEA;CACC,qBAAqB;CACrB,qBAAqB;AACtB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,wCAAwC;AACzC;;AAEA;CACC,8CAA8C;CAC9C,eAAe;AAChB;;AAEA;CACC,oBAAoB;AACrB;;AAEA;CACC,yCAAyC;CACzC,kBAAkB;CAClB,gBAAgB;CAChB,wDAAwD;AACzD;;AAEA;;CAEC,qBAAqB;AACtB;;AAEA;CACC,aAAa;CACb,sBAAsB;CACtB,mBAAmB;CACnB,eAAe;CACf,yBAAyB;AAC1B;;AAEA;CACC,aAAa;CACb,cAAc;AACf;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,4BAA4B;CAC5B,eAAe;AAChB;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,kBAAkB;CAClB,YAAY;CACZ,iBAAiB;CACjB,yCAAyC;AAC1C;;AAEA;CACC,0DAA0D;CAC1D,iBAAiB;AAClB;;AAEA;CACC,iBAAiB;CACjB,mBAAmB;AACpB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .parameter-hints-widget {\n\t/* Must be higher than the sash's z-index and terminal canvases but lower than the suggest widget */\n\tz-index: 39;\n\tdisplay: flex;\n\tflex-direction: column;\n\tline-height: 1.5em;\n\tcursor: default;\n\tcolor: var(--vscode-editorHoverWidget-foreground);\n\tbackground-color: var(--vscode-editorHoverWidget-background);\n\tborder: 1px solid var(--vscode-editorHoverWidget-border);\n}\n\n.hc-black .monaco-editor .parameter-hints-widget,\n.hc-light .monaco-editor .parameter-hints-widget {\n\tborder-width: 2px;\n}\n\n.monaco-editor .parameter-hints-widget > .phwrapper {\n\tmax-width: 440px;\n\tdisplay: flex;\n\tflex-direction: row;\n}\n\n.monaco-editor .parameter-hints-widget.multiple {\n\tmin-height: 3.3em;\n\tpadding: 0;\n}\n\n.monaco-editor .parameter-hints-widget.multiple .body::before {\n\tcontent: \"\";\n\tdisplay: block;\n\theight: 100%;\n\tposition: absolute;\n\topacity: 0.5;\n\tborder-left: 1px solid var(--vscode-editorHoverWidget-border);\n}\n\n.monaco-editor .parameter-hints-widget p,\n.monaco-editor .parameter-hints-widget ul {\n\tmargin: 8px 0;\n}\n\n.monaco-editor .parameter-hints-widget .monaco-scrollable-element,\n.monaco-editor .parameter-hints-widget .body {\n\tdisplay: flex;\n\tflex: 1;\n\tflex-direction: column;\n\tmin-height: 100%;\n}\n\n.monaco-editor .parameter-hints-widget .signature {\n\tpadding: 4px 5px;\n\tposition: relative;\n}\n\n.monaco-editor .parameter-hints-widget .signature.has-docs::after {\n\tcontent: \"\";\n\tdisplay: block;\n\tposition: absolute;\n\tleft: 0;\n\twidth: 100%;\n\tpadding-top: 4px;\n\topacity: 0.5;\n\tborder-bottom: 1px solid var(--vscode-editorHoverWidget-border);\n}\n\n.monaco-editor .parameter-hints-widget .docs {\n\tpadding: 0 10px 0 5px;\n\twhite-space: pre-wrap;\n}\n\n.monaco-editor .parameter-hints-widget .docs.empty {\n\tdisplay: none;\n}\n\n.monaco-editor .parameter-hints-widget .docs a {\n\tcolor: var(--vscode-textLink-foreground);\n}\n\n.monaco-editor .parameter-hints-widget .docs a:hover {\n\tcolor: var(--vscode-textLink-activeForeground);\n\tcursor: pointer;\n}\n\n.monaco-editor .parameter-hints-widget .docs .markdown-docs {\n\twhite-space: initial;\n}\n\n.monaco-editor .parameter-hints-widget .docs code {\n\tfont-family: var(--monaco-monospace-font);\n\tborder-radius: 3px;\n\tpadding: 0 0.4em;\n\tbackground-color: var(--vscode-textCodeBlock-background);\n}\n\n.monaco-editor .parameter-hints-widget .docs .monaco-tokenized-source,\n.monaco-editor .parameter-hints-widget .docs .code {\n\twhite-space: pre-wrap;\n}\n\n.monaco-editor .parameter-hints-widget .controls {\n\tdisplay: none;\n\tflex-direction: column;\n\talign-items: center;\n\tmin-width: 22px;\n\tjustify-content: flex-end;\n}\n\n.monaco-editor .parameter-hints-widget.multiple .controls {\n\tdisplay: flex;\n\tpadding: 0 2px;\n}\n\n.monaco-editor .parameter-hints-widget.multiple .button {\n\twidth: 16px;\n\theight: 16px;\n\tbackground-repeat: no-repeat;\n\tcursor: pointer;\n}\n\n.monaco-editor .parameter-hints-widget .button.previous {\n\tbottom: 24px;\n}\n\n.monaco-editor .parameter-hints-widget .overloads {\n\ttext-align: center;\n\theight: 12px;\n\tline-height: 12px;\n\tfont-family: var(--monaco-monospace-font);\n}\n\n.monaco-editor .parameter-hints-widget .signature .parameter.active {\n\tcolor: var(--vscode-editorHoverWidget-highlightForeground);\n\tfont-weight: bold;\n}\n\n.monaco-editor .parameter-hints-widget .documentation-parameter > .parameter {\n\tfont-weight: bold;\n\tmargin-right: 0.5em;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/peekView/browser/media/peekViewWidget.css": +/*!******************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/peekView/browser/media/peekViewWidget.css ***! + \******************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .peekview-widget .head { + box-sizing: border-box; + display: flex; + justify-content: space-between; + flex-wrap: nowrap; +} + +.monaco-editor .peekview-widget .head .peekview-title { + display: flex; + align-items: baseline; + font-size: 13px; + margin-left: 20px; + min-width: 0; + text-overflow: ellipsis; + overflow: hidden; +} + +.monaco-editor .peekview-widget .head .peekview-title.clickable { + cursor: pointer; +} + +.monaco-editor .peekview-widget .head .peekview-title .dirname:not(:empty) { + font-size: 0.9em; + margin-left: 0.5em; +} + +.monaco-editor .peekview-widget .head .peekview-title .meta { + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.monaco-editor .peekview-widget .head .peekview-title .dirname { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.monaco-editor .peekview-widget .head .peekview-title .filename { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.monaco-editor .peekview-widget .head .peekview-title .meta:not(:empty)::before { + content: '-'; + padding: 0 0.3em; +} + +.monaco-editor .peekview-widget .head .peekview-actions { + flex: 1; + text-align: right; + padding-right: 2px; +} + +.monaco-editor .peekview-widget .head .peekview-actions > .monaco-action-bar { + display: inline-block; +} + +.monaco-editor .peekview-widget .head .peekview-actions > .monaco-action-bar, +.monaco-editor .peekview-widget .head .peekview-actions > .monaco-action-bar > .actions-container { + height: 100%; +} + +.monaco-editor .peekview-widget > .body { + border-top: 1px solid; + position: relative; +} + +.monaco-editor .peekview-widget .head .peekview-title .codicon { + margin-right: 4px; + align-self: center; +} + +.monaco-editor .peekview-widget .monaco-list .monaco-list-row.focused .codicon { + color: inherit !important; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/peekView/browser/media/peekViewWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,sBAAsB;CACtB,aAAa;CACb,8BAA8B;CAC9B,iBAAiB;AAClB;;AAEA;CACC,aAAa;CACb,qBAAqB;CACrB,eAAe;CACf,iBAAiB;CACjB,YAAY;CACZ,uBAAuB;CACvB,gBAAgB;AACjB;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,gBAAgB;CAChB,kBAAkB;AACnB;;AAEA;CACC,mBAAmB;CACnB,gBAAgB;CAChB,uBAAuB;AACxB;;AAEA;CACC,gBAAgB;CAChB,uBAAuB;CACvB,mBAAmB;AACpB;;AAEA;CACC,gBAAgB;CAChB,uBAAuB;CACvB,mBAAmB;AACpB;;AAEA;CACC,YAAY;CACZ,gBAAgB;AACjB;;AAEA;CACC,OAAO;CACP,iBAAiB;CACjB,kBAAkB;AACnB;;AAEA;CACC,qBAAqB;AACtB;;AAEA;;CAEC,YAAY;AACb;;AAEA;CACC,qBAAqB;CACrB,kBAAkB;AACnB;;AAEA;CACC,iBAAiB;CACjB,kBAAkB;AACnB;;AAEA;CACC,yBAAyB;AAC1B","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .peekview-widget .head {\n\tbox-sizing: border-box;\n\tdisplay: flex;\n\tjustify-content: space-between;\n\tflex-wrap: nowrap;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title {\n\tdisplay: flex;\n\talign-items: baseline;\n\tfont-size: 13px;\n\tmargin-left: 20px;\n\tmin-width: 0;\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title.clickable {\n\tcursor: pointer;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title .dirname:not(:empty) {\n\tfont-size: 0.9em;\n\tmargin-left: 0.5em;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title .meta {\n\twhite-space: nowrap;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title .dirname {\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title .filename {\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title .meta:not(:empty)::before {\n\tcontent: '-';\n\tpadding: 0 0.3em;\n}\n\n.monaco-editor .peekview-widget .head .peekview-actions {\n\tflex: 1;\n\ttext-align: right;\n\tpadding-right: 2px;\n}\n\n.monaco-editor .peekview-widget .head .peekview-actions > .monaco-action-bar {\n\tdisplay: inline-block;\n}\n\n.monaco-editor .peekview-widget .head .peekview-actions > .monaco-action-bar,\n.monaco-editor .peekview-widget .head .peekview-actions > .monaco-action-bar > .actions-container {\n\theight: 100%;\n}\n\n.monaco-editor .peekview-widget > .body {\n\tborder-top: 1px solid;\n\tposition: relative;\n}\n\n.monaco-editor .peekview-widget .head .peekview-title .codicon {\n\tmargin-right: 4px;\n\talign-self: center;\n}\n\n.monaco-editor .peekview-widget .monaco-list .monaco-list-row.focused .codicon {\n\tcolor: inherit !important;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/rename/browser/renameInputField.css": +/*!************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/rename/browser/renameInputField.css ***! + \************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .rename-box { + z-index: 100; + color: inherit; + border-radius: 4px; +} + +.monaco-editor .rename-box.preview { + padding: 4px 4px 0 4px; +} + +.monaco-editor .rename-box .rename-input { + padding: 3px; + border-radius: 2px; +} + +.monaco-editor .rename-box .rename-label { + display: none; + opacity: .8; +} + +.monaco-editor .rename-box.preview .rename-label { + display: inherit; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/rename/browser/renameInputField.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,YAAY;CACZ,cAAc;CACd,kBAAkB;AACnB;;AAEA;CACC,sBAAsB;AACvB;;AAEA;CACC,YAAY;CACZ,kBAAkB;AACnB;;AAEA;CACC,aAAa;CACb,WAAW;AACZ;;AAEA;CACC,gBAAgB;AACjB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .rename-box {\n\tz-index: 100;\n\tcolor: inherit;\n\tborder-radius: 4px;\n}\n\n.monaco-editor .rename-box.preview {\n\tpadding: 4px 4px 0 4px;\n}\n\n.monaco-editor .rename-box .rename-input {\n\tpadding: 3px;\n\tborder-radius: 2px;\n}\n\n.monaco-editor .rename-box .rename-label {\n\tdisplay: none;\n\topacity: .8;\n}\n\n.monaco-editor .rename-box.preview .rename-label {\n\tdisplay: inherit;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetSession.css": +/*!***********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetSession.css ***! + \***********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .snippet-placeholder { + min-width: 2px; + outline-style: solid; + outline-width: 1px; + background-color: var(--vscode-editor-snippetTabstopHighlightBackground, transparent); + outline-color: var(--vscode-editor-snippetTabstopHighlightBorder, transparent); +} + +.monaco-editor .finish-snippet-placeholder { + outline-style: solid; + outline-width: 1px; + background-color: var(--vscode-editor-snippetFinalTabstopHighlightBackground, transparent); + outline-color: var(--vscode-editor-snippetFinalTabstopHighlightBorder, transparent); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetSession.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,cAAc;CACd,oBAAoB;CACpB,kBAAkB;CAClB,qFAAqF;CACrF,8EAA8E;AAC/E;;AAEA;CACC,oBAAoB;CACpB,kBAAkB;CAClB,0FAA0F;CAC1F,mFAAmF;AACpF","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .snippet-placeholder {\n\tmin-width: 2px;\n\toutline-style: solid;\n\toutline-width: 1px;\n\tbackground-color: var(--vscode-editor-snippetTabstopHighlightBackground, transparent);\n\toutline-color: var(--vscode-editor-snippetTabstopHighlightBorder, transparent);\n}\n\n.monaco-editor .finish-snippet-placeholder {\n\toutline-style: solid;\n\toutline-width: 1px;\n\tbackground-color: var(--vscode-editor-snippetFinalTabstopHighlightBackground, transparent);\n\toutline-color: var(--vscode-editor-snippetFinalTabstopHighlightBorder, transparent);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/stickyScroll/browser/stickyScroll.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/stickyScroll/browser/stickyScroll.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .sticky-widget { + overflow: hidden; +} + +.monaco-editor .sticky-widget-line-numbers { + float: left; + background-color: inherit; +} + +.monaco-editor .sticky-widget-lines-scrollable { + display: inline-block; + position: absolute; + overflow: hidden; + width: var(--vscode-editorStickyScroll-scrollableWidth); + background-color: inherit; +} + +.monaco-editor .sticky-widget-lines { + position: absolute; + background-color: inherit; +} + +.monaco-editor .sticky-line-number, .monaco-editor .sticky-line-content { + color: var(--vscode-editorLineNumber-foreground); + white-space: nowrap; + display: inline-block; + position: absolute; + background-color: inherit; +} + +.monaco-editor .sticky-line-number .codicon-folding-expanded, +.monaco-editor .sticky-line-number .codicon-folding-collapsed { + float: right; + transition: var(--vscode-editorStickyScroll-foldingOpacityTransition); +} + +.monaco-editor .sticky-line-content { + width: var(--vscode-editorStickyScroll-scrollableWidth); + background-color: inherit; + white-space: nowrap; +} + +.monaco-editor .sticky-line-number-inner { + display: inline-block; + text-align: right; +} + +.monaco-editor.hc-black .sticky-widget, +.monaco-editor.hc-light .sticky-widget { + border-bottom: 1px solid var(--vscode-contrastBorder); +} + +.monaco-editor .sticky-line-content:hover { + background-color: var(--vscode-editorStickyScrollHover-background); + cursor: pointer; +} + +.monaco-editor .sticky-widget { + width: 100%; + box-shadow: var(--vscode-scrollbar-shadow) 0 3px 2px -2px; + z-index: 4; + background-color: var(--vscode-editorStickyScroll-background); +} + +.monaco-editor .sticky-widget.peek { + background-color: var(--vscode-peekViewEditorStickyScroll-background); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/stickyScroll/browser/stickyScroll.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,gBAAgB;AACjB;;AAEA;CACC,WAAW;CACX,yBAAyB;AAC1B;;AAEA;CACC,qBAAqB;CACrB,kBAAkB;CAClB,gBAAgB;CAChB,uDAAuD;CACvD,yBAAyB;AAC1B;;AAEA;CACC,kBAAkB;CAClB,yBAAyB;AAC1B;;AAEA;CACC,gDAAgD;CAChD,mBAAmB;CACnB,qBAAqB;CACrB,kBAAkB;CAClB,yBAAyB;AAC1B;;AAEA;;CAEC,YAAY;CACZ,qEAAqE;AACtE;;AAEA;CACC,uDAAuD;CACvD,yBAAyB;CACzB,mBAAmB;AACpB;;AAEA;CACC,qBAAqB;CACrB,iBAAiB;AAClB;;AAEA;;CAEC,qDAAqD;AACtD;;AAEA;CACC,kEAAkE;CAClE,eAAe;AAChB;;AAEA;CACC,WAAW;CACX,yDAAyD;CACzD,UAAU;CACV,6DAA6D;AAC9D;;AAEA;CACC,qEAAqE;AACtE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .sticky-widget {\n\toverflow: hidden;\n}\n\n.monaco-editor .sticky-widget-line-numbers {\n\tfloat: left;\n\tbackground-color: inherit;\n}\n\n.monaco-editor .sticky-widget-lines-scrollable {\n\tdisplay: inline-block;\n\tposition: absolute;\n\toverflow: hidden;\n\twidth: var(--vscode-editorStickyScroll-scrollableWidth);\n\tbackground-color: inherit;\n}\n\n.monaco-editor .sticky-widget-lines {\n\tposition: absolute;\n\tbackground-color: inherit;\n}\n\n.monaco-editor .sticky-line-number, .monaco-editor .sticky-line-content {\n\tcolor: var(--vscode-editorLineNumber-foreground);\n\twhite-space: nowrap;\n\tdisplay: inline-block;\n\tposition: absolute;\n\tbackground-color: inherit;\n}\n\n.monaco-editor .sticky-line-number .codicon-folding-expanded,\n.monaco-editor .sticky-line-number .codicon-folding-collapsed {\n\tfloat: right;\n\ttransition: var(--vscode-editorStickyScroll-foldingOpacityTransition);\n}\n\n.monaco-editor .sticky-line-content {\n\twidth: var(--vscode-editorStickyScroll-scrollableWidth);\n\tbackground-color: inherit;\n\twhite-space: nowrap;\n}\n\n.monaco-editor .sticky-line-number-inner {\n\tdisplay: inline-block;\n\ttext-align: right;\n}\n\n.monaco-editor.hc-black .sticky-widget,\n.monaco-editor.hc-light .sticky-widget {\n\tborder-bottom: 1px solid var(--vscode-contrastBorder);\n}\n\n.monaco-editor .sticky-line-content:hover {\n\tbackground-color: var(--vscode-editorStickyScrollHover-background);\n\tcursor: pointer;\n}\n\n.monaco-editor .sticky-widget {\n\twidth: 100%;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 3px 2px -2px;\n\tz-index: 4;\n\tbackground-color: var(--vscode-editorStickyScroll-background);\n}\n\n.monaco-editor .sticky-widget.peek {\n\tbackground-color: var(--vscode-peekViewEditorStickyScroll-background);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/suggest/browser/media/suggest.css": +/*!**********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/suggest/browser/media/suggest.css ***! + \**********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +/* Suggest widget*/ + +.monaco-editor .suggest-widget { + width: 430px; + z-index: 40; + display: flex; + flex-direction: column; + border-radius: 3px; +} + +.monaco-editor .suggest-widget.message { + flex-direction: row; + align-items: center; +} + +.monaco-editor .suggest-widget, +.monaco-editor .suggest-details { + flex: 0 1 auto; + width: 100%; + border-style: solid; + border-width: 1px; + border-color: var(--vscode-editorSuggestWidget-border); + background-color: var(--vscode-editorSuggestWidget-background); +} + +.monaco-editor.hc-black .suggest-widget, +.monaco-editor.hc-black .suggest-details, +.monaco-editor.hc-light .suggest-widget, +.monaco-editor.hc-light .suggest-details { + border-width: 2px; +} + +/* Styles for status bar part */ + + +.monaco-editor .suggest-widget .suggest-status-bar { + box-sizing: border-box; + display: none; + flex-flow: row nowrap; + justify-content: space-between; + width: 100%; + font-size: 80%; + padding: 0 4px 0 4px; + border-top: 1px solid var(--vscode-editorSuggestWidget-border); + overflow: hidden; +} + +.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar { + display: flex; +} + +.monaco-editor .suggest-widget .suggest-status-bar .left { + padding-right: 8px; +} + +.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar .action-label { + color: var(--vscode-editorSuggestWidgetStatus-foreground); +} + +.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label { + margin-right: 0; +} + +.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label::after { + content: ', '; + margin-right: 0.3em; +} + +.monaco-editor .suggest-widget.with-status-bar .monaco-list .monaco-list-row>.contents>.main>.right>.readMore, +.monaco-editor .suggest-widget.with-status-bar .monaco-list .monaco-list-row.focused.string-label>.contents>.main>.right>.readMore { + display: none; +} + +.monaco-editor .suggest-widget.with-status-bar:not(.docs-side) .monaco-list .monaco-list-row:hover>.contents>.main>.right.can-expand-details>.details-label { + width: 100%; +} + +/* Styles for Message element for when widget is loading or is empty */ + +.monaco-editor .suggest-widget>.message { + padding-left: 22px; +} + +/** Styles for the list element **/ + +.monaco-editor .suggest-widget>.tree { + height: 100%; + width: 100%; +} + +.monaco-editor .suggest-widget .monaco-list { + user-select: none; + -webkit-user-select: none; +} + +/** Styles for each row in the list element **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row { + display: flex; + -mox-box-sizing: border-box; + box-sizing: border-box; + padding-right: 10px; + background-repeat: no-repeat; + background-position: 2px 2px; + white-space: nowrap; + cursor: pointer; + touch-action: none; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused { + color: var(--vscode-editorSuggestWidget-selectedForeground); +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused .codicon { + color: var(--vscode-editorSuggestWidget-selectedIconForeground); +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents { + flex: 1; + height: 100%; + overflow: hidden; + padding-left: 2px; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main { + display: flex; + overflow: hidden; + text-overflow: ellipsis; + white-space: pre; + justify-content: space-between; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left, +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right { + display: flex; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row:not(.focused)>.contents>.main .monaco-icon-label { + color: var(--vscode-editorSuggestWidget-foreground); +} + +.monaco-editor .suggest-widget:not(.frozen) .monaco-highlighted-label .highlight { + font-weight: bold; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main .monaco-highlighted-label .highlight { + color: var(--vscode-editorSuggestWidget-highlightForeground); +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused>.contents>.main .monaco-highlighted-label .highlight { + color: var(--vscode-editorSuggestWidget-focusHighlightForeground); +} + +/** ReadMore Icon styles **/ + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.codicon-close, +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore::before { + color: inherit; + opacity: 1; + font-size: 14px; + cursor: pointer; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.codicon-close { + position: absolute; + top: 6px; + right: 2px; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.codicon-close:hover, +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore:hover { + opacity: 1; +} + +/** signature, qualifier, type/details opacity **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label { + opacity: 0.7; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.signature-label { + overflow: hidden; + text-overflow: ellipsis; + opacity: 0.6; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.qualifier-label { + margin-left: 12px; + opacity: 0.4; + font-size: 85%; + line-height: initial; + text-overflow: ellipsis; + overflow: hidden; + align-self: center; +} + +/** Type Info and icon next to the label in the focused completion item **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label { + font-size: 85%; + margin-left: 1.1em; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label>.monaco-tokenized-source { + display: inline; +} + +/** Details: if using CompletionItem#details, show on focus **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label { + display: none; +} + +.monaco-editor .suggest-widget:not(.shows-details) .monaco-list .monaco-list-row.focused>.contents>.main>.right>.details-label { + display: inline; +} + +/** Details: if using CompletionItemLabel#details, always show **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.right>.details-label, +.monaco-editor .suggest-widget.docs-side .monaco-list .monaco-list-row.focused:not(.string-label)>.contents>.main>.right>.details-label { + display: inline; +} + +/** Ellipsis on hover **/ + +.monaco-editor .suggest-widget:not(.docs-side) .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right.can-expand-details>.details-label { + width: calc(100% - 26px); +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left { + flex-shrink: 1; + flex-grow: 1; + overflow: hidden; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.monaco-icon-label { + flex-shrink: 0; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.left>.monaco-icon-label { + max-width: 100%; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row.string-label>.contents>.main>.left>.monaco-icon-label { + flex-shrink: 1; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right { + overflow: hidden; + flex-shrink: 4; + max-width: 70%; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore { + display: inline-block; + position: absolute; + right: 10px; + width: 18px; + height: 18px; + visibility: hidden; +} + +/** Do NOT display ReadMore when docs is side/below **/ + +.monaco-editor .suggest-widget.docs-side .monaco-list .monaco-list-row>.contents>.main>.right>.readMore { + display: none !important; +} + +/** Do NOT display ReadMore when using plain CompletionItemLabel (details/documentation might not be resolved) **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row.string-label>.contents>.main>.right>.readMore { + display: none; +} + +/** Focused item can show ReadMore, but can't when docs is side/below **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused.string-label>.contents>.main>.right>.readMore { + display: inline-block; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right>.readMore { + visibility: visible; +} + +/** Styles for each row in the list **/ + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated { + opacity: 0.66; + text-decoration: unset; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated>.monaco-icon-label-container>.monaco-icon-name-container { + text-decoration: line-through; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row .monaco-icon-label::before { + height: 100%; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row .icon { + display: block; + height: 16px; + width: 16px; + margin-left: 2px; + background-repeat: no-repeat; + background-size: 80%; + background-position: center; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row .icon.hide { + display: none; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row .suggest-icon { + display: flex; + align-items: center; + margin-right: 4px; +} + +.monaco-editor .suggest-widget.no-icons .monaco-list .monaco-list-row .icon, +.monaco-editor .suggest-widget.no-icons .monaco-list .monaco-list-row .suggest-icon::before { + display: none; +} + +.monaco-editor .suggest-widget .monaco-list .monaco-list-row .icon.customcolor .colorspan { + margin: 0 0 0 0.3em; + border: 0.1em solid #000; + width: 0.7em; + height: 0.7em; + display: inline-block; +} + +/** Styles for the docs of the completion item in focus **/ + +.monaco-editor .suggest-details-container { + z-index: 41; +} + +.monaco-editor .suggest-details { + display: flex; + flex-direction: column; + cursor: default; + color: var(--vscode-editorSuggestWidget-foreground); +} + +.monaco-editor .suggest-details.focused { + border-color: var(--vscode-focusBorder); +} + +.monaco-editor .suggest-details a { + color: var(--vscode-textLink-foreground); +} + +.monaco-editor .suggest-details a:hover { + color: var(--vscode-textLink-activeForeground); +} + +.monaco-editor .suggest-details code { + background-color: var(--vscode-textCodeBlock-background); +} + +.monaco-editor .suggest-details.no-docs { + display: none; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element { + flex: 1; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body { + box-sizing: border-box; + height: 100%; + width: 100%; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.type { + flex: 2; + overflow: hidden; + text-overflow: ellipsis; + opacity: 0.7; + white-space: pre; + margin: 0 24px 0 0; + padding: 4px 0 12px 5px; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.type.auto-wrap { + white-space: normal; + word-break: break-all; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs { + margin: 0; + padding: 4px 5px; + white-space: pre-wrap; +} + +.monaco-editor .suggest-details.no-type>.monaco-scrollable-element>.body>.docs { + margin-right: 24px; + overflow: hidden; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs { + padding: 0; + white-space: initial; + min-height: calc(1rem + 8px); +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>div, +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>span:not(:empty) { + padding: 4px 5px; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>div>p:first-child { + margin-top: 0; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>div>p:last-child { + margin-bottom: 0; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs .monaco-tokenized-source { + white-space: pre; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs .code { + white-space: pre-wrap; + word-wrap: break-word; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs .codicon { + vertical-align: sub; +} + +.monaco-editor .suggest-details>.monaco-scrollable-element>.body>p:empty { + display: none; +} + +.monaco-editor .suggest-details code { + border-radius: 3px; + padding: 0 0.4em; +} + +.monaco-editor .suggest-details ul { + padding-left: 20px; +} + +.monaco-editor .suggest-details ol { + padding-left: 20px; +} + +.monaco-editor .suggest-details p code { + font-family: var(--monaco-monospace-font); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/suggest/browser/media/suggest.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F,kBAAkB;;AAElB;CACC,YAAY;CACZ,WAAW;CACX,aAAa;CACb,sBAAsB;CACtB,kBAAkB;AACnB;;AAEA;CACC,mBAAmB;CACnB,mBAAmB;AACpB;;AAEA;;CAEC,cAAc;CACd,WAAW;CACX,mBAAmB;CACnB,iBAAiB;CACjB,sDAAsD;CACtD,8DAA8D;AAC/D;;AAEA;;;;CAIC,iBAAiB;AAClB;;AAEA,+BAA+B;;;AAG/B;CACC,sBAAsB;CACtB,aAAa;CACb,qBAAqB;CACrB,8BAA8B;CAC9B,WAAW;CACX,cAAc;CACd,oBAAoB;CACpB,8DAA8D;CAC9D,gBAAgB;AACjB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,yDAAyD;AAC1D;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,aAAa;CACb,mBAAmB;AACpB;;AAEA;;CAEC,aAAa;AACd;;AAEA;CACC,WAAW;AACZ;;AAEA,sEAAsE;;AAEtE;CACC,kBAAkB;AACnB;;AAEA,kCAAkC;;AAElC;CACC,YAAY;CACZ,WAAW;AACZ;;AAEA;CACC,iBAAiB;CACjB,yBAAyB;AAC1B;;AAEA,8CAA8C;;AAE9C;CACC,aAAa;CACb,2BAA2B;CAC3B,sBAAsB;CACtB,mBAAmB;CACnB,4BAA4B;CAC5B,4BAA4B;CAC5B,mBAAmB;CACnB,eAAe;CACf,kBAAkB;AACnB;;AAEA;CACC,2DAA2D;AAC5D;;AAEA;CACC,+DAA+D;AAChE;;AAEA;CACC,OAAO;CACP,YAAY;CACZ,gBAAgB;CAChB,iBAAiB;AAClB;;AAEA;CACC,aAAa;CACb,gBAAgB;CAChB,uBAAuB;CACvB,gBAAgB;CAChB,8BAA8B;AAC/B;;AAEA;;CAEC,aAAa;AACd;;AAEA;CACC,mDAAmD;AACpD;;AAEA;CACC,iBAAiB;AAClB;;AAEA;CACC,4DAA4D;AAC7D;;AAEA;CACC,iEAAiE;AAClE;;AAEA,2BAA2B;;AAE3B;;CAEC,cAAc;CACd,UAAU;CACV,eAAe;CACf,eAAe;AAChB;;AAEA;CACC,kBAAkB;CAClB,QAAQ;CACR,UAAU;AACX;;AAEA;;CAEC,UAAU;AACX;;AAEA,iDAAiD;;AAEjD;CACC,YAAY;AACb;;AAEA;CACC,gBAAgB;CAChB,uBAAuB;CACvB,YAAY;AACb;;AAEA;CACC,iBAAiB;CACjB,YAAY;CACZ,cAAc;CACd,oBAAoB;CACpB,uBAAuB;CACvB,gBAAgB;CAChB,kBAAkB;AACnB;;AAEA,0EAA0E;;AAE1E;CACC,cAAc;CACd,kBAAkB;CAClB,gBAAgB;CAChB,uBAAuB;CACvB,mBAAmB;AACpB;;AAEA;CACC,eAAe;AAChB;;AAEA,8DAA8D;;AAE9D;CACC,aAAa;AACd;;AAEA;CACC,eAAe;AAChB;;AAEA,iEAAiE;;AAEjE;;CAEC,eAAe;AAChB;;AAEA,wBAAwB;;AAExB;CACC,wBAAwB;AACzB;;AAEA;CACC,cAAc;CACd,YAAY;CACZ,gBAAgB;AACjB;;AAEA;CACC,cAAc;AACf;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,cAAc;AACf;;AAEA;CACC,gBAAgB;CAChB,cAAc;CACd,cAAc;AACf;;AAEA;CACC,qBAAqB;CACrB,kBAAkB;CAClB,WAAW;CACX,WAAW;CACX,YAAY;CACZ,kBAAkB;AACnB;;AAEA,sDAAsD;;AAEtD;CACC,wBAAwB;AACzB;;AAEA,iHAAiH;;AAEjH;CACC,aAAa;AACd;;AAEA,wEAAwE;;AAExE;CACC,qBAAqB;AACtB;;AAEA;CACC,mBAAmB;AACpB;;AAEA,sCAAsC;;AAEtC;CACC,aAAa;CACb,sBAAsB;AACvB;;AAEA;CACC,6BAA6B;AAC9B;;AAEA;CACC,YAAY;AACb;;AAEA;CACC,cAAc;CACd,YAAY;CACZ,WAAW;CACX,gBAAgB;CAChB,4BAA4B;CAC5B,oBAAoB;CACpB,2BAA2B;AAC5B;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,aAAa;CACb,mBAAmB;CACnB,iBAAiB;AAClB;;AAEA;;CAEC,aAAa;AACd;;AAEA;CACC,mBAAmB;CACnB,wBAAwB;CACxB,YAAY;CACZ,aAAa;CACb,qBAAqB;AACtB;;AAEA,0DAA0D;;AAE1D;CACC,WAAW;AACZ;;AAEA;CACC,aAAa;CACb,sBAAsB;CACtB,eAAe;CACf,mDAAmD;AACpD;;AAEA;CACC,uCAAuC;AACxC;;AAEA;CACC,wCAAwC;AACzC;;AAEA;CACC,8CAA8C;AAC/C;;AAEA;CACC,wDAAwD;AACzD;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,OAAO;AACR;;AAEA;CACC,sBAAsB;CACtB,YAAY;CACZ,WAAW;AACZ;;AAEA;CACC,OAAO;CACP,gBAAgB;CAChB,uBAAuB;CACvB,YAAY;CACZ,gBAAgB;CAChB,kBAAkB;CAClB,uBAAuB;AACxB;;AAEA;CACC,mBAAmB;CACnB,qBAAqB;AACtB;;AAEA;CACC,SAAS;CACT,gBAAgB;CAChB,qBAAqB;AACtB;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;AACjB;;AAEA;CACC,UAAU;CACV,oBAAoB;CACpB,4BAA4B;AAC7B;;AAEA;;CAEC,gBAAgB;AACjB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,qBAAqB;CACrB,qBAAqB;AACtB;;AAEA;CACC,mBAAmB;AACpB;;AAEA;CACC,aAAa;AACd;;AAEA;CACC,kBAAkB;CAClB,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,yCAAyC;AAC1C","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Suggest widget*/\n\n.monaco-editor .suggest-widget {\n\twidth: 430px;\n\tz-index: 40;\n\tdisplay: flex;\n\tflex-direction: column;\n\tborder-radius: 3px;\n}\n\n.monaco-editor .suggest-widget.message {\n\tflex-direction: row;\n\talign-items: center;\n}\n\n.monaco-editor .suggest-widget,\n.monaco-editor .suggest-details {\n\tflex: 0 1 auto;\n\twidth: 100%;\n\tborder-style: solid;\n\tborder-width: 1px;\n\tborder-color: var(--vscode-editorSuggestWidget-border);\n\tbackground-color: var(--vscode-editorSuggestWidget-background);\n}\n\n.monaco-editor.hc-black .suggest-widget,\n.monaco-editor.hc-black .suggest-details,\n.monaco-editor.hc-light .suggest-widget,\n.monaco-editor.hc-light .suggest-details {\n\tborder-width: 2px;\n}\n\n/* Styles for status bar part */\n\n\n.monaco-editor .suggest-widget .suggest-status-bar {\n\tbox-sizing: border-box;\n\tdisplay: none;\n\tflex-flow: row nowrap;\n\tjustify-content: space-between;\n\twidth: 100%;\n\tfont-size: 80%;\n\tpadding: 0 4px 0 4px;\n\tborder-top: 1px solid var(--vscode-editorSuggestWidget-border);\n\toverflow: hidden;\n}\n\n.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar {\n\tdisplay: flex;\n}\n\n.monaco-editor .suggest-widget .suggest-status-bar .left {\n\tpadding-right: 8px;\n}\n\n.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar .action-label {\n\tcolor: var(--vscode-editorSuggestWidgetStatus-foreground);\n}\n\n.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label {\n\tmargin-right: 0;\n}\n\n.monaco-editor .suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label::after {\n\tcontent: ', ';\n\tmargin-right: 0.3em;\n}\n\n.monaco-editor .suggest-widget.with-status-bar .monaco-list .monaco-list-row>.contents>.main>.right>.readMore,\n.monaco-editor .suggest-widget.with-status-bar .monaco-list .monaco-list-row.focused.string-label>.contents>.main>.right>.readMore {\n\tdisplay: none;\n}\n\n.monaco-editor .suggest-widget.with-status-bar:not(.docs-side) .monaco-list .monaco-list-row:hover>.contents>.main>.right.can-expand-details>.details-label {\n\twidth: 100%;\n}\n\n/* Styles for Message element for when widget is loading or is empty */\n\n.monaco-editor .suggest-widget>.message {\n\tpadding-left: 22px;\n}\n\n/** Styles for the list element **/\n\n.monaco-editor .suggest-widget>.tree {\n\theight: 100%;\n\twidth: 100%;\n}\n\n.monaco-editor .suggest-widget .monaco-list {\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n/** Styles for each row in the list element **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row {\n\tdisplay: flex;\n\t-mox-box-sizing: border-box;\n\tbox-sizing: border-box;\n\tpadding-right: 10px;\n\tbackground-repeat: no-repeat;\n\tbackground-position: 2px 2px;\n\twhite-space: nowrap;\n\tcursor: pointer;\n\ttouch-action: none;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused {\n\tcolor: var(--vscode-editorSuggestWidget-selectedForeground);\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused .codicon {\n\tcolor: var(--vscode-editorSuggestWidget-selectedIconForeground);\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents {\n\tflex: 1;\n\theight: 100%;\n\toverflow: hidden;\n\tpadding-left: 2px;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main {\n\tdisplay: flex;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\twhite-space: pre;\n\tjustify-content: space-between;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left,\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right {\n\tdisplay: flex;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row:not(.focused)>.contents>.main .monaco-icon-label {\n\tcolor: var(--vscode-editorSuggestWidget-foreground);\n}\n\n.monaco-editor .suggest-widget:not(.frozen) .monaco-highlighted-label .highlight {\n\tfont-weight: bold;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main .monaco-highlighted-label .highlight {\n\tcolor: var(--vscode-editorSuggestWidget-highlightForeground);\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused>.contents>.main .monaco-highlighted-label .highlight {\n\tcolor: var(--vscode-editorSuggestWidget-focusHighlightForeground);\n}\n\n/** ReadMore Icon styles **/\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.codicon-close,\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore::before {\n\tcolor: inherit;\n\topacity: 1;\n\tfont-size: 14px;\n\tcursor: pointer;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.codicon-close {\n\tposition: absolute;\n\ttop: 6px;\n\tright: 2px;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.codicon-close:hover,\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore:hover {\n\topacity: 1;\n}\n\n/** signature, qualifier, type/details opacity **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label {\n\topacity: 0.7;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.signature-label {\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\topacity: 0.6;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.qualifier-label {\n\tmargin-left: 12px;\n\topacity: 0.4;\n\tfont-size: 85%;\n\tline-height: initial;\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n\talign-self: center;\n}\n\n/** Type Info and icon next to the label in the focused completion item **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label {\n\tfont-size: 85%;\n\tmargin-left: 1.1em;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label>.monaco-tokenized-source {\n\tdisplay: inline;\n}\n\n/** Details: if using CompletionItem#details, show on focus **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label {\n\tdisplay: none;\n}\n\n.monaco-editor .suggest-widget:not(.shows-details) .monaco-list .monaco-list-row.focused>.contents>.main>.right>.details-label {\n\tdisplay: inline;\n}\n\n/** Details: if using CompletionItemLabel#details, always show **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.right>.details-label,\n.monaco-editor .suggest-widget.docs-side .monaco-list .monaco-list-row.focused:not(.string-label)>.contents>.main>.right>.details-label {\n\tdisplay: inline;\n}\n\n/** Ellipsis on hover **/\n\n.monaco-editor .suggest-widget:not(.docs-side) .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right.can-expand-details>.details-label {\n\twidth: calc(100% - 26px);\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left {\n\tflex-shrink: 1;\n\tflex-grow: 1;\n\toverflow: hidden;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.monaco-icon-label {\n\tflex-shrink: 0;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.left>.monaco-icon-label {\n\tmax-width: 100%;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row.string-label>.contents>.main>.left>.monaco-icon-label {\n\tflex-shrink: 1;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right {\n\toverflow: hidden;\n\tflex-shrink: 4;\n\tmax-width: 70%;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore {\n\tdisplay: inline-block;\n\tposition: absolute;\n\tright: 10px;\n\twidth: 18px;\n\theight: 18px;\n\tvisibility: hidden;\n}\n\n/** Do NOT display ReadMore when docs is side/below **/\n\n.monaco-editor .suggest-widget.docs-side .monaco-list .monaco-list-row>.contents>.main>.right>.readMore {\n\tdisplay: none !important;\n}\n\n/** Do NOT display ReadMore when using plain CompletionItemLabel (details/documentation might not be resolved) **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row.string-label>.contents>.main>.right>.readMore {\n\tdisplay: none;\n}\n\n/** Focused item can show ReadMore, but can't when docs is side/below **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused.string-label>.contents>.main>.right>.readMore {\n\tdisplay: inline-block;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right>.readMore {\n\tvisibility: visible;\n}\n\n/** Styles for each row in the list **/\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated {\n\topacity: 0.66;\n\ttext-decoration: unset;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated>.monaco-icon-label-container>.monaco-icon-name-container {\n\ttext-decoration: line-through;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row .monaco-icon-label::before {\n\theight: 100%;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row .icon {\n\tdisplay: block;\n\theight: 16px;\n\twidth: 16px;\n\tmargin-left: 2px;\n\tbackground-repeat: no-repeat;\n\tbackground-size: 80%;\n\tbackground-position: center;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row .icon.hide {\n\tdisplay: none;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row .suggest-icon {\n\tdisplay: flex;\n\talign-items: center;\n\tmargin-right: 4px;\n}\n\n.monaco-editor .suggest-widget.no-icons .monaco-list .monaco-list-row .icon,\n.monaco-editor .suggest-widget.no-icons .monaco-list .monaco-list-row .suggest-icon::before {\n\tdisplay: none;\n}\n\n.monaco-editor .suggest-widget .monaco-list .monaco-list-row .icon.customcolor .colorspan {\n\tmargin: 0 0 0 0.3em;\n\tborder: 0.1em solid #000;\n\twidth: 0.7em;\n\theight: 0.7em;\n\tdisplay: inline-block;\n}\n\n/** Styles for the docs of the completion item in focus **/\n\n.monaco-editor .suggest-details-container {\n\tz-index: 41;\n}\n\n.monaco-editor .suggest-details {\n\tdisplay: flex;\n\tflex-direction: column;\n\tcursor: default;\n\tcolor: var(--vscode-editorSuggestWidget-foreground);\n}\n\n.monaco-editor .suggest-details.focused {\n\tborder-color: var(--vscode-focusBorder);\n}\n\n.monaco-editor .suggest-details a {\n\tcolor: var(--vscode-textLink-foreground);\n}\n\n.monaco-editor .suggest-details a:hover {\n\tcolor: var(--vscode-textLink-activeForeground);\n}\n\n.monaco-editor .suggest-details code {\n\tbackground-color: var(--vscode-textCodeBlock-background);\n}\n\n.monaco-editor .suggest-details.no-docs {\n\tdisplay: none;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element {\n\tflex: 1;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body {\n\tbox-sizing: border-box;\n\theight: 100%;\n\twidth: 100%;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.type {\n\tflex: 2;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\topacity: 0.7;\n\twhite-space: pre;\n\tmargin: 0 24px 0 0;\n\tpadding: 4px 0 12px 5px;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.header>.type.auto-wrap {\n\twhite-space: normal;\n\tword-break: break-all;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs {\n\tmargin: 0;\n\tpadding: 4px 5px;\n\twhite-space: pre-wrap;\n}\n\n.monaco-editor .suggest-details.no-type>.monaco-scrollable-element>.body>.docs {\n\tmargin-right: 24px;\n\toverflow: hidden;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs {\n\tpadding: 0;\n\twhite-space: initial;\n\tmin-height: calc(1rem + 8px);\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>div,\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>span:not(:empty) {\n\tpadding: 4px 5px;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>div>p:first-child {\n\tmargin-top: 0;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs>div>p:last-child {\n\tmargin-bottom: 0;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs .monaco-tokenized-source {\n\twhite-space: pre;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs .code {\n\twhite-space: pre-wrap;\n\tword-wrap: break-word;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>.docs.markdown-docs .codicon {\n\tvertical-align: sub;\n}\n\n.monaco-editor .suggest-details>.monaco-scrollable-element>.body>p:empty {\n\tdisplay: none;\n}\n\n.monaco-editor .suggest-details code {\n\tborder-radius: 3px;\n\tpadding: 0 0.4em;\n}\n\n.monaco-editor .suggest-details ul {\n\tpadding-left: 20px;\n}\n\n.monaco-editor .suggest-details ol {\n\tpadding-left: 20px;\n}\n\n.monaco-editor .suggest-details p code {\n\tfont-family: var(--monaco-monospace-font);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/symbolIcons/browser/symbolIcons.css": +/*!************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/symbolIcons/browser/symbolIcons.css ***! + \************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .codicon.codicon-symbol-array, +.monaco-workbench .codicon.codicon-symbol-array { color: var(--vscode-symbolIcon-arrayForeground); } +.monaco-editor .codicon.codicon-symbol-boolean, +.monaco-workbench .codicon.codicon-symbol-boolean { color: var(--vscode-symbolIcon-booleanForeground); } +.monaco-editor .codicon.codicon-symbol-class, +.monaco-workbench .codicon.codicon-symbol-class { color: var(--vscode-symbolIcon-classForeground); } +.monaco-editor .codicon.codicon-symbol-method, +.monaco-workbench .codicon.codicon-symbol-method { color: var(--vscode-symbolIcon-methodForeground); } +.monaco-editor .codicon.codicon-symbol-color, +.monaco-workbench .codicon.codicon-symbol-color { color: var(--vscode-symbolIcon-colorForeground); } +.monaco-editor .codicon.codicon-symbol-constant, +.monaco-workbench .codicon.codicon-symbol-constant { color: var(--vscode-symbolIcon-constantForeground); } +.monaco-editor .codicon.codicon-symbol-constructor, +.monaco-workbench .codicon.codicon-symbol-constructor { color: var(--vscode-symbolIcon-constructorForeground); } +.monaco-editor .codicon.codicon-symbol-value, +.monaco-workbench .codicon.codicon-symbol-value, +.monaco-editor .codicon.codicon-symbol-enum, +.monaco-workbench .codicon.codicon-symbol-enum { color: var(--vscode-symbolIcon-enumeratorForeground); } +.monaco-editor .codicon.codicon-symbol-enum-member, +.monaco-workbench .codicon.codicon-symbol-enum-member { color: var(--vscode-symbolIcon-enumeratorMemberForeground); } +.monaco-editor .codicon.codicon-symbol-event, +.monaco-workbench .codicon.codicon-symbol-event { color: var(--vscode-symbolIcon-eventForeground); } +.monaco-editor .codicon.codicon-symbol-field, +.monaco-workbench .codicon.codicon-symbol-field { color: var(--vscode-symbolIcon-fieldForeground); } +.monaco-editor .codicon.codicon-symbol-file, +.monaco-workbench .codicon.codicon-symbol-file { color: var(--vscode-symbolIcon-fileForeground); } +.monaco-editor .codicon.codicon-symbol-folder, +.monaco-workbench .codicon.codicon-symbol-folder { color: var(--vscode-symbolIcon-folderForeground); } +.monaco-editor .codicon.codicon-symbol-function, +.monaco-workbench .codicon.codicon-symbol-function { color: var(--vscode-symbolIcon-functionForeground); } +.monaco-editor .codicon.codicon-symbol-interface, +.monaco-workbench .codicon.codicon-symbol-interface { color: var(--vscode-symbolIcon-interfaceForeground); } +.monaco-editor .codicon.codicon-symbol-key, +.monaco-workbench .codicon.codicon-symbol-key { color: var(--vscode-symbolIcon-keyForeground); } +.monaco-editor .codicon.codicon-symbol-keyword, +.monaco-workbench .codicon.codicon-symbol-keyword { color: var(--vscode-symbolIcon-keywordForeground); } +.monaco-editor .codicon.codicon-symbol-module, +.monaco-workbench .codicon.codicon-symbol-module { color: var(--vscode-symbolIcon-moduleForeground); } +.monaco-editor .codicon.codicon-symbol-namespace, +.monaco-workbench .codicon.codicon-symbol-namespace { color: var(--vscode-symbolIcon-namespaceForeground); } +.monaco-editor .codicon.codicon-symbol-null, +.monaco-workbench .codicon.codicon-symbol-null { color: var(--vscode-symbolIcon-nullForeground); } +.monaco-editor .codicon.codicon-symbol-number, +.monaco-workbench .codicon.codicon-symbol-number { color: var(--vscode-symbolIcon-numberForeground); } +.monaco-editor .codicon.codicon-symbol-object, +.monaco-workbench .codicon.codicon-symbol-object { color: var(--vscode-symbolIcon-objectForeground); } +.monaco-editor .codicon.codicon-symbol-operator, +.monaco-workbench .codicon.codicon-symbol-operator { color: var(--vscode-symbolIcon-operatorForeground); } +.monaco-editor .codicon.codicon-symbol-package, +.monaco-workbench .codicon.codicon-symbol-package { color: var(--vscode-symbolIcon-packageForeground); } +.monaco-editor .codicon.codicon-symbol-property, +.monaco-workbench .codicon.codicon-symbol-property { color: var(--vscode-symbolIcon-propertyForeground); } +.monaco-editor .codicon.codicon-symbol-reference, +.monaco-workbench .codicon.codicon-symbol-reference { color: var(--vscode-symbolIcon-referenceForeground); } +.monaco-editor .codicon.codicon-symbol-snippet, +.monaco-workbench .codicon.codicon-symbol-snippet { color: var(--vscode-symbolIcon-snippetForeground); } +.monaco-editor .codicon.codicon-symbol-string, +.monaco-workbench .codicon.codicon-symbol-string { color: var(--vscode-symbolIcon-stringForeground); } +.monaco-editor .codicon.codicon-symbol-struct, +.monaco-workbench .codicon.codicon-symbol-struct { color: var(--vscode-symbolIcon-structForeground); } +.monaco-editor .codicon.codicon-symbol-text, +.monaco-workbench .codicon.codicon-symbol-text { color: var(--vscode-symbolIcon-textForeground); } +.monaco-editor .codicon.codicon-symbol-type-parameter, +.monaco-workbench .codicon.codicon-symbol-type-parameter { color: var(--vscode-symbolIcon-typeParameterForeground); } +.monaco-editor .codicon.codicon-symbol-unit, +.monaco-workbench .codicon.codicon-symbol-unit { color: var(--vscode-symbolIcon-unitForeground); } +.monaco-editor .codicon.codicon-symbol-variable, +.monaco-workbench .codicon.codicon-symbol-variable { color: var(--vscode-symbolIcon-variableForeground); } +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/symbolIcons/browser/symbolIcons.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;kDACkD,+CAA+C,EAAE;AACnG;oDACoD,iDAAiD,EAAE;AACvG;kDACkD,+CAA+C,EAAE;AACnG;mDACmD,gDAAgD,EAAE;AACrG;kDACkD,+CAA+C,EAAE;AACnG;qDACqD,kDAAkD,EAAE;AACzG;wDACwD,qDAAqD,EAAE;AAC/G;;;iDAGiD,oDAAoD,EAAE;AACvG;wDACwD,0DAA0D,EAAE;AACpH;kDACkD,+CAA+C,EAAE;AACnG;kDACkD,+CAA+C,EAAE;AACnG;iDACiD,8CAA8C,EAAE;AACjG;mDACmD,gDAAgD,EAAE;AACrG;qDACqD,kDAAkD,EAAE;AACzG;sDACsD,mDAAmD,EAAE;AAC3G;gDACgD,6CAA6C,EAAE;AAC/F;oDACoD,iDAAiD,EAAE;AACvG;mDACmD,gDAAgD,EAAE;AACrG;sDACsD,mDAAmD,EAAE;AAC3G;iDACiD,8CAA8C,EAAE;AACjG;mDACmD,gDAAgD,EAAE;AACrG;mDACmD,gDAAgD,EAAE;AACrG;qDACqD,kDAAkD,EAAE;AACzG;oDACoD,iDAAiD,EAAE;AACvG;qDACqD,kDAAkD,EAAE;AACzG;sDACsD,mDAAmD,EAAE;AAC3G;oDACoD,iDAAiD,EAAE;AACvG;mDACmD,gDAAgD,EAAE;AACrG;mDACmD,gDAAgD,EAAE;AACrG;iDACiD,8CAA8C,EAAE;AACjG;2DAC2D,uDAAuD,EAAE;AACpH;iDACiD,8CAA8C,EAAE;AACjG;qDACqD,kDAAkD,EAAE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .codicon.codicon-symbol-array,\n.monaco-workbench .codicon.codicon-symbol-array { color: var(--vscode-symbolIcon-arrayForeground); }\n.monaco-editor .codicon.codicon-symbol-boolean,\n.monaco-workbench .codicon.codicon-symbol-boolean { color: var(--vscode-symbolIcon-booleanForeground); }\n.monaco-editor .codicon.codicon-symbol-class,\n.monaco-workbench .codicon.codicon-symbol-class { color: var(--vscode-symbolIcon-classForeground); }\n.monaco-editor .codicon.codicon-symbol-method,\n.monaco-workbench .codicon.codicon-symbol-method { color: var(--vscode-symbolIcon-methodForeground); }\n.monaco-editor .codicon.codicon-symbol-color,\n.monaco-workbench .codicon.codicon-symbol-color { color: var(--vscode-symbolIcon-colorForeground); }\n.monaco-editor .codicon.codicon-symbol-constant,\n.monaco-workbench .codicon.codicon-symbol-constant { color: var(--vscode-symbolIcon-constantForeground); }\n.monaco-editor .codicon.codicon-symbol-constructor,\n.monaco-workbench .codicon.codicon-symbol-constructor { color: var(--vscode-symbolIcon-constructorForeground); }\n.monaco-editor .codicon.codicon-symbol-value,\n.monaco-workbench .codicon.codicon-symbol-value,\n.monaco-editor .codicon.codicon-symbol-enum,\n.monaco-workbench .codicon.codicon-symbol-enum { color: var(--vscode-symbolIcon-enumeratorForeground); }\n.monaco-editor .codicon.codicon-symbol-enum-member,\n.monaco-workbench .codicon.codicon-symbol-enum-member { color: var(--vscode-symbolIcon-enumeratorMemberForeground); }\n.monaco-editor .codicon.codicon-symbol-event,\n.monaco-workbench .codicon.codicon-symbol-event { color: var(--vscode-symbolIcon-eventForeground); }\n.monaco-editor .codicon.codicon-symbol-field,\n.monaco-workbench .codicon.codicon-symbol-field { color: var(--vscode-symbolIcon-fieldForeground); }\n.monaco-editor .codicon.codicon-symbol-file,\n.monaco-workbench .codicon.codicon-symbol-file { color: var(--vscode-symbolIcon-fileForeground); }\n.monaco-editor .codicon.codicon-symbol-folder,\n.monaco-workbench .codicon.codicon-symbol-folder { color: var(--vscode-symbolIcon-folderForeground); }\n.monaco-editor .codicon.codicon-symbol-function,\n.monaco-workbench .codicon.codicon-symbol-function { color: var(--vscode-symbolIcon-functionForeground); }\n.monaco-editor .codicon.codicon-symbol-interface,\n.monaco-workbench .codicon.codicon-symbol-interface { color: var(--vscode-symbolIcon-interfaceForeground); }\n.monaco-editor .codicon.codicon-symbol-key,\n.monaco-workbench .codicon.codicon-symbol-key { color: var(--vscode-symbolIcon-keyForeground); }\n.monaco-editor .codicon.codicon-symbol-keyword,\n.monaco-workbench .codicon.codicon-symbol-keyword { color: var(--vscode-symbolIcon-keywordForeground); }\n.monaco-editor .codicon.codicon-symbol-module,\n.monaco-workbench .codicon.codicon-symbol-module { color: var(--vscode-symbolIcon-moduleForeground); }\n.monaco-editor .codicon.codicon-symbol-namespace,\n.monaco-workbench .codicon.codicon-symbol-namespace { color: var(--vscode-symbolIcon-namespaceForeground); }\n.monaco-editor .codicon.codicon-symbol-null,\n.monaco-workbench .codicon.codicon-symbol-null { color: var(--vscode-symbolIcon-nullForeground); }\n.monaco-editor .codicon.codicon-symbol-number,\n.monaco-workbench .codicon.codicon-symbol-number { color: var(--vscode-symbolIcon-numberForeground); }\n.monaco-editor .codicon.codicon-symbol-object,\n.monaco-workbench .codicon.codicon-symbol-object { color: var(--vscode-symbolIcon-objectForeground); }\n.monaco-editor .codicon.codicon-symbol-operator,\n.monaco-workbench .codicon.codicon-symbol-operator { color: var(--vscode-symbolIcon-operatorForeground); }\n.monaco-editor .codicon.codicon-symbol-package,\n.monaco-workbench .codicon.codicon-symbol-package { color: var(--vscode-symbolIcon-packageForeground); }\n.monaco-editor .codicon.codicon-symbol-property,\n.monaco-workbench .codicon.codicon-symbol-property { color: var(--vscode-symbolIcon-propertyForeground); }\n.monaco-editor .codicon.codicon-symbol-reference,\n.monaco-workbench .codicon.codicon-symbol-reference { color: var(--vscode-symbolIcon-referenceForeground); }\n.monaco-editor .codicon.codicon-symbol-snippet,\n.monaco-workbench .codicon.codicon-symbol-snippet { color: var(--vscode-symbolIcon-snippetForeground); }\n.monaco-editor .codicon.codicon-symbol-string,\n.monaco-workbench .codicon.codicon-symbol-string { color: var(--vscode-symbolIcon-stringForeground); }\n.monaco-editor .codicon.codicon-symbol-struct,\n.monaco-workbench .codicon.codicon-symbol-struct { color: var(--vscode-symbolIcon-structForeground); }\n.monaco-editor .codicon.codicon-symbol-text,\n.monaco-workbench .codicon.codicon-symbol-text { color: var(--vscode-symbolIcon-textForeground); }\n.monaco-editor .codicon.codicon-symbol-type-parameter,\n.monaco-workbench .codicon.codicon-symbol-type-parameter { color: var(--vscode-symbolIcon-typeParameterForeground); }\n.monaco-editor .codicon.codicon-symbol-unit,\n.monaco-workbench .codicon.codicon-symbol-unit { color: var(--vscode-symbolIcon-unitForeground); }\n.monaco-editor .codicon.codicon-symbol-variable,\n.monaco-workbench .codicon.codicon-symbol-variable { color: var(--vscode-symbolIcon-variableForeground); }\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/unicodeHighlighter/browser/bannerController.css": +/*!************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/unicodeHighlighter/browser/bannerController.css ***! + \************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.editor-banner { + box-sizing: border-box; + cursor: default; + width: 100%; + font-size: 12px; + display: flex; + overflow: visible; + + height: 26px; + + background: var(--vscode-banner-background); +} + + +.editor-banner .icon-container { + display: flex; + flex-shrink: 0; + align-items: center; + padding: 0 6px 0 10px; +} + +.editor-banner .icon-container.custom-icon { + background-repeat: no-repeat; + background-position: center center; + background-size: 16px; + width: 16px; + padding: 0; + margin: 0 6px 0 10px; +} + +.editor-banner .message-container { + display: flex; + align-items: center; + line-height: 26px; + text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; +} + +.editor-banner .message-container p { + margin-block-start: 0; + margin-block-end: 0; +} + +.editor-banner .message-actions-container { + flex-grow: 1; + flex-shrink: 0; + line-height: 26px; + margin: 0 4px; +} + +.editor-banner .message-actions-container a.monaco-button { + width: inherit; + margin: 2px 8px; + padding: 0px 12px; +} + +.editor-banner .message-actions-container a { + padding: 3px; + margin-left: 12px; + text-decoration: underline; +} + +.editor-banner .action-container { + padding: 0 10px 0 6px; +} + +.editor-banner { + background-color: var(--vscode-banner-background); +} + +.editor-banner, +.editor-banner .action-container .codicon, +.editor-banner .message-actions-container .monaco-link { + color: var(--vscode-banner-foreground); +} + +.editor-banner .icon-container .codicon { + color: var(--vscode-banner-iconForeground); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/unicodeHighlighter/browser/bannerController.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,sBAAsB;CACtB,eAAe;CACf,WAAW;CACX,eAAe;CACf,aAAa;CACb,iBAAiB;;CAEjB,YAAY;;CAEZ,2CAA2C;AAC5C;;;AAGA;CACC,aAAa;CACb,cAAc;CACd,mBAAmB;CACnB,qBAAqB;AACtB;;AAEA;CACC,4BAA4B;CAC5B,kCAAkC;CAClC,qBAAqB;CACrB,WAAW;CACX,UAAU;CACV,oBAAoB;AACrB;;AAEA;CACC,aAAa;CACb,mBAAmB;CACnB,iBAAiB;CACjB,uBAAuB;CACvB,mBAAmB;CACnB,gBAAgB;AACjB;;AAEA;CACC,qBAAqB;CACrB,mBAAmB;AACpB;;AAEA;CACC,YAAY;CACZ,cAAc;CACd,iBAAiB;CACjB,aAAa;AACd;;AAEA;CACC,cAAc;CACd,eAAe;CACf,iBAAiB;AAClB;;AAEA;CACC,YAAY;CACZ,iBAAiB;CACjB,0BAA0B;AAC3B;;AAEA;CACC,qBAAqB;AACtB;;AAEA;CACC,iDAAiD;AAClD;;AAEA;;;CAGC,sCAAsC;AACvC;;AAEA;CACC,0CAA0C;AAC3C","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.editor-banner {\n\tbox-sizing: border-box;\n\tcursor: default;\n\twidth: 100%;\n\tfont-size: 12px;\n\tdisplay: flex;\n\toverflow: visible;\n\n\theight: 26px;\n\n\tbackground: var(--vscode-banner-background);\n}\n\n\n.editor-banner .icon-container {\n\tdisplay: flex;\n\tflex-shrink: 0;\n\talign-items: center;\n\tpadding: 0 6px 0 10px;\n}\n\n.editor-banner .icon-container.custom-icon {\n\tbackground-repeat: no-repeat;\n\tbackground-position: center center;\n\tbackground-size: 16px;\n\twidth: 16px;\n\tpadding: 0;\n\tmargin: 0 6px 0 10px;\n}\n\n.editor-banner .message-container {\n\tdisplay: flex;\n\talign-items: center;\n\tline-height: 26px;\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n\toverflow: hidden;\n}\n\n.editor-banner .message-container p {\n\tmargin-block-start: 0;\n\tmargin-block-end: 0;\n}\n\n.editor-banner .message-actions-container {\n\tflex-grow: 1;\n\tflex-shrink: 0;\n\tline-height: 26px;\n\tmargin: 0 4px;\n}\n\n.editor-banner .message-actions-container a.monaco-button {\n\twidth: inherit;\n\tmargin: 2px 8px;\n\tpadding: 0px 12px;\n}\n\n.editor-banner .message-actions-container a {\n\tpadding: 3px;\n\tmargin-left: 12px;\n\ttext-decoration: underline;\n}\n\n.editor-banner .action-container {\n\tpadding: 0 10px 0 6px;\n}\n\n.editor-banner {\n\tbackground-color: var(--vscode-banner-background);\n}\n\n.editor-banner,\n.editor-banner .action-container .codicon,\n.editor-banner .message-actions-container .monaco-link {\n\tcolor: var(--vscode-banner-foreground);\n}\n\n.editor-banner .icon-container .codicon {\n\tcolor: var(--vscode-banner-iconForeground);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.css": +/*!**************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.css ***! + \**************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .unicode-highlight { + border: 1px solid var(--vscode-editorUnicodeHighlight-border); + background-color: var(--vscode-editorUnicodeHighlight-background); + box-sizing: border-box; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,6DAA6D;CAC7D,iEAAiE;CACjE,sBAAsB;AACvB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .unicode-highlight {\n\tborder: 1px solid var(--vscode-editorUnicodeHighlight-border);\n\tbackground-color: var(--vscode-editorUnicodeHighlight-background);\n\tbox-sizing: border-box;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.css": +/*!*************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.css ***! + \*************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .focused .selectionHighlight { + background-color: var(--vscode-editor-selectionHighlightBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-selectionHighlightBorder); +} +.monaco-editor.hc-black .focused .selectionHighlight, .monaco-editor.hc-light .focused .selectionHighlight { + border-style: dotted; +} + +.monaco-editor .wordHighlight { + background-color: var(--vscode-editor-wordHighlightBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-wordHighlightBorder); +} +.monaco-editor.hc-black .wordHighlight, .monaco-editor.hc-light .wordHighlight { + border-style: dotted; +} + +.monaco-editor .wordHighlightStrong { + background-color: var(--vscode-editor-wordHighlightStrongBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-wordHighlightStrongBorder); +} +.monaco-editor.hc-black .wordHighlightStrong, .monaco-editor.hc-light .wordHighlightStrong { + border-style: dotted; +} + +.monaco-editor .wordHighlightText { + background-color: var(--vscode-editor-wordHighlightTextBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-wordHighlightTextBorder); +} +.monaco-editor.hc-black .wordHighlightText, .monaco-editor.hc-light .wordHighlightText { + border-style: dotted; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,mEAAmE;CACnE,sBAAsB;CACtB,+DAA+D;AAChE;AACA;CACC,oBAAoB;AACrB;;AAEA;CACC,8DAA8D;CAC9D,sBAAsB;CACtB,0DAA0D;AAC3D;AACA;CACC,oBAAoB;AACrB;;AAEA;CACC,oEAAoE;CACpE,sBAAsB;CACtB,gEAAgE;AACjE;AACA;CACC,oBAAoB;AACrB;;AAEA;CACC,kEAAkE;CAClE,sBAAsB;CACtB,8DAA8D;AAC/D;AACA;CACC,oBAAoB;AACrB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .focused .selectionHighlight {\n\tbackground-color: var(--vscode-editor-selectionHighlightBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-selectionHighlightBorder);\n}\n.monaco-editor.hc-black .focused .selectionHighlight, .monaco-editor.hc-light .focused .selectionHighlight {\n\tborder-style: dotted;\n}\n\n.monaco-editor .wordHighlight {\n\tbackground-color: var(--vscode-editor-wordHighlightBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-wordHighlightBorder);\n}\n.monaco-editor.hc-black .wordHighlight, .monaco-editor.hc-light .wordHighlight {\n\tborder-style: dotted;\n}\n\n.monaco-editor .wordHighlightStrong {\n\tbackground-color: var(--vscode-editor-wordHighlightStrongBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-wordHighlightStrongBorder);\n}\n.monaco-editor.hc-black .wordHighlightStrong, .monaco-editor.hc-light .wordHighlightStrong {\n\tborder-style: dotted;\n}\n\n.monaco-editor .wordHighlightText {\n\tbackground-color: var(--vscode-editor-wordHighlightTextBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-wordHighlightTextBorder);\n}\n.monaco-editor.hc-black .wordHighlightText, .monaco-editor.hc-light .wordHighlightText {\n\tborder-style: dotted;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget.css": +/*!**********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget.css ***! + \**********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +.monaco-editor .zone-widget { + position: absolute; + z-index: 10; +} + + +.monaco-editor .zone-widget .zone-widget-container { + border-top-style: solid; + border-bottom-style: solid; + border-top-width: 0; + border-bottom-width: 0; + position: relative; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;CACC,kBAAkB;CAClB,WAAW;AACZ;;;AAGA;CACC,uBAAuB;CACvB,0BAA0B;CAC1B,mBAAmB;CACnB,sBAAsB;CACtB,kBAAkB;AACnB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .zone-widget {\n\tposition: absolute;\n\tz-index: 10;\n}\n\n\n.monaco-editor .zone-widget .zone-widget-container {\n\tborder-top-style: solid;\n\tborder-bottom-style: solid;\n\tborder-top-width: 0;\n\tborder-bottom-width: 0;\n\tposition: relative;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.css": +/*!*************************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.css ***! + \*************************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/getUrl.js */ "./node_modules/css-loader/dist/runtime/getUrl.js"); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__); +// Imports + + + +var ___CSS_LOADER_URL_IMPORT_0___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCA1MyAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwKSI+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNDguMDM2NCA0LjAxMDQySDQuMDA3NzlMNC4wMDc3OSAzMi4wMjg2SDQ4LjAzNjRWNC4wMTA0MlpNNC4wMDc3OSAwLjAwNzgxMjVDMS43OTcyMSAwLjAwNzgxMjUgMC4wMDUxODc5OSAxLjc5OTg0IDAuMDA1MTg3OTkgNC4wMTA0MlYzMi4wMjg2QzAuMDA1MTg3OTkgMzQuMjM5MiAxLjc5NzIxIDM2LjAzMTIgNC4wMDc3OSAzNi4wMzEySDQ4LjAzNjRDNTAuMjQ3IDM2LjAzMTIgNTIuMDM5IDM0LjIzOTIgNTIuMDM5IDMyLjAyODZWNC4wMTA0MkM1Mi4wMzkgMS43OTk4NCA1MC4yNDcgMC4wMDc4MTI1IDQ4LjAzNjQgMC4wMDc4MTI1SDQuMDA3NzlaTTguMDEwNDIgOC4wMTMwMkgxMi4wMTNWMTIuMDE1Nkg4LjAxMDQyVjguMDEzMDJaTTIwLjAxODIgOC4wMTMwMkgxNi4wMTU2VjEyLjAxNTZIMjAuMDE4MlY4LjAxMzAyWk0yNC4wMjA4IDguMDEzMDJIMjguMDIzNFYxMi4wMTU2SDI0LjAyMDhWOC4wMTMwMlpNMzYuMDI4NiA4LjAxMzAySDMyLjAyNlYxMi4wMTU2SDM2LjAyODZWOC4wMTMwMlpNNDAuMDMxMiA4LjAxMzAySDQ0LjAzMzlWMTIuMDE1Nkg0MC4wMzEyVjguMDEzMDJaTTE2LjAxNTYgMTYuMDE4Mkg4LjAxMDQyVjIwLjAyMDhIMTYuMDE1NlYxNi4wMTgyWk0yMC4wMTgyIDE2LjAxODJIMjQuMDIwOFYyMC4wMjA4SDIwLjAxODJWMTYuMDE4MlpNMzIuMDI2IDE2LjAxODJIMjguMDIzNFYyMC4wMjA4SDMyLjAyNlYxNi4wMTgyWk00NC4wMzM5IDE2LjAxODJWMjAuMDIwOEgzNi4wMjg2VjE2LjAxODJINDQuMDMzOVpNMTIuMDEzIDI0LjAyMzRIOC4wMTA0MlYyOC4wMjZIMTIuMDEzVjI0LjAyMzRaTTE2LjAxNTYgMjQuMDIzNEgzNi4wMjg2VjI4LjAyNkgxNi4wMTU2VjI0LjAyMzRaTTQ0LjAzMzkgMjQuMDIzNEg0MC4wMzEyVjI4LjAyNkg0NC4wMzM5VjI0LjAyMzRaIiBmaWxsPSIjNDI0MjQyIi8+CjwvZz4KPGRlZnM+CjxjbGlwUGF0aCBpZD0iY2xpcDAiPgo8cmVjdCB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIGZpbGw9IndoaXRlIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg== */ "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCA1MyAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwKSI+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNDguMDM2NCA0LjAxMDQySDQuMDA3NzlMNC4wMDc3OSAzMi4wMjg2SDQ4LjAzNjRWNC4wMTA0MlpNNC4wMDc3OSAwLjAwNzgxMjVDMS43OTcyMSAwLjAwNzgxMjUgMC4wMDUxODc5OSAxLjc5OTg0IDAuMDA1MTg3OTkgNC4wMTA0MlYzMi4wMjg2QzAuMDA1MTg3OTkgMzQuMjM5MiAxLjc5NzIxIDM2LjAzMTIgNC4wMDc3OSAzNi4wMzEySDQ4LjAzNjRDNTAuMjQ3IDM2LjAzMTIgNTIuMDM5IDM0LjIzOTIgNTIuMDM5IDMyLjAyODZWNC4wMTA0MkM1Mi4wMzkgMS43OTk4NCA1MC4yNDcgMC4wMDc4MTI1IDQ4LjAzNjQgMC4wMDc4MTI1SDQuMDA3NzlaTTguMDEwNDIgOC4wMTMwMkgxMi4wMTNWMTIuMDE1Nkg4LjAxMDQyVjguMDEzMDJaTTIwLjAxODIgOC4wMTMwMkgxNi4wMTU2VjEyLjAxNTZIMjAuMDE4MlY4LjAxMzAyWk0yNC4wMjA4IDguMDEzMDJIMjguMDIzNFYxMi4wMTU2SDI0LjAyMDhWOC4wMTMwMlpNMzYuMDI4NiA4LjAxMzAySDMyLjAyNlYxMi4wMTU2SDM2LjAyODZWOC4wMTMwMlpNNDAuMDMxMiA4LjAxMzAySDQ0LjAzMzlWMTIuMDE1Nkg0MC4wMzEyVjguMDEzMDJaTTE2LjAxNTYgMTYuMDE4Mkg4LjAxMDQyVjIwLjAyMDhIMTYuMDE1NlYxNi4wMTgyWk0yMC4wMTgyIDE2LjAxODJIMjQuMDIwOFYyMC4wMjA4SDIwLjAxODJWMTYuMDE4MlpNMzIuMDI2IDE2LjAxODJIMjguMDIzNFYyMC4wMjA4SDMyLjAyNlYxNi4wMTgyWk00NC4wMzM5IDE2LjAxODJWMjAuMDIwOEgzNi4wMjg2VjE2LjAxODJINDQuMDMzOVpNMTIuMDEzIDI0LjAyMzRIOC4wMTA0MlYyOC4wMjZIMTIuMDEzVjI0LjAyMzRaTTE2LjAxNTYgMjQuMDIzNEgzNi4wMjg2VjI4LjAyNkgxNi4wMTU2VjI0LjAyMzRaTTQ0LjAzMzkgMjQuMDIzNEg0MC4wMzEyVjI4LjAyNkg0NC4wMzM5VjI0LjAyMzRaIiBmaWxsPSIjNDI0MjQyIi8+CjwvZz4KPGRlZnM+CjxjbGlwUGF0aCBpZD0iY2xpcDAiPgo8cmVjdCB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIGZpbGw9IndoaXRlIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg=="), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_1___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCA1MyAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwKSI+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNDguMDM2NCA0LjAxMDQySDQuMDA3NzlMNC4wMDc3OSAzMi4wMjg2SDQ4LjAzNjRWNC4wMTA0MlpNNC4wMDc3OSAwLjAwNzgxMjVDMS43OTcyMSAwLjAwNzgxMjUgMC4wMDUxODc5OSAxLjc5OTg0IDAuMDA1MTg3OTkgNC4wMTA0MlYzMi4wMjg2QzAuMDA1MTg3OTkgMzQuMjM5MiAxLjc5NzIxIDM2LjAzMTIgNC4wMDc3OSAzNi4wMzEySDQ4LjAzNjRDNTAuMjQ3IDM2LjAzMTIgNTIuMDM5IDM0LjIzOTIgNTIuMDM5IDMyLjAyODZWNC4wMTA0MkM1Mi4wMzkgMS43OTk4NCA1MC4yNDcgMC4wMDc4MTI1IDQ4LjAzNjQgMC4wMDc4MTI1SDQuMDA3NzlaTTguMDEwNDIgOC4wMTMwMkgxMi4wMTNWMTIuMDE1Nkg4LjAxMDQyVjguMDEzMDJaTTIwLjAxODIgOC4wMTMwMkgxNi4wMTU2VjEyLjAxNTZIMjAuMDE4MlY4LjAxMzAyWk0yNC4wMjA4IDguMDEzMDJIMjguMDIzNFYxMi4wMTU2SDI0LjAyMDhWOC4wMTMwMlpNMzYuMDI4NiA4LjAxMzAySDMyLjAyNlYxMi4wMTU2SDM2LjAyODZWOC4wMTMwMlpNNDAuMDMxMiA4LjAxMzAySDQ0LjAzMzlWMTIuMDE1Nkg0MC4wMzEyVjguMDEzMDJaTTE2LjAxNTYgMTYuMDE4Mkg4LjAxMDQyVjIwLjAyMDhIMTYuMDE1NlYxNi4wMTgyWk0yMC4wMTgyIDE2LjAxODJIMjQuMDIwOFYyMC4wMjA4SDIwLjAxODJWMTYuMDE4MlpNMzIuMDI2IDE2LjAxODJIMjguMDIzNFYyMC4wMjA4SDMyLjAyNlYxNi4wMTgyWk00NC4wMzM5IDE2LjAxODJWMjAuMDIwOEgzNi4wMjg2VjE2LjAxODJINDQuMDMzOVpNMTIuMDEzIDI0LjAyMzRIOC4wMTA0MlYyOC4wMjZIMTIuMDEzVjI0LjAyMzRaTTE2LjAxNTYgMjQuMDIzNEgzNi4wMjg2VjI4LjAyNkgxNi4wMTU2VjI0LjAyMzRaTTQ0LjAzMzkgMjQuMDIzNEg0MC4wMzEyVjI4LjAyNkg0NC4wMzM5VjI0LjAyMzRaIiBmaWxsPSIjQzVDNUM1Ii8+CjwvZz4KPGRlZnM+CjxjbGlwUGF0aCBpZD0iY2xpcDAiPgo8cmVjdCB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIGZpbGw9IndoaXRlIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg== */ "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCA1MyAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwKSI+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNDguMDM2NCA0LjAxMDQySDQuMDA3NzlMNC4wMDc3OSAzMi4wMjg2SDQ4LjAzNjRWNC4wMTA0MlpNNC4wMDc3OSAwLjAwNzgxMjVDMS43OTcyMSAwLjAwNzgxMjUgMC4wMDUxODc5OSAxLjc5OTg0IDAuMDA1MTg3OTkgNC4wMTA0MlYzMi4wMjg2QzAuMDA1MTg3OTkgMzQuMjM5MiAxLjc5NzIxIDM2LjAzMTIgNC4wMDc3OSAzNi4wMzEySDQ4LjAzNjRDNTAuMjQ3IDM2LjAzMTIgNTIuMDM5IDM0LjIzOTIgNTIuMDM5IDMyLjAyODZWNC4wMTA0MkM1Mi4wMzkgMS43OTk4NCA1MC4yNDcgMC4wMDc4MTI1IDQ4LjAzNjQgMC4wMDc4MTI1SDQuMDA3NzlaTTguMDEwNDIgOC4wMTMwMkgxMi4wMTNWMTIuMDE1Nkg4LjAxMDQyVjguMDEzMDJaTTIwLjAxODIgOC4wMTMwMkgxNi4wMTU2VjEyLjAxNTZIMjAuMDE4MlY4LjAxMzAyWk0yNC4wMjA4IDguMDEzMDJIMjguMDIzNFYxMi4wMTU2SDI0LjAyMDhWOC4wMTMwMlpNMzYuMDI4NiA4LjAxMzAySDMyLjAyNlYxMi4wMTU2SDM2LjAyODZWOC4wMTMwMlpNNDAuMDMxMiA4LjAxMzAySDQ0LjAzMzlWMTIuMDE1Nkg0MC4wMzEyVjguMDEzMDJaTTE2LjAxNTYgMTYuMDE4Mkg4LjAxMDQyVjIwLjAyMDhIMTYuMDE1NlYxNi4wMTgyWk0yMC4wMTgyIDE2LjAxODJIMjQuMDIwOFYyMC4wMjA4SDIwLjAxODJWMTYuMDE4MlpNMzIuMDI2IDE2LjAxODJIMjguMDIzNFYyMC4wMjA4SDMyLjAyNlYxNi4wMTgyWk00NC4wMzM5IDE2LjAxODJWMjAuMDIwOEgzNi4wMjg2VjE2LjAxODJINDQuMDMzOVpNMTIuMDEzIDI0LjAyMzRIOC4wMTA0MlYyOC4wMjZIMTIuMDEzVjI0LjAyMzRaTTE2LjAxNTYgMjQuMDIzNEgzNi4wMjg2VjI4LjAyNkgxNi4wMTU2VjI0LjAyMzRaTTQ0LjAzMzkgMjQuMDIzNEg0MC4wMzEyVjI4LjAyNkg0NC4wMzM5VjI0LjAyMzRaIiBmaWxsPSIjQzVDNUM1Ii8+CjwvZz4KPGRlZnM+CjxjbGlwUGF0aCBpZD0iY2xpcDAiPgo8cmVjdCB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIGZpbGw9IndoaXRlIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg=="), __webpack_require__.b); +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +var ___CSS_LOADER_URL_REPLACEMENT_0___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_0___); +var ___CSS_LOADER_URL_REPLACEMENT_1___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_1___); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .iPadShowKeyboard { + width: 58px; + min-width: 0; + height: 36px; + min-height: 0; + margin: 0; + padding: 0; + position: absolute; + resize: none; + overflow: hidden; + background: url(${___CSS_LOADER_URL_REPLACEMENT_0___}) center center no-repeat; + border: 4px solid #F6F6F6; + border-radius: 4px; +} + +.monaco-editor.vs-dark .iPadShowKeyboard { + background: url(${___CSS_LOADER_URL_REPLACEMENT_1___}) center center no-repeat; + border: 4px solid #252526; +}`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,WAAW;CACX,YAAY;CACZ,YAAY;CACZ,aAAa;CACb,SAAS;CACT,UAAU;CACV,kBAAkB;CAClB,YAAY;CACZ,gBAAgB;CAChB,2EAAqnD;CACrnD,yBAAyB;CACzB,kBAAkB;AACnB;;AAEA;CACC,2EAAqnD;CACrnD,yBAAyB;AAC1B","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .iPadShowKeyboard {\n\twidth: 58px;\n\tmin-width: 0;\n\theight: 36px;\n\tmin-height: 0;\n\tmargin: 0;\n\tpadding: 0;\n\tposition: absolute;\n\tresize: none;\n\toverflow: hidden;\n\tbackground: url(\"data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCA1MyAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwKSI+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNDguMDM2NCA0LjAxMDQySDQuMDA3NzlMNC4wMDc3OSAzMi4wMjg2SDQ4LjAzNjRWNC4wMTA0MlpNNC4wMDc3OSAwLjAwNzgxMjVDMS43OTcyMSAwLjAwNzgxMjUgMC4wMDUxODc5OSAxLjc5OTg0IDAuMDA1MTg3OTkgNC4wMTA0MlYzMi4wMjg2QzAuMDA1MTg3OTkgMzQuMjM5MiAxLjc5NzIxIDM2LjAzMTIgNC4wMDc3OSAzNi4wMzEySDQ4LjAzNjRDNTAuMjQ3IDM2LjAzMTIgNTIuMDM5IDM0LjIzOTIgNTIuMDM5IDMyLjAyODZWNC4wMTA0MkM1Mi4wMzkgMS43OTk4NCA1MC4yNDcgMC4wMDc4MTI1IDQ4LjAzNjQgMC4wMDc4MTI1SDQuMDA3NzlaTTguMDEwNDIgOC4wMTMwMkgxMi4wMTNWMTIuMDE1Nkg4LjAxMDQyVjguMDEzMDJaTTIwLjAxODIgOC4wMTMwMkgxNi4wMTU2VjEyLjAxNTZIMjAuMDE4MlY4LjAxMzAyWk0yNC4wMjA4IDguMDEzMDJIMjguMDIzNFYxMi4wMTU2SDI0LjAyMDhWOC4wMTMwMlpNMzYuMDI4NiA4LjAxMzAySDMyLjAyNlYxMi4wMTU2SDM2LjAyODZWOC4wMTMwMlpNNDAuMDMxMiA4LjAxMzAySDQ0LjAzMzlWMTIuMDE1Nkg0MC4wMzEyVjguMDEzMDJaTTE2LjAxNTYgMTYuMDE4Mkg4LjAxMDQyVjIwLjAyMDhIMTYuMDE1NlYxNi4wMTgyWk0yMC4wMTgyIDE2LjAxODJIMjQuMDIwOFYyMC4wMjA4SDIwLjAxODJWMTYuMDE4MlpNMzIuMDI2IDE2LjAxODJIMjguMDIzNFYyMC4wMjA4SDMyLjAyNlYxNi4wMTgyWk00NC4wMzM5IDE2LjAxODJWMjAuMDIwOEgzNi4wMjg2VjE2LjAxODJINDQuMDMzOVpNMTIuMDEzIDI0LjAyMzRIOC4wMTA0MlYyOC4wMjZIMTIuMDEzVjI0LjAyMzRaTTE2LjAxNTYgMjQuMDIzNEgzNi4wMjg2VjI4LjAyNkgxNi4wMTU2VjI0LjAyMzRaTTQ0LjAzMzkgMjQuMDIzNEg0MC4wMzEyVjI4LjAyNkg0NC4wMzM5VjI0LjAyMzRaIiBmaWxsPSIjNDI0MjQyIi8+CjwvZz4KPGRlZnM+CjxjbGlwUGF0aCBpZD0iY2xpcDAiPgo8cmVjdCB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIGZpbGw9IndoaXRlIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg==\") center center no-repeat;\n\tborder: 4px solid #F6F6F6;\n\tborder-radius: 4px;\n}\n\n.monaco-editor.vs-dark .iPadShowKeyboard {\n\tbackground: url(\"data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCA1MyAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwKSI+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNDguMDM2NCA0LjAxMDQySDQuMDA3NzlMNC4wMDc3OSAzMi4wMjg2SDQ4LjAzNjRWNC4wMTA0MlpNNC4wMDc3OSAwLjAwNzgxMjVDMS43OTcyMSAwLjAwNzgxMjUgMC4wMDUxODc5OSAxLjc5OTg0IDAuMDA1MTg3OTkgNC4wMTA0MlYzMi4wMjg2QzAuMDA1MTg3OTkgMzQuMjM5MiAxLjc5NzIxIDM2LjAzMTIgNC4wMDc3OSAzNi4wMzEySDQ4LjAzNjRDNTAuMjQ3IDM2LjAzMTIgNTIuMDM5IDM0LjIzOTIgNTIuMDM5IDMyLjAyODZWNC4wMTA0MkM1Mi4wMzkgMS43OTk4NCA1MC4yNDcgMC4wMDc4MTI1IDQ4LjAzNjQgMC4wMDc4MTI1SDQuMDA3NzlaTTguMDEwNDIgOC4wMTMwMkgxMi4wMTNWMTIuMDE1Nkg4LjAxMDQyVjguMDEzMDJaTTIwLjAxODIgOC4wMTMwMkgxNi4wMTU2VjEyLjAxNTZIMjAuMDE4MlY4LjAxMzAyWk0yNC4wMjA4IDguMDEzMDJIMjguMDIzNFYxMi4wMTU2SDI0LjAyMDhWOC4wMTMwMlpNMzYuMDI4NiA4LjAxMzAySDMyLjAyNlYxMi4wMTU2SDM2LjAyODZWOC4wMTMwMlpNNDAuMDMxMiA4LjAxMzAySDQ0LjAzMzlWMTIuMDE1Nkg0MC4wMzEyVjguMDEzMDJaTTE2LjAxNTYgMTYuMDE4Mkg4LjAxMDQyVjIwLjAyMDhIMTYuMDE1NlYxNi4wMTgyWk0yMC4wMTgyIDE2LjAxODJIMjQuMDIwOFYyMC4wMjA4SDIwLjAxODJWMTYuMDE4MlpNMzIuMDI2IDE2LjAxODJIMjguMDIzNFYyMC4wMjA4SDMyLjAyNlYxNi4wMTgyWk00NC4wMzM5IDE2LjAxODJWMjAuMDIwOEgzNi4wMjg2VjE2LjAxODJINDQuMDMzOVpNMTIuMDEzIDI0LjAyMzRIOC4wMTA0MlYyOC4wMjZIMTIuMDEzVjI0LjAyMzRaTTE2LjAxNTYgMjQuMDIzNEgzNi4wMjg2VjI4LjAyNkgxNi4wMTU2VjI0LjAyMzRaTTQ0LjAzMzkgMjQuMDIzNEg0MC4wMzEyVjI4LjAyNkg0NC4wMzM5VjI0LjAyMzRaIiBmaWxsPSIjQzVDNUM1Ii8+CjwvZz4KPGRlZnM+CjxjbGlwUGF0aCBpZD0iY2xpcDAiPgo8cmVjdCB3aWR0aD0iNTMiIGhlaWdodD0iMzYiIGZpbGw9IndoaXRlIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg==\") center center no-repeat;\n\tborder: 4px solid #252526;\n}"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/inspectTokens/inspectTokens.css": +/*!*******************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/inspectTokens/inspectTokens.css ***! + \*******************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .tokens-inspect-widget { + z-index: 50; + user-select: text; + -webkit-user-select: text; + padding: 10px; + color: var(--vscode-editorHoverWidget-foreground); + background-color: var(--vscode-editorHoverWidget-background); + border: 1px solid var(--vscode-editorHoverWidget-border); +} +.monaco-editor.hc-black .tokens-inspect-widget, .monaco-editor.hc-light .tokens-inspect-widget { + border-width: 2px; +} + +.monaco-editor .tokens-inspect-widget .tokens-inspect-separator { + height: 1px; + border: 0; + background-color: var(--vscode-editorHoverWidget-border); +} + +.monaco-editor .tokens-inspect-widget .tm-token { + font-family: var(--monaco-monospace-font); +} + +.monaco-editor .tokens-inspect-widget .tm-token-length { + font-weight: normal; + font-size: 60%; + float: right; +} + +.monaco-editor .tokens-inspect-widget .tm-metadata-table { + width: 100%; +} + +.monaco-editor .tokens-inspect-widget .tm-metadata-value { + font-family: var(--monaco-monospace-font); + text-align: right; +} + +.monaco-editor .tokens-inspect-widget .tm-token-type { + font-family: var(--monaco-monospace-font); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/standalone/browser/inspectTokens/inspectTokens.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,WAAW;CACX,iBAAiB;CACjB,yBAAyB;CACzB,aAAa;CACb,iDAAiD;CACjD,4DAA4D;CAC5D,wDAAwD;AACzD;AACA;CACC,iBAAiB;AAClB;;AAEA;CACC,WAAW;CACX,SAAS;CACT,wDAAwD;AACzD;;AAEA;CACC,yCAAyC;AAC1C;;AAEA;CACC,mBAAmB;CACnB,cAAc;CACd,YAAY;AACb;;AAEA;CACC,WAAW;AACZ;;AAEA;CACC,yCAAyC;CACzC,iBAAiB;AAClB;;AAEA;CACC,yCAAyC;AAC1C","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .tokens-inspect-widget {\n\tz-index: 50;\n\tuser-select: text;\n\t-webkit-user-select: text;\n\tpadding: 10px;\n\tcolor: var(--vscode-editorHoverWidget-foreground);\n\tbackground-color: var(--vscode-editorHoverWidget-background);\n\tborder: 1px solid var(--vscode-editorHoverWidget-border);\n}\n.monaco-editor.hc-black .tokens-inspect-widget, .monaco-editor.hc-light .tokens-inspect-widget {\n\tborder-width: 2px;\n}\n\n.monaco-editor .tokens-inspect-widget .tokens-inspect-separator {\n\theight: 1px;\n\tborder: 0;\n\tbackground-color: var(--vscode-editorHoverWidget-border);\n}\n\n.monaco-editor .tokens-inspect-widget .tm-token {\n\tfont-family: var(--monaco-monospace-font);\n}\n\n.monaco-editor .tokens-inspect-widget .tm-token-length {\n\tfont-weight: normal;\n\tfont-size: 60%;\n\tfloat: right;\n}\n\n.monaco-editor .tokens-inspect-widget .tm-metadata-table {\n\twidth: 100%;\n}\n\n.monaco-editor .tokens-inspect-widget .tm-metadata-value {\n\tfont-family: var(--monaco-monospace-font);\n\ttext-align: right;\n}\n\n.monaco-editor .tokens-inspect-widget .tm-token-type {\n\tfont-family: var(--monaco-monospace-font);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInput.css": +/*!***********************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInput.css ***! + \***********************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.quick-input-widget { + font-size: 13px; +} + +.quick-input-widget .monaco-highlighted-label .highlight, +.quick-input-widget .monaco-highlighted-label .highlight { + color: #0066BF; +} + +.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight, +.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight { + color: #9DDDFF; +} + +.vs-dark .quick-input-widget .monaco-highlighted-label .highlight, +.vs-dark .quick-input-widget .monaco-highlighted-label .highlight { + color: #0097fb; +} + +.hc-black .quick-input-widget .monaco-highlighted-label .highlight, +.hc-black .quick-input-widget .monaco-highlighted-label .highlight { + color: #F38518; +} + +.hc-light .quick-input-widget .monaco-highlighted-label .highlight, +.hc-light .quick-input-widget .monaco-highlighted-label .highlight { + color: #0F4A85; +} + +.monaco-keybinding > .monaco-keybinding-key { + background-color: rgba(221, 221, 221, 0.4); + border: solid 1px rgba(204, 204, 204, 0.4); + border-bottom-color: rgba(187, 187, 187, 0.4); + box-shadow: inset 0 -1px 0 rgba(187, 187, 187, 0.4); + color: #555; +} + +.hc-black .monaco-keybinding > .monaco-keybinding-key { + background-color: transparent; + border: solid 1px rgb(111, 195, 223); + box-shadow: none; + color: #fff; +} + +.hc-light .monaco-keybinding > .monaco-keybinding-key { + background-color: transparent; + border: solid 1px #0F4A85; + box-shadow: none; + color: #292929; +} + +.vs-dark .monaco-keybinding > .monaco-keybinding-key { + background-color: rgba(128, 128, 128, 0.17); + border: solid 1px rgba(51, 51, 51, 0.6); + border-bottom-color: rgba(68, 68, 68, 0.6); + box-shadow: inset 0 -1px 0 rgba(68, 68, 68, 0.6); + color: #ccc; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInput.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,eAAe;AAChB;;AAEA;;CAEC,cAAc;AACf;;AAEA;;CAEC,cAAc;AACf;;AAEA;;CAEC,cAAc;AACf;;AAEA;;CAEC,cAAc;AACf;;AAEA;;CAEC,cAAc;AACf;;AAEA;CACC,0CAA0C;CAC1C,0CAA0C;CAC1C,6CAA6C;CAC7C,mDAAmD;CACnD,WAAW;AACZ;;AAEA;CACC,6BAA6B;CAC7B,oCAAoC;CACpC,gBAAgB;CAChB,WAAW;AACZ;;AAEA;CACC,6BAA6B;CAC7B,yBAAyB;CACzB,gBAAgB;CAChB,cAAc;AACf;;AAEA;CACC,2CAA2C;CAC3C,uCAAuC;CACvC,0CAA0C;CAC1C,gDAAgD;CAChD,WAAW;AACZ","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.quick-input-widget {\n\tfont-size: 13px;\n}\n\n.quick-input-widget .monaco-highlighted-label .highlight,\n.quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #0066BF;\n}\n\n.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight,\n.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight {\n\tcolor: #9DDDFF;\n}\n\n.vs-dark .quick-input-widget .monaco-highlighted-label .highlight,\n.vs-dark .quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #0097fb;\n}\n\n.hc-black .quick-input-widget .monaco-highlighted-label .highlight,\n.hc-black .quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #F38518;\n}\n\n.hc-light .quick-input-widget .monaco-highlighted-label .highlight,\n.hc-light .quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #0F4A85;\n}\n\n.monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: rgba(221, 221, 221, 0.4);\n\tborder: solid 1px rgba(204, 204, 204, 0.4);\n\tborder-bottom-color: rgba(187, 187, 187, 0.4);\n\tbox-shadow: inset 0 -1px 0 rgba(187, 187, 187, 0.4);\n\tcolor: #555;\n}\n\n.hc-black .monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: transparent;\n\tborder: solid 1px rgb(111, 195, 223);\n\tbox-shadow: none;\n\tcolor: #fff;\n}\n\n.hc-light .monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: transparent;\n\tborder: solid 1px #0F4A85;\n\tbox-shadow: none;\n\tcolor: #292929;\n}\n\n.vs-dark .monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: rgba(128, 128, 128, 0.17);\n\tborder: solid 1px rgba(51, 51, 51, 0.6);\n\tborder-bottom-color: rgba(68, 68, 68, 0.6);\n\tbox-shadow: inset 0 -1px 0 rgba(68, 68, 68, 0.6);\n\tcolor: #ccc;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/standalone-tokens.css": +/*!*********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/editor/standalone/browser/standalone-tokens.css ***! + \*********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + + +/* Default standalone editor fonts */ +.monaco-editor { + font-family: -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", "HelveticaNeue-Light", system-ui, "Ubuntu", "Droid Sans", sans-serif; + --monaco-monospace-font: "SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace; +} + +.monaco-menu .monaco-action-bar.vertical .action-item .action-menu-item:focus .action-label { + stroke-width: 1.2px; +} + +.monaco-editor.vs-dark .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label, +.monaco-editor.hc-black .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label, +.monaco-editor.hc-light .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label { + stroke-width: 1.2px; +} + +.monaco-hover p { + margin: 0; +} + +/* See https://github.com/microsoft/monaco-editor/issues/2168#issuecomment-780078600 */ +.monaco-aria-container { + position: absolute !important; + top: 0; /* avoid being placed underneath a sibling element */ + height: 1px; + width: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + clip: rect(1px, 1px, 1px, 1px); + clip-path: inset(50%); +} + +/*.monaco-editor.vs [tabindex="0"]:focus { + outline: 1px solid rgba(0, 122, 204, 0.4); + outline-offset: -1px; + opacity: 1 !important; +} + +.monaco-editor.vs-dark [tabindex="0"]:focus { + outline: 1px solid rgba(14, 99, 156, 0.6); + outline-offset: -1px; + opacity: 1 !important; +}*/ +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/editor/standalone/browser/standalone-tokens.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;;AAG/F,oCAAoC;AACpC;CACC,6IAA6I;CAC7I,2IAA2I;AAC5I;;AAEA;CACC,mBAAmB;AACpB;;AAEA;;;CAGC,mBAAmB;AACpB;;AAEA;CACC,SAAS;AACV;;AAEA,sFAAsF;AACtF;CACC,6BAA6B;CAC7B,MAAM,EAAE,oDAAoD;CAC5D,WAAW;CACX,UAAU;CACV,YAAY;CACZ,gBAAgB;CAChB,UAAU;CACV,8BAA8B;CAC9B,qBAAqB;AACtB;;AAEA;;;;;;;;;;EAUE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\n/* Default standalone editor fonts */\n.monaco-editor {\n\tfont-family: -apple-system, BlinkMacSystemFont, \"Segoe WPC\", \"Segoe UI\", \"HelveticaNeue-Light\", system-ui, \"Ubuntu\", \"Droid Sans\", sans-serif;\n\t--monaco-monospace-font: \"SF Mono\", Monaco, Menlo, Consolas, \"Ubuntu Mono\", \"Liberation Mono\", \"DejaVu Sans Mono\", \"Courier New\", monospace;\n}\n\n.monaco-menu .monaco-action-bar.vertical .action-item .action-menu-item:focus .action-label {\n\tstroke-width: 1.2px;\n}\n\n.monaco-editor.vs-dark .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,\n.monaco-editor.hc-black .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,\n.monaco-editor.hc-light .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label {\n\tstroke-width: 1.2px;\n}\n\n.monaco-hover p {\n\tmargin: 0;\n}\n\n/* See https://github.com/microsoft/monaco-editor/issues/2168#issuecomment-780078600 */\n.monaco-aria-container {\n\tposition: absolute !important;\n\ttop: 0; /* avoid being placed underneath a sibling element */\n\theight: 1px;\n\twidth: 1px;\n\tmargin: -1px;\n\toverflow: hidden;\n\tpadding: 0;\n\tclip: rect(1px, 1px, 1px, 1px);\n\tclip-path: inset(50%);\n}\n\n/*.monaco-editor.vs [tabindex=\"0\"]:focus {\n\toutline: 1px solid rgba(0, 122, 204, 0.4);\n\toutline-offset: -1px;\n\topacity: 1 !important;\n}\n\n.monaco-editor.vs-dark [tabindex=\"0\"]:focus {\n\toutline: 1px solid rgba(14, 99, 156, 0.6);\n\toutline-offset: -1px;\n\topacity: 1 !important;\n}*/\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/actionWidget/browser/actionWidget.css": +/*!********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/actionWidget/browser/actionWidget.css ***! + \********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.action-widget { + font-size: 13px; + border-radius: 0; + min-width: 160px; + max-width: 80vw; + z-index: 40; + display: block; + width: 100%; + border: 1px solid var(--vscode-editorWidget-border) !important; + border-radius: 2px; + background-color: var(--vscode-editorWidget-background); + color: var(--vscode-editorWidget-foreground); +} + +.context-view-block { + position: fixed; + cursor: initial; + left: 0; + top: 0; + width: 100%; + height: 100%; + z-index: -1; +} + +.context-view-pointerBlock { + position: fixed; + cursor: initial; + left: 0; + top: 0; + width: 100%; + height: 100%; + z-index: 2; +} + +.action-widget .monaco-list { + user-select: none; + -webkit-user-select: none; + border: none !important; + border-width: 0 !important; +} + +.action-widget .monaco-list:focus:before { + outline: 0 !important; +} + +.action-widget .monaco-list .monaco-scrollable-element { + overflow: visible; +} + +/** Styles for each row in the list element **/ +.action-widget .monaco-list .monaco-list-row { + padding: 0 10px; + white-space: nowrap; + cursor: pointer; + touch-action: none; + width: 100%; +} + +.action-widget .monaco-list .monaco-list-row.action.focused:not(.option-disabled) { + background-color: var(--vscode-quickInputList-focusBackground) !important; + color: var(--vscode-quickInputList-focusForeground); + outline: 1px solid var(--vscode-menu-selectionBorder, transparent); + outline-offset: -1px; +} + +.action-widget .monaco-list-row.group-header { + color: var(--vscode-descriptionForeground) !important; + font-weight: 600; +} + +.action-widget .monaco-list .group-header, +.action-widget .monaco-list .option-disabled, +.action-widget .monaco-list .option-disabled:before, +.action-widget .monaco-list .option-disabled .focused, +.action-widget .monaco-list .option-disabled .focused:before { + cursor: default !important; + -webkit-touch-callout: none; + -webkit-user-select: none; + user-select: none; + background-color: transparent !important; + outline: 0 solid !important; +} + +.action-widget .monaco-list-row.action { + display: flex; + gap: 6px; + align-items: center; +} + +.action-widget .monaco-list-row.action.option-disabled, +.action-widget .monaco-list:focus .monaco-list-row.focused.action.option-disabled, +.action-widget .monaco-list-row.action.option-disabled .codicon, +.action-widget .monaco-list:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused).option-disabled { + color: var(--vscode-disabledForeground); +} + + +.action-widget .monaco-list-row.action:not(.option-disabled) .codicon { + color: inherit; +} + +.action-widget .monaco-list-row.action .title { + flex: 1; + overflow: hidden; + text-overflow: ellipsis; +} + +/* Action bar */ + +.action-widget .action-widget-action-bar { + background-color: var(--vscode-editorHoverWidget-statusBarBackground); + border-top: 1px solid var(--vscode-editorHoverWidget-border); +} + +.action-widget .action-widget-action-bar::before { + display: block; + content: ""; + width: 100%; +} + +.action-widget .action-widget-action-bar .actions-container { + padding: 0 8px; +} + +.action-widget-action-bar .action-label { + color: var(--vscode-textLink-activeForeground); + font-size: 12px; + line-height: 22px; + padding: 0; + pointer-events: all; +} + +.action-widget-action-bar .action-item { + margin-right: 16px; + pointer-events: none; +} + +.action-widget-action-bar .action-label:hover { + background-color: transparent !important; +} + +.monaco-action-bar .actions-container.highlight-toggled .action-label.checked { + /* The important gives this rule precedence over the hover rule. */ + background: var(--vscode-actionBar-toggledBackground) !important; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/platform/actionWidget/browser/actionWidget.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,eAAe;CACf,gBAAgB;CAChB,gBAAgB;CAChB,eAAe;CACf,WAAW;CACX,cAAc;CACd,WAAW;CACX,8DAA8D;CAC9D,kBAAkB;CAClB,uDAAuD;CACvD,4CAA4C;AAC7C;;AAEA;CACC,eAAe;CACf,eAAe;CACf,OAAO;CACP,MAAM;CACN,WAAW;CACX,YAAY;CACZ,WAAW;AACZ;;AAEA;CACC,eAAe;CACf,eAAe;CACf,OAAO;CACP,MAAM;CACN,WAAW;CACX,YAAY;CACZ,UAAU;AACX;;AAEA;CACC,iBAAiB;CACjB,yBAAyB;CACzB,uBAAuB;CACvB,0BAA0B;AAC3B;;AAEA;CACC,qBAAqB;AACtB;;AAEA;CACC,iBAAiB;AAClB;;AAEA,8CAA8C;AAC9C;CACC,eAAe;CACf,mBAAmB;CACnB,eAAe;CACf,kBAAkB;CAClB,WAAW;AACZ;;AAEA;CACC,yEAAyE;CACzE,mDAAmD;CACnD,kEAAkE;CAClE,oBAAoB;AACrB;;AAEA;CACC,qDAAqD;CACrD,gBAAgB;AACjB;;AAEA;;;;;CAKC,0BAA0B;CAC1B,2BAA2B;CAC3B,yBAAyB;CACzB,iBAAiB;CACjB,wCAAwC;CACxC,2BAA2B;AAC5B;;AAEA;CACC,aAAa;CACb,QAAQ;CACR,mBAAmB;AACpB;;AAEA;;;;CAIC,uCAAuC;AACxC;;;AAGA;CACC,cAAc;AACf;;AAEA;CACC,OAAO;CACP,gBAAgB;CAChB,uBAAuB;AACxB;;AAEA,eAAe;;AAEf;CACC,qEAAqE;CACrE,4DAA4D;AAC7D;;AAEA;CACC,cAAc;CACd,WAAW;CACX,WAAW;AACZ;;AAEA;CACC,cAAc;AACf;;AAEA;CACC,8CAA8C;CAC9C,eAAe;CACf,iBAAiB;CACjB,UAAU;CACV,mBAAmB;AACpB;;AAEA;CACC,kBAAkB;CAClB,oBAAoB;AACrB;;AAEA;CACC,wCAAwC;AACzC;;AAEA;CACC,kEAAkE;CAClE,gEAAgE;AACjE","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.action-widget {\n\tfont-size: 13px;\n\tborder-radius: 0;\n\tmin-width: 160px;\n\tmax-width: 80vw;\n\tz-index: 40;\n\tdisplay: block;\n\twidth: 100%;\n\tborder: 1px solid var(--vscode-editorWidget-border) !important;\n\tborder-radius: 2px;\n\tbackground-color: var(--vscode-editorWidget-background);\n\tcolor: var(--vscode-editorWidget-foreground);\n}\n\n.context-view-block {\n\tposition: fixed;\n\tcursor: initial;\n\tleft: 0;\n\ttop: 0;\n\twidth: 100%;\n\theight: 100%;\n\tz-index: -1;\n}\n\n.context-view-pointerBlock {\n\tposition: fixed;\n\tcursor: initial;\n\tleft: 0;\n\ttop: 0;\n\twidth: 100%;\n\theight: 100%;\n\tz-index: 2;\n}\n\n.action-widget .monaco-list {\n\tuser-select: none;\n\t-webkit-user-select: none;\n\tborder: none !important;\n\tborder-width: 0 !important;\n}\n\n.action-widget .monaco-list:focus:before {\n\toutline: 0 !important;\n}\n\n.action-widget .monaco-list .monaco-scrollable-element {\n\toverflow: visible;\n}\n\n/** Styles for each row in the list element **/\n.action-widget .monaco-list .monaco-list-row {\n\tpadding: 0 10px;\n\twhite-space: nowrap;\n\tcursor: pointer;\n\ttouch-action: none;\n\twidth: 100%;\n}\n\n.action-widget .monaco-list .monaco-list-row.action.focused:not(.option-disabled) {\n\tbackground-color: var(--vscode-quickInputList-focusBackground) !important;\n\tcolor: var(--vscode-quickInputList-focusForeground);\n\toutline: 1px solid var(--vscode-menu-selectionBorder, transparent);\n\toutline-offset: -1px;\n}\n\n.action-widget .monaco-list-row.group-header {\n\tcolor: var(--vscode-descriptionForeground) !important;\n\tfont-weight: 600;\n}\n\n.action-widget .monaco-list .group-header,\n.action-widget .monaco-list .option-disabled,\n.action-widget .monaco-list .option-disabled:before,\n.action-widget .monaco-list .option-disabled .focused,\n.action-widget .monaco-list .option-disabled .focused:before {\n\tcursor: default !important;\n\t-webkit-touch-callout: none;\n\t-webkit-user-select: none;\n\tuser-select: none;\n\tbackground-color: transparent !important;\n\toutline: 0 solid !important;\n}\n\n.action-widget .monaco-list-row.action {\n\tdisplay: flex;\n\tgap: 6px;\n\talign-items: center;\n}\n\n.action-widget .monaco-list-row.action.option-disabled,\n.action-widget .monaco-list:focus .monaco-list-row.focused.action.option-disabled,\n.action-widget .monaco-list-row.action.option-disabled .codicon,\n.action-widget .monaco-list:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused).option-disabled {\n\tcolor: var(--vscode-disabledForeground);\n}\n\n\n.action-widget .monaco-list-row.action:not(.option-disabled) .codicon {\n\tcolor: inherit;\n}\n\n.action-widget .monaco-list-row.action .title {\n\tflex: 1;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n}\n\n/* Action bar */\n\n.action-widget .action-widget-action-bar {\n\tbackground-color: var(--vscode-editorHoverWidget-statusBarBackground);\n\tborder-top: 1px solid var(--vscode-editorHoverWidget-border);\n}\n\n.action-widget .action-widget-action-bar::before {\n\tdisplay: block;\n\tcontent: \"\";\n\twidth: 100%;\n}\n\n.action-widget .action-widget-action-bar .actions-container {\n\tpadding: 0 8px;\n}\n\n.action-widget-action-bar .action-label {\n\tcolor: var(--vscode-textLink-activeForeground);\n\tfont-size: 12px;\n\tline-height: 22px;\n\tpadding: 0;\n\tpointer-events: all;\n}\n\n.action-widget-action-bar .action-item {\n\tmargin-right: 16px;\n\tpointer-events: none;\n}\n\n.action-widget-action-bar .action-label:hover {\n\tbackground-color: transparent !important;\n}\n\n.monaco-action-bar .actions-container.highlight-toggled .action-label.checked {\n\t/* The important gives this rule precedence over the hover rule. */\n\tbackground: var(--vscode-actionBar-toggledBackground) !important;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-action-bar .action-item.menu-entry .action-label.icon { + width: 16px; + height: 16px; + background-repeat: no-repeat; + background-position: 50%; + background-size: 16px; +} + +.monaco-dropdown-with-default { + display: flex !important; + flex-direction: row; + border-radius: 5px; +} + +.monaco-dropdown-with-default > .action-container > .action-label { + margin-right: 0; +} + +.monaco-dropdown-with-default > .action-container.menu-entry > .action-label.icon { + width: 16px; + height: 16px; + background-repeat: no-repeat; + background-position: 50%; + background-size: 16px; +} + +.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*='codicon-'] { + font-size: 12px; + padding-left: 0px; + padding-right: 0px; + line-height: 16px; + margin-left: -3px; +} + +.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label { + display: block; + background-size: 16px; + background-position: center center; + background-repeat: no-repeat; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,WAAW;CACX,YAAY;CACZ,4BAA4B;CAC5B,wBAAwB;CACxB,qBAAqB;AACtB;;AAEA;CACC,wBAAwB;CACxB,mBAAmB;CACnB,kBAAkB;AACnB;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,WAAW;CACX,YAAY;CACZ,4BAA4B;CAC5B,wBAAwB;CACxB,qBAAqB;AACtB;;AAEA;CACC,eAAe;CACf,iBAAiB;CACjB,kBAAkB;CAClB,iBAAiB;CACjB,iBAAiB;AAClB;;AAEA;CACC,cAAc;CACd,qBAAqB;CACrB,kCAAkC;CAClC,4BAA4B;AAC7B","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-action-bar .action-item.menu-entry .action-label.icon {\n\twidth: 16px;\n\theight: 16px;\n\tbackground-repeat: no-repeat;\n\tbackground-position: 50%;\n\tbackground-size: 16px;\n}\n\n.monaco-dropdown-with-default {\n\tdisplay: flex !important;\n\tflex-direction: row;\n\tborder-radius: 5px;\n}\n\n.monaco-dropdown-with-default > .action-container > .action-label {\n\tmargin-right: 0;\n}\n\n.monaco-dropdown-with-default > .action-container.menu-entry > .action-label.icon {\n\twidth: 16px;\n\theight: 16px;\n\tbackground-repeat: no-repeat;\n\tbackground-position: 50%;\n\tbackground-size: 16px;\n}\n\n.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*='codicon-'] {\n\tfont-size: 12px;\n\tpadding-left: 0px;\n\tpadding-right: 0px;\n\tline-height: 16px;\n\tmargin-left: -3px;\n}\n\n.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label {\n\tdisplay: block;\n\tbackground-size: 16px;\n\tbackground-position: center center;\n\tbackground-repeat: no-repeat;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/opener/browser/link.css": +/*!******************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/opener/browser/link.css ***! + \******************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-link { + color: var(--vscode-textLink-foreground); +} + +.monaco-link:hover { + color: var(--vscode-textLink-activeForeground); +} + +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/platform/opener/browser/link.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,wCAAwC;AACzC;;AAEA;CACC,8CAA8C;AAC/C","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-link {\n\tcolor: var(--vscode-textLink-foreground);\n}\n\n.monaco-link:hover {\n\tcolor: var(--vscode-textLink-activeForeground);\n}\n\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/quickinput/browser/media/quickInput.css": +/*!**********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/quickinput/browser/media/quickInput.css ***! + \**********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.quick-input-widget { + position: absolute; + width: 600px; + z-index: 2550; + left: 50%; + margin-left: -300px; + -webkit-app-region: no-drag; + border-radius: 6px; +} + +.quick-input-titlebar { + display: flex; + align-items: center; + border-top-left-radius: 5px; /* match border radius of quick input widget */ + border-top-right-radius: 5px; +} + +.quick-input-left-action-bar { + display: flex; + margin-left: 4px; + flex: 1; +} + +.quick-input-title { + padding: 3px 0px; + text-align: center; + text-overflow: ellipsis; + overflow: hidden; +} + +.quick-input-right-action-bar { + display: flex; + margin-right: 4px; + flex: 1; +} + +.quick-input-right-action-bar > .actions-container { + justify-content: flex-end; +} + +.quick-input-titlebar .monaco-action-bar .action-label.codicon { + background-position: center; + background-repeat: no-repeat; + padding: 2px; +} + +.quick-input-description { + margin: 6px 6px 6px 11px; +} + +.quick-input-header .quick-input-description { + margin: 4px 2px; + flex: 1; +} + +.quick-input-header { + display: flex; + padding: 8px 6px 6px 6px; +} + +.quick-input-widget.hidden-input .quick-input-header { + /* reduce margins and paddings when input box hidden */ + padding: 0; + margin-bottom: 0; +} + +.quick-input-and-message { + display: flex; + flex-direction: column; + flex-grow: 1; + min-width: 0; + position: relative; +} + +.quick-input-check-all { + align-self: center; + margin: 0; +} + +.quick-input-filter { + flex-grow: 1; + display: flex; + position: relative; +} + +.quick-input-box { + flex-grow: 1; +} + +.quick-input-widget.show-checkboxes .quick-input-box, +.quick-input-widget.show-checkboxes .quick-input-message { + margin-left: 5px; +} + +.quick-input-visible-count { + position: absolute; + left: -10000px; +} + +.quick-input-count { + align-self: center; + position: absolute; + right: 4px; + display: flex; + align-items: center; +} + +.quick-input-count .monaco-count-badge { + vertical-align: middle; + padding: 2px 4px; + border-radius: 2px; + min-height: auto; + line-height: normal; +} + +.quick-input-action { + margin-left: 6px; +} + +.quick-input-action .monaco-text-button { + font-size: 11px; + padding: 0 6px; + display: flex; + height: 25px; + align-items: center; +} + +.quick-input-message { + margin-top: -1px; + padding: 5px; + overflow-wrap: break-word; +} + +.quick-input-message > .codicon { + margin: 0 0.2em; + vertical-align: text-bottom; +} + +/* Links in descriptions & validations */ +.quick-input-message a { + color: inherit; +} + +.quick-input-progress.monaco-progress-container { + position: relative; +} + +.quick-input-list { + line-height: 22px; +} + +.quick-input-widget.hidden-input .quick-input-list { + margin-top: 4px; /* reduce margins when input box hidden */ + padding-bottom: 4px; +} + +.quick-input-list .monaco-list { + overflow: hidden; + max-height: calc(20 * 22px); + padding-bottom: 5px; +} + +.quick-input-list .monaco-scrollable-element { + padding: 0px 5px; +} + +.quick-input-list .quick-input-list-entry { + box-sizing: border-box; + overflow: hidden; + display: flex; + height: 100%; + padding: 0 6px; +} + +.quick-input-list .quick-input-list-entry.quick-input-list-separator-border { + border-top-width: 1px; + border-top-style: solid; +} + +.quick-input-list .monaco-list-row { + border-radius: 3px; +} + +.quick-input-list .monaco-list-row[data-index="0"] .quick-input-list-entry.quick-input-list-separator-border { + border-top-style: none; +} + +.quick-input-list .quick-input-list-label { + overflow: hidden; + display: flex; + height: 100%; + flex: 1; +} + +.quick-input-list .quick-input-list-checkbox { + align-self: center; + margin: 0; +} + +.quick-input-list .quick-input-list-icon { + background-size: 16px; + background-position: left center; + background-repeat: no-repeat; + padding-right: 6px; + width: 16px; + height: 22px; + display: flex; + align-items: center; + justify-content: center; +} + +.quick-input-list .quick-input-list-rows { + overflow: hidden; + text-overflow: ellipsis; + display: flex; + flex-direction: column; + height: 100%; + flex: 1; + margin-left: 5px; +} + +.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-rows { + margin-left: 10px; +} + +.quick-input-widget .quick-input-list .quick-input-list-checkbox { + display: none; +} +.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-checkbox { + display: inline; +} + +.quick-input-list .quick-input-list-rows > .quick-input-list-row { + display: flex; + align-items: center; +} + +.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label, +.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label .monaco-icon-label-container > .monaco-icon-name-container { + flex: 1; /* make sure the icon label grows within the row */ +} + +.quick-input-list .quick-input-list-rows > .quick-input-list-row .codicon[class*='codicon-'] { + vertical-align: text-bottom; +} + +.quick-input-list .quick-input-list-rows .monaco-highlighted-label > span { + opacity: 1; +} + +.quick-input-list .quick-input-list-entry .quick-input-list-entry-keybinding { + margin-right: 8px; /* separate from the separator label or scrollbar if any */ +} + +.quick-input-list .quick-input-list-label-meta { + opacity: 0.7; + line-height: normal; + text-overflow: ellipsis; + overflow: hidden; +} + +.quick-input-list .monaco-highlighted-label .highlight { + font-weight: bold; +} + +.quick-input-list .quick-input-list-entry .quick-input-list-separator { + margin-right: 4px; /* separate from keybindings or actions */ +} + +.quick-input-list .quick-input-list-entry-action-bar { + display: flex; + flex: 0; + overflow: visible; +} + +.quick-input-list .quick-input-list-entry-action-bar .action-label { + /* + * By default, actions in the quick input action bar are hidden + * until hovered over them or selected. + */ + display: none; +} + +.quick-input-list .quick-input-list-entry-action-bar .action-label.codicon { + margin-right: 4px; + padding: 0px 2px 2px 2px; +} + +.quick-input-list .quick-input-list-entry-action-bar { + margin-top: 1px; +} + +.quick-input-list .quick-input-list-entry-action-bar { + margin-right: 4px; /* separate from scrollbar */ +} + +.quick-input-list .quick-input-list-entry .quick-input-list-entry-action-bar .action-label.always-visible, +.quick-input-list .quick-input-list-entry:hover .quick-input-list-entry-action-bar .action-label, +.quick-input-list .monaco-list-row.focused .quick-input-list-entry-action-bar .action-label { + display: flex; +} + +/* focused items in quick pick */ +.quick-input-list .monaco-list-row.focused .monaco-keybinding-key, +.quick-input-list .monaco-list-row.focused .quick-input-list-entry .quick-input-list-separator { + color: inherit +} +.quick-input-list .monaco-list-row.focused .monaco-keybinding-key { + background: none; +} + +/* Quick input separators as full-row item */ +.quick-input-list .quick-input-list-separator-as-item { + font-weight: 600; + font-size: 12px; +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/platform/quickinput/browser/media/quickInput.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;CACC,kBAAkB;CAClB,YAAY;CACZ,aAAa;CACb,SAAS;CACT,mBAAmB;CACnB,2BAA2B;CAC3B,kBAAkB;AACnB;;AAEA;CACC,aAAa;CACb,mBAAmB;CACnB,2BAA2B,EAAE,8CAA8C;CAC3E,4BAA4B;AAC7B;;AAEA;CACC,aAAa;CACb,gBAAgB;CAChB,OAAO;AACR;;AAEA;CACC,gBAAgB;CAChB,kBAAkB;CAClB,uBAAuB;CACvB,gBAAgB;AACjB;;AAEA;CACC,aAAa;CACb,iBAAiB;CACjB,OAAO;AACR;;AAEA;CACC,yBAAyB;AAC1B;;AAEA;CACC,2BAA2B;CAC3B,4BAA4B;CAC5B,YAAY;AACb;;AAEA;CACC,wBAAwB;AACzB;;AAEA;CACC,eAAe;CACf,OAAO;AACR;;AAEA;CACC,aAAa;CACb,wBAAwB;AACzB;;AAEA;CACC,sDAAsD;CACtD,UAAU;CACV,gBAAgB;AACjB;;AAEA;CACC,aAAa;CACb,sBAAsB;CACtB,YAAY;CACZ,YAAY;CACZ,kBAAkB;AACnB;;AAEA;CACC,kBAAkB;CAClB,SAAS;AACV;;AAEA;CACC,YAAY;CACZ,aAAa;CACb,kBAAkB;AACnB;;AAEA;CACC,YAAY;AACb;;AAEA;;CAEC,gBAAgB;AACjB;;AAEA;CACC,kBAAkB;CAClB,cAAc;AACf;;AAEA;CACC,kBAAkB;CAClB,kBAAkB;CAClB,UAAU;CACV,aAAa;CACb,mBAAmB;AACpB;;AAEA;CACC,sBAAsB;CACtB,gBAAgB;CAChB,kBAAkB;CAClB,gBAAgB;CAChB,mBAAmB;AACpB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,eAAe;CACf,cAAc;CACd,aAAa;CACb,YAAY;CACZ,mBAAmB;AACpB;;AAEA;CACC,gBAAgB;CAChB,YAAY;CACZ,yBAAyB;AAC1B;;AAEA;CACC,eAAe;CACf,2BAA2B;AAC5B;;AAEA,wCAAwC;AACxC;CACC,cAAc;AACf;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,iBAAiB;AAClB;;AAEA;CACC,eAAe,EAAE,yCAAyC;CAC1D,mBAAmB;AACpB;;AAEA;CACC,gBAAgB;CAChB,2BAA2B;CAC3B,mBAAmB;AACpB;;AAEA;CACC,gBAAgB;AACjB;;AAEA;CACC,sBAAsB;CACtB,gBAAgB;CAChB,aAAa;CACb,YAAY;CACZ,cAAc;AACf;;AAEA;CACC,qBAAqB;CACrB,uBAAuB;AACxB;;AAEA;CACC,kBAAkB;AACnB;;AAEA;CACC,sBAAsB;AACvB;;AAEA;CACC,gBAAgB;CAChB,aAAa;CACb,YAAY;CACZ,OAAO;AACR;;AAEA;CACC,kBAAkB;CAClB,SAAS;AACV;;AAEA;CACC,qBAAqB;CACrB,gCAAgC;CAChC,4BAA4B;CAC5B,kBAAkB;CAClB,WAAW;CACX,YAAY;CACZ,aAAa;CACb,mBAAmB;CACnB,uBAAuB;AACxB;;AAEA;CACC,gBAAgB;CAChB,uBAAuB;CACvB,aAAa;CACb,sBAAsB;CACtB,YAAY;CACZ,OAAO;CACP,gBAAgB;AACjB;;AAEA;CACC,iBAAiB;AAClB;;AAEA;CACC,aAAa;AACd;AACA;CACC,eAAe;AAChB;;AAEA;CACC,aAAa;CACb,mBAAmB;AACpB;;AAEA;;CAEC,OAAO,EAAE,kDAAkD;AAC5D;;AAEA;CACC,2BAA2B;AAC5B;;AAEA;CACC,UAAU;AACX;;AAEA;CACC,iBAAiB,EAAE,0DAA0D;AAC9E;;AAEA;CACC,YAAY;CACZ,mBAAmB;CACnB,uBAAuB;CACvB,gBAAgB;AACjB;;AAEA;CACC,iBAAiB;AAClB;;AAEA;CACC,iBAAiB,EAAE,yCAAyC;AAC7D;;AAEA;CACC,aAAa;CACb,OAAO;CACP,iBAAiB;AAClB;;AAEA;CACC;;;GAGE;CACF,aAAa;AACd;;AAEA;CACC,iBAAiB;CACjB,wBAAwB;AACzB;;AAEA;CACC,eAAe;AAChB;;AAEA;CACC,iBAAiB,EAAE,4BAA4B;AAChD;;AAEA;;;CAGC,aAAa;AACd;;AAEA,gCAAgC;AAChC;;CAEC;AACD;AACA;CACC,gBAAgB;AACjB;;AAEA,4CAA4C;AAC5C;CACC,gBAAgB;CAChB,eAAe;AAChB","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.quick-input-widget {\n\tposition: absolute;\n\twidth: 600px;\n\tz-index: 2550;\n\tleft: 50%;\n\tmargin-left: -300px;\n\t-webkit-app-region: no-drag;\n\tborder-radius: 6px;\n}\n\n.quick-input-titlebar {\n\tdisplay: flex;\n\talign-items: center;\n\tborder-top-left-radius: 5px; /* match border radius of quick input widget */\n\tborder-top-right-radius: 5px;\n}\n\n.quick-input-left-action-bar {\n\tdisplay: flex;\n\tmargin-left: 4px;\n\tflex: 1;\n}\n\n.quick-input-title {\n\tpadding: 3px 0px;\n\ttext-align: center;\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n}\n\n.quick-input-right-action-bar {\n\tdisplay: flex;\n\tmargin-right: 4px;\n\tflex: 1;\n}\n\n.quick-input-right-action-bar > .actions-container {\n\tjustify-content: flex-end;\n}\n\n.quick-input-titlebar .monaco-action-bar .action-label.codicon {\n\tbackground-position: center;\n\tbackground-repeat: no-repeat;\n\tpadding: 2px;\n}\n\n.quick-input-description {\n\tmargin: 6px 6px 6px 11px;\n}\n\n.quick-input-header .quick-input-description {\n\tmargin: 4px 2px;\n\tflex: 1;\n}\n\n.quick-input-header {\n\tdisplay: flex;\n\tpadding: 8px 6px 6px 6px;\n}\n\n.quick-input-widget.hidden-input .quick-input-header {\n\t/* reduce margins and paddings when input box hidden */\n\tpadding: 0;\n\tmargin-bottom: 0;\n}\n\n.quick-input-and-message {\n\tdisplay: flex;\n\tflex-direction: column;\n\tflex-grow: 1;\n\tmin-width: 0;\n\tposition: relative;\n}\n\n.quick-input-check-all {\n\talign-self: center;\n\tmargin: 0;\n}\n\n.quick-input-filter {\n\tflex-grow: 1;\n\tdisplay: flex;\n\tposition: relative;\n}\n\n.quick-input-box {\n\tflex-grow: 1;\n}\n\n.quick-input-widget.show-checkboxes .quick-input-box,\n.quick-input-widget.show-checkboxes .quick-input-message {\n\tmargin-left: 5px;\n}\n\n.quick-input-visible-count {\n\tposition: absolute;\n\tleft: -10000px;\n}\n\n.quick-input-count {\n\talign-self: center;\n\tposition: absolute;\n\tright: 4px;\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.quick-input-count .monaco-count-badge {\n\tvertical-align: middle;\n\tpadding: 2px 4px;\n\tborder-radius: 2px;\n\tmin-height: auto;\n\tline-height: normal;\n}\n\n.quick-input-action {\n\tmargin-left: 6px;\n}\n\n.quick-input-action .monaco-text-button {\n\tfont-size: 11px;\n\tpadding: 0 6px;\n\tdisplay: flex;\n\theight: 25px;\n\talign-items: center;\n}\n\n.quick-input-message {\n\tmargin-top: -1px;\n\tpadding: 5px;\n\toverflow-wrap: break-word;\n}\n\n.quick-input-message > .codicon {\n\tmargin: 0 0.2em;\n\tvertical-align: text-bottom;\n}\n\n/* Links in descriptions & validations */\n.quick-input-message a {\n\tcolor: inherit;\n}\n\n.quick-input-progress.monaco-progress-container {\n\tposition: relative;\n}\n\n.quick-input-list {\n\tline-height: 22px;\n}\n\n.quick-input-widget.hidden-input .quick-input-list {\n\tmargin-top: 4px; /* reduce margins when input box hidden */\n\tpadding-bottom: 4px;\n}\n\n.quick-input-list .monaco-list {\n\toverflow: hidden;\n\tmax-height: calc(20 * 22px);\n\tpadding-bottom: 5px;\n}\n\n.quick-input-list .monaco-scrollable-element {\n\tpadding: 0px 5px;\n}\n\n.quick-input-list .quick-input-list-entry {\n\tbox-sizing: border-box;\n\toverflow: hidden;\n\tdisplay: flex;\n\theight: 100%;\n\tpadding: 0 6px;\n}\n\n.quick-input-list .quick-input-list-entry.quick-input-list-separator-border {\n\tborder-top-width: 1px;\n\tborder-top-style: solid;\n}\n\n.quick-input-list .monaco-list-row {\n\tborder-radius: 3px;\n}\n\n.quick-input-list .monaco-list-row[data-index=\"0\"] .quick-input-list-entry.quick-input-list-separator-border {\n\tborder-top-style: none;\n}\n\n.quick-input-list .quick-input-list-label {\n\toverflow: hidden;\n\tdisplay: flex;\n\theight: 100%;\n\tflex: 1;\n}\n\n.quick-input-list .quick-input-list-checkbox {\n\talign-self: center;\n\tmargin: 0;\n}\n\n.quick-input-list .quick-input-list-icon {\n\tbackground-size: 16px;\n\tbackground-position: left center;\n\tbackground-repeat: no-repeat;\n\tpadding-right: 6px;\n\twidth: 16px;\n\theight: 22px;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n.quick-input-list .quick-input-list-rows {\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\tdisplay: flex;\n\tflex-direction: column;\n\theight: 100%;\n\tflex: 1;\n\tmargin-left: 5px;\n}\n\n.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-rows {\n\tmargin-left: 10px;\n}\n\n.quick-input-widget .quick-input-list .quick-input-list-checkbox {\n\tdisplay: none;\n}\n.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-checkbox {\n\tdisplay: inline;\n}\n\n.quick-input-list .quick-input-list-rows > .quick-input-list-row {\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label,\n.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label .monaco-icon-label-container > .monaco-icon-name-container {\n\tflex: 1; /* make sure the icon label grows within the row */\n}\n\n.quick-input-list .quick-input-list-rows > .quick-input-list-row .codicon[class*='codicon-'] {\n\tvertical-align: text-bottom;\n}\n\n.quick-input-list .quick-input-list-rows .monaco-highlighted-label > span {\n\topacity: 1;\n}\n\n.quick-input-list .quick-input-list-entry .quick-input-list-entry-keybinding {\n\tmargin-right: 8px; /* separate from the separator label or scrollbar if any */\n}\n\n.quick-input-list .quick-input-list-label-meta {\n\topacity: 0.7;\n\tline-height: normal;\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n}\n\n.quick-input-list .monaco-highlighted-label .highlight {\n\tfont-weight: bold;\n}\n\n.quick-input-list .quick-input-list-entry .quick-input-list-separator {\n\tmargin-right: 4px; /* separate from keybindings or actions */\n}\n\n.quick-input-list .quick-input-list-entry-action-bar {\n\tdisplay: flex;\n\tflex: 0;\n\toverflow: visible;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar .action-label {\n\t/*\n\t * By default, actions in the quick input action bar are hidden\n\t * until hovered over them or selected.\n\t */\n\tdisplay: none;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar .action-label.codicon {\n\tmargin-right: 4px;\n\tpadding: 0px 2px 2px 2px;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar {\n\tmargin-top: 1px;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar {\n\tmargin-right: 4px; /* separate from scrollbar */\n}\n\n.quick-input-list .quick-input-list-entry .quick-input-list-entry-action-bar .action-label.always-visible,\n.quick-input-list .quick-input-list-entry:hover .quick-input-list-entry-action-bar .action-label,\n.quick-input-list .monaco-list-row.focused .quick-input-list-entry-action-bar .action-label {\n\tdisplay: flex;\n}\n\n/* focused items in quick pick */\n.quick-input-list .monaco-list-row.focused .monaco-keybinding-key,\n.quick-input-list .monaco-list-row.focused .quick-input-list-entry .quick-input-list-separator {\n\tcolor: inherit\n}\n.quick-input-list .monaco-list-row.focused .monaco-keybinding-key {\n\tbackground: none;\n}\n\n/* Quick input separators as full-row item */\n.quick-input-list .quick-input-list-separator-as-item {\n\tfont-weight: 600;\n\tfont-size: 12px;\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/severityIcon/browser/media/severityIcon.css": +/*!**************************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/monaco-editor/esm/vs/platform/severityIcon/browser/media/severityIcon.css ***! + \**************************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../../../../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +// Imports + + +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +.monaco-editor .zone-widget .codicon.codicon-error, +.markers-panel .marker-icon.error, .markers-panel .marker-icon .codicon.codicon-error, +.text-search-provider-messages .providerMessage .codicon.codicon-error, +.extensions-viewlet > .extensions .codicon.codicon-error, +.extension-editor .codicon.codicon-error, +.preferences-editor .codicon.codicon-error { + color: var(--vscode-problemsErrorIcon-foreground); +} + +.monaco-editor .zone-widget .codicon.codicon-warning, +.markers-panel .marker-icon.warning, .markers-panel .marker-icon .codicon.codicon-warning, +.text-search-provider-messages .providerMessage .codicon.codicon-warning, +.extensions-viewlet > .extensions .codicon.codicon-warning, +.extension-editor .codicon.codicon-warning, +.preferences-editor .codicon.codicon-warning { + color: var(--vscode-problemsWarningIcon-foreground); +} + +.monaco-editor .zone-widget .codicon.codicon-info, +.markers-panel .marker-icon.info, .markers-panel .marker-icon .codicon.codicon-info, +.text-search-provider-messages .providerMessage .codicon.codicon-info, +.extensions-viewlet > .extensions .codicon.codicon-info, +.extension-editor .codicon.codicon-info, +.preferences-editor .codicon.codicon-info { + color: var(--vscode-problemsInfoIcon-foreground); +} +`, "",{"version":3,"sources":["webpack://./node_modules/monaco-editor/esm/vs/platform/severityIcon/browser/media/severityIcon.css"],"names":[],"mappings":"AAAA;;;+FAG+F;;AAE/F;;;;;;CAMC,iDAAiD;AAClD;;AAEA;;;;;;CAMC,mDAAmD;AACpD;;AAEA;;;;;;CAMC,gDAAgD;AACjD","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .zone-widget .codicon.codicon-error,\n.markers-panel .marker-icon.error, .markers-panel .marker-icon .codicon.codicon-error,\n.text-search-provider-messages .providerMessage .codicon.codicon-error,\n.extensions-viewlet > .extensions .codicon.codicon-error,\n.extension-editor .codicon.codicon-error,\n.preferences-editor .codicon.codicon-error {\n\tcolor: var(--vscode-problemsErrorIcon-foreground);\n}\n\n.monaco-editor .zone-widget .codicon.codicon-warning,\n.markers-panel .marker-icon.warning, .markers-panel .marker-icon .codicon.codicon-warning,\n.text-search-provider-messages .providerMessage .codicon.codicon-warning,\n.extensions-viewlet > .extensions .codicon.codicon-warning,\n.extension-editor .codicon.codicon-warning,\n.preferences-editor .codicon.codicon-warning {\n\tcolor: var(--vscode-problemsWarningIcon-foreground);\n}\n\n.monaco-editor .zone-widget .codicon.codicon-info,\n.markers-panel .marker-icon.info, .markers-panel .marker-icon .codicon.codicon-info,\n.text-search-provider-messages .providerMessage .codicon.codicon-info,\n.extensions-viewlet > .extensions .codicon.codicon-info,\n.extension-editor .codicon.codicon-info,\n.preferences-editor .codicon.codicon-info {\n\tcolor: var(--vscode-problemsInfoIcon-foreground);\n}\n"],"sourceRoot":""}]); +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___); + + +/***/ }), + +/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./node_modules/bootstrap/scss/bootstrap.scss": +/*!*********************************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./node_modules/bootstrap/scss/bootstrap.scss ***! + \*********************************************************************************************************************************/ +/***/ ((module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js"); +/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); +/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../css-loader/dist/runtime/getUrl.js */ "./node_modules/css-loader/dist/runtime/getUrl.js"); +/* harmony import */ var _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__); +// Imports + + + +var ___CSS_LOADER_URL_IMPORT_0___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath fill=%27%2328a745%27 d=%27M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath fill=%27%2328a745%27 d=%27M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_1___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%274%27 height=%275%27 viewBox=%270 0 4 5%27%3e%3cpath fill=%27%23343a40%27 d=%27M2 0L0 2h4zm0 5L0 3h4z%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%274%27 height=%275%27 viewBox=%270 0 4 5%27%3e%3cpath fill=%27%23343a40%27 d=%27M2 0L0 2h4zm0 5L0 3h4z%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_2___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2712%27 height=%2712%27 fill=%27none%27 stroke=%27%23dc3545%27 viewBox=%270 0 12 12%27%3e%3ccircle cx=%276%27 cy=%276%27 r=%274.5%27/%3e%3cpath stroke-linejoin=%27round%27 d=%27M5.8 3.6h.4L6 6.5z%27/%3e%3ccircle cx=%276%27 cy=%278.2%27 r=%27.6%27 fill=%27%23dc3545%27 stroke=%27none%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2712%27 height=%2712%27 fill=%27none%27 stroke=%27%23dc3545%27 viewBox=%270 0 12 12%27%3e%3ccircle cx=%276%27 cy=%276%27 r=%274.5%27/%3e%3cpath stroke-linejoin=%27round%27 d=%27M5.8 3.6h.4L6 6.5z%27/%3e%3ccircle cx=%276%27 cy=%278.2%27 r=%27.6%27 fill=%27%23dc3545%27 stroke=%27none%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_3___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath fill=%27%23fff%27 d=%27M6.564.75l-3.59 3.612-1.538-1.55L0 4.26l2.974 2.99L8 2.193z%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath fill=%27%23fff%27 d=%27M6.564.75l-3.59 3.612-1.538-1.55L0 4.26l2.974 2.99L8 2.193z%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_4___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%274%27 height=%274%27 viewBox=%270 0 4 4%27%3e%3cpath stroke=%27%23fff%27 d=%27M0 2h4%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%274%27 height=%274%27 viewBox=%270 0 4 4%27%3e%3cpath stroke=%27%23fff%27 d=%27M0 2h4%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_5___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2712%27 height=%2712%27 viewBox=%27-4 -4 8 8%27%3e%3ccircle r=%273%27 fill=%27%23fff%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2712%27 height=%2712%27 viewBox=%27-4 -4 8 8%27%3e%3ccircle r=%273%27 fill=%27%23fff%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_6___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2730%27 height=%2730%27 viewBox=%270 0 30 30%27%3e%3cpath stroke=%27rgba%280, 0, 0, 0.5%29%27 stroke-linecap=%27round%27 stroke-miterlimit=%2710%27 stroke-width=%272%27 d=%27M4 7h22M4 15h22M4 23h22%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2730%27 height=%2730%27 viewBox=%270 0 30 30%27%3e%3cpath stroke=%27rgba%280, 0, 0, 0.5%29%27 stroke-linecap=%27round%27 stroke-miterlimit=%2710%27 stroke-width=%272%27 d=%27M4 7h22M4 15h22M4 23h22%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_7___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2730%27 height=%2730%27 viewBox=%270 0 30 30%27%3e%3cpath stroke=%27rgba%28255, 255, 255, 0.5%29%27 stroke-linecap=%27round%27 stroke-miterlimit=%2710%27 stroke-width=%272%27 d=%27M4 7h22M4 15h22M4 23h22%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 width=%2730%27 height=%2730%27 viewBox=%270 0 30 30%27%3e%3cpath stroke=%27rgba%28255, 255, 255, 0.5%29%27 stroke-linecap=%27round%27 stroke-miterlimit=%2710%27 stroke-width=%272%27 d=%27M4 7h22M4 15h22M4 23h22%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_8___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 fill=%27%23fff%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath d=%27M5.25 0l-4 4 4 4 1.5-1.5L4.25 4l2.5-2.5L5.25 0z%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 fill=%27%23fff%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath d=%27M5.25 0l-4 4 4 4 1.5-1.5L4.25 4l2.5-2.5L5.25 0z%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_URL_IMPORT_9___ = new URL(/* asset import */ __webpack_require__(/*! data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 fill=%27%23fff%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath d=%27M2.75 0l-1.5 1.5L3.75 4l-2.5 2.5L2.75 8l4-4-4-4z%27/%3e%3c/svg%3e */ "data:image/svg+xml,%3csvg xmlns=%27http://www.w3.org/2000/svg%27 fill=%27%23fff%27 width=%278%27 height=%278%27 viewBox=%270 0 8 8%27%3e%3cpath d=%27M2.75 0l-1.5 1.5L3.75 4l-2.5 2.5L2.75 8l4-4-4-4z%27/%3e%3c/svg%3e"), __webpack_require__.b); +var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default())); +var ___CSS_LOADER_URL_REPLACEMENT_0___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_0___); +var ___CSS_LOADER_URL_REPLACEMENT_1___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_1___); +var ___CSS_LOADER_URL_REPLACEMENT_2___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_2___); +var ___CSS_LOADER_URL_REPLACEMENT_3___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_3___); +var ___CSS_LOADER_URL_REPLACEMENT_4___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_4___); +var ___CSS_LOADER_URL_REPLACEMENT_5___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_5___); +var ___CSS_LOADER_URL_REPLACEMENT_6___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_6___); +var ___CSS_LOADER_URL_REPLACEMENT_7___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_7___); +var ___CSS_LOADER_URL_REPLACEMENT_8___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_8___); +var ___CSS_LOADER_URL_REPLACEMENT_9___ = _css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_9___); +// Module +___CSS_LOADER_EXPORT___.push([module.id, `@charset "UTF-8"; +/*! + * Bootstrap v4.6.2 (https://getbootstrap.com/) + * Copyright 2011-2022 The Bootstrap Authors + * Copyright 2011-2022 Twitter, Inc. + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ +:root { + --blue: #007bff; + --indigo: #6610f2; + --purple: #6f42c1; + --pink: #e83e8c; + --red: #dc3545; + --orange: #fd7e14; + --yellow: #ffc107; + --green: #28a745; + --teal: #20c997; + --cyan: #17a2b8; + --white: #fff; + --gray: #6c757d; + --gray-dark: #343a40; + --primary: #007bff; + --secondary: #6c757d; + --success: #28a745; + --info: #17a2b8; + --warning: #ffc107; + --danger: #dc3545; + --light: #f8f9fa; + --dark: #343a40; + --breakpoint-xs: 0; + --breakpoint-sm: 576px; + --breakpoint-md: 768px; + --breakpoint-lg: 992px; + --breakpoint-xl: 1200px; + --font-family-sans-serif: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; + --font-family-monospace: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; +} + +*, +*::before, +*::after { + box-sizing: border-box; +} + +html { + font-family: sans-serif; + line-height: 1.15; + -webkit-text-size-adjust: 100%; + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); +} + +article, aside, figcaption, figure, footer, header, hgroup, main, nav, section { + display: block; +} + +body { + margin: 0; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; + font-size: 1rem; + font-weight: 400; + line-height: 1.5; + color: #212529; + text-align: left; + background-color: #fff; +} + +[tabindex="-1"]:focus:not(:focus-visible) { + outline: 0 !important; +} + +hr { + box-sizing: content-box; + height: 0; + overflow: visible; +} + +h1, h2, h3, h4, h5, h6 { + margin-top: 0; + margin-bottom: 0.5rem; +} + +p { + margin-top: 0; + margin-bottom: 1rem; +} + +abbr[title], +abbr[data-original-title] { + text-decoration: underline; + text-decoration: underline dotted; + cursor: help; + border-bottom: 0; + text-decoration-skip-ink: none; +} + +address { + margin-bottom: 1rem; + font-style: normal; + line-height: inherit; +} + +ol, +ul, +dl { + margin-top: 0; + margin-bottom: 1rem; +} + +ol ol, +ul ul, +ol ul, +ul ol { + margin-bottom: 0; +} + +dt { + font-weight: 700; +} + +dd { + margin-bottom: 0.5rem; + margin-left: 0; +} + +blockquote { + margin: 0 0 1rem; +} + +b, +strong { + font-weight: bolder; +} + +small { + font-size: 80%; +} + +sub, +sup { + position: relative; + font-size: 75%; + line-height: 0; + vertical-align: baseline; +} + +sub { + bottom: -0.25em; +} + +sup { + top: -0.5em; +} + +a { + color: #007bff; + text-decoration: none; + background-color: transparent; +} +a:hover { + color: #0056b3; + text-decoration: underline; +} + +a:not([href]):not([class]) { + color: inherit; + text-decoration: none; +} +a:not([href]):not([class]):hover { + color: inherit; + text-decoration: none; +} + +pre, +code, +kbd, +samp { + font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; + font-size: 1em; +} + +pre { + margin-top: 0; + margin-bottom: 1rem; + overflow: auto; + -ms-overflow-style: scrollbar; +} + +figure { + margin: 0 0 1rem; +} + +img { + vertical-align: middle; + border-style: none; +} + +svg { + overflow: hidden; + vertical-align: middle; +} + +table { + border-collapse: collapse; +} + +caption { + padding-top: 0.75rem; + padding-bottom: 0.75rem; + color: #6c757d; + text-align: left; + caption-side: bottom; +} + +th { + text-align: inherit; + text-align: -webkit-match-parent; +} + +label { + display: inline-block; + margin-bottom: 0.5rem; +} + +button { + border-radius: 0; +} + +button:focus:not(:focus-visible) { + outline: 0; +} + +input, +button, +select, +optgroup, +textarea { + margin: 0; + font-family: inherit; + font-size: inherit; + line-height: inherit; +} + +button, +input { + overflow: visible; +} + +button, +select { + text-transform: none; +} + +[role=button] { + cursor: pointer; +} + +select { + word-wrap: normal; +} + +button, +[type=button], +[type=reset], +[type=submit] { + -webkit-appearance: button; +} + +button:not(:disabled), +[type=button]:not(:disabled), +[type=reset]:not(:disabled), +[type=submit]:not(:disabled) { + cursor: pointer; +} + +button::-moz-focus-inner, +[type=button]::-moz-focus-inner, +[type=reset]::-moz-focus-inner, +[type=submit]::-moz-focus-inner { + padding: 0; + border-style: none; +} + +input[type=radio], +input[type=checkbox] { + box-sizing: border-box; + padding: 0; +} + +textarea { + overflow: auto; + resize: vertical; +} + +fieldset { + min-width: 0; + padding: 0; + margin: 0; + border: 0; +} + +legend { + display: block; + width: 100%; + max-width: 100%; + padding: 0; + margin-bottom: 0.5rem; + font-size: 1.5rem; + line-height: inherit; + color: inherit; + white-space: normal; +} + +progress { + vertical-align: baseline; +} + +[type=number]::-webkit-inner-spin-button, +[type=number]::-webkit-outer-spin-button { + height: auto; +} + +[type=search] { + outline-offset: -2px; + -webkit-appearance: none; +} + +[type=search]::-webkit-search-decoration { + -webkit-appearance: none; +} + +::-webkit-file-upload-button { + font: inherit; + -webkit-appearance: button; +} + +output { + display: inline-block; +} + +summary { + display: list-item; + cursor: pointer; +} + +template { + display: none; +} + +[hidden] { + display: none !important; +} + +h1, h2, h3, h4, h5, h6, +.h1, .h2, .h3, .h4, .h5, .h6 { + margin-bottom: 0.5rem; + font-weight: 500; + line-height: 1.2; +} + +h1, .h1 { + font-size: 2.5rem; +} + +h2, .h2 { + font-size: 2rem; +} + +h3, .h3 { + font-size: 1.75rem; +} + +h4, .h4 { + font-size: 1.5rem; +} + +h5, .h5 { + font-size: 1.25rem; +} + +h6, .h6 { + font-size: 1rem; +} + +.lead { + font-size: 1.25rem; + font-weight: 300; +} + +.display-1 { + font-size: 6rem; + font-weight: 300; + line-height: 1.2; +} + +.display-2 { + font-size: 5.5rem; + font-weight: 300; + line-height: 1.2; +} + +.display-3 { + font-size: 4.5rem; + font-weight: 300; + line-height: 1.2; +} + +.display-4 { + font-size: 3.5rem; + font-weight: 300; + line-height: 1.2; +} + +hr { + margin-top: 1rem; + margin-bottom: 1rem; + border: 0; + border-top: 1px solid rgba(0, 0, 0, 0.1); +} + +small, +.small { + font-size: 0.875em; + font-weight: 400; +} + +mark, +.mark { + padding: 0.2em; + background-color: #fcf8e3; +} + +.list-unstyled { + padding-left: 0; + list-style: none; +} + +.list-inline { + padding-left: 0; + list-style: none; +} + +.list-inline-item { + display: inline-block; +} +.list-inline-item:not(:last-child) { + margin-right: 0.5rem; +} + +.initialism { + font-size: 90%; + text-transform: uppercase; +} + +.blockquote { + margin-bottom: 1rem; + font-size: 1.25rem; +} + +.blockquote-footer { + display: block; + font-size: 0.875em; + color: #6c757d; +} +.blockquote-footer::before { + content: "— "; +} + +.img-fluid { + max-width: 100%; + height: auto; +} + +.img-thumbnail { + padding: 0.25rem; + background-color: #fff; + border: 1px solid #dee2e6; + border-radius: 0.25rem; + max-width: 100%; + height: auto; +} + +.figure { + display: inline-block; +} + +.figure-img { + margin-bottom: 0.5rem; + line-height: 1; +} + +.figure-caption { + font-size: 90%; + color: #6c757d; +} + +code { + font-size: 87.5%; + color: #e83e8c; + word-wrap: break-word; +} +a > code { + color: inherit; +} + +kbd { + padding: 0.2rem 0.4rem; + font-size: 87.5%; + color: #fff; + background-color: #212529; + border-radius: 0.2rem; +} +kbd kbd { + padding: 0; + font-size: 100%; + font-weight: 700; +} + +pre { + display: block; + font-size: 87.5%; + color: #212529; +} +pre code { + font-size: inherit; + color: inherit; + word-break: normal; +} + +.pre-scrollable { + max-height: 340px; + overflow-y: scroll; +} + +.container, +.container-fluid, +.container-xl, +.container-lg, +.container-md, +.container-sm { + width: 100%; + padding-right: 15px; + padding-left: 15px; + margin-right: auto; + margin-left: auto; +} + +@media (min-width: 576px) { + .container-sm, .container { + max-width: 540px; + } +} +@media (min-width: 768px) { + .container-md, .container-sm, .container { + max-width: 720px; + } +} +@media (min-width: 992px) { + .container-lg, .container-md, .container-sm, .container { + max-width: 960px; + } +} +@media (min-width: 1200px) { + .container-xl, .container-lg, .container-md, .container-sm, .container { + max-width: 1140px; + } +} +.row { + display: flex; + flex-wrap: wrap; + margin-right: -15px; + margin-left: -15px; +} + +.no-gutters { + margin-right: 0; + margin-left: 0; +} +.no-gutters > .col, +.no-gutters > [class*=col-] { + padding-right: 0; + padding-left: 0; +} + +.col-xl, +.col-xl-auto, .col-xl-12, .col-xl-11, .col-xl-10, .col-xl-9, .col-xl-8, .col-xl-7, .col-xl-6, .col-xl-5, .col-xl-4, .col-xl-3, .col-xl-2, .col-xl-1, .col-lg, +.col-lg-auto, .col-lg-12, .col-lg-11, .col-lg-10, .col-lg-9, .col-lg-8, .col-lg-7, .col-lg-6, .col-lg-5, .col-lg-4, .col-lg-3, .col-lg-2, .col-lg-1, .col-md, +.col-md-auto, .col-md-12, .col-md-11, .col-md-10, .col-md-9, .col-md-8, .col-md-7, .col-md-6, .col-md-5, .col-md-4, .col-md-3, .col-md-2, .col-md-1, .col-sm, +.col-sm-auto, .col-sm-12, .col-sm-11, .col-sm-10, .col-sm-9, .col-sm-8, .col-sm-7, .col-sm-6, .col-sm-5, .col-sm-4, .col-sm-3, .col-sm-2, .col-sm-1, .col, +.col-auto, .col-12, .col-11, .col-10, .col-9, .col-8, .col-7, .col-6, .col-5, .col-4, .col-3, .col-2, .col-1 { + position: relative; + width: 100%; + padding-right: 15px; + padding-left: 15px; +} + +.col { + flex-basis: 0; + flex-grow: 1; + max-width: 100%; +} + +.row-cols-1 > * { + flex: 0 0 100%; + max-width: 100%; +} + +.row-cols-2 > * { + flex: 0 0 50%; + max-width: 50%; +} + +.row-cols-3 > * { + flex: 0 0 33.3333333333%; + max-width: 33.3333333333%; +} + +.row-cols-4 > * { + flex: 0 0 25%; + max-width: 25%; +} + +.row-cols-5 > * { + flex: 0 0 20%; + max-width: 20%; +} + +.row-cols-6 > * { + flex: 0 0 16.6666666667%; + max-width: 16.6666666667%; +} + +.col-auto { + flex: 0 0 auto; + width: auto; + max-width: 100%; +} + +.col-1 { + flex: 0 0 8.33333333%; + max-width: 8.33333333%; +} + +.col-2 { + flex: 0 0 16.66666667%; + max-width: 16.66666667%; +} + +.col-3 { + flex: 0 0 25%; + max-width: 25%; +} + +.col-4 { + flex: 0 0 33.33333333%; + max-width: 33.33333333%; +} + +.col-5 { + flex: 0 0 41.66666667%; + max-width: 41.66666667%; +} + +.col-6 { + flex: 0 0 50%; + max-width: 50%; +} + +.col-7 { + flex: 0 0 58.33333333%; + max-width: 58.33333333%; +} + +.col-8 { + flex: 0 0 66.66666667%; + max-width: 66.66666667%; +} + +.col-9 { + flex: 0 0 75%; + max-width: 75%; +} + +.col-10 { + flex: 0 0 83.33333333%; + max-width: 83.33333333%; +} + +.col-11 { + flex: 0 0 91.66666667%; + max-width: 91.66666667%; +} + +.col-12 { + flex: 0 0 100%; + max-width: 100%; +} + +.order-first { + order: -1; +} + +.order-last { + order: 13; +} + +.order-0 { + order: 0; +} + +.order-1 { + order: 1; +} + +.order-2 { + order: 2; +} + +.order-3 { + order: 3; +} + +.order-4 { + order: 4; +} + +.order-5 { + order: 5; +} + +.order-6 { + order: 6; +} + +.order-7 { + order: 7; +} + +.order-8 { + order: 8; +} + +.order-9 { + order: 9; +} + +.order-10 { + order: 10; +} + +.order-11 { + order: 11; +} + +.order-12 { + order: 12; +} + +.offset-1 { + margin-left: 8.33333333%; +} + +.offset-2 { + margin-left: 16.66666667%; +} + +.offset-3 { + margin-left: 25%; +} + +.offset-4 { + margin-left: 33.33333333%; +} + +.offset-5 { + margin-left: 41.66666667%; +} + +.offset-6 { + margin-left: 50%; +} + +.offset-7 { + margin-left: 58.33333333%; +} + +.offset-8 { + margin-left: 66.66666667%; +} + +.offset-9 { + margin-left: 75%; +} + +.offset-10 { + margin-left: 83.33333333%; +} + +.offset-11 { + margin-left: 91.66666667%; +} + +@media (min-width: 576px) { + .col-sm { + flex-basis: 0; + flex-grow: 1; + max-width: 100%; + } + .row-cols-sm-1 > * { + flex: 0 0 100%; + max-width: 100%; + } + .row-cols-sm-2 > * { + flex: 0 0 50%; + max-width: 50%; + } + .row-cols-sm-3 > * { + flex: 0 0 33.3333333333%; + max-width: 33.3333333333%; + } + .row-cols-sm-4 > * { + flex: 0 0 25%; + max-width: 25%; + } + .row-cols-sm-5 > * { + flex: 0 0 20%; + max-width: 20%; + } + .row-cols-sm-6 > * { + flex: 0 0 16.6666666667%; + max-width: 16.6666666667%; + } + .col-sm-auto { + flex: 0 0 auto; + width: auto; + max-width: 100%; + } + .col-sm-1 { + flex: 0 0 8.33333333%; + max-width: 8.33333333%; + } + .col-sm-2 { + flex: 0 0 16.66666667%; + max-width: 16.66666667%; + } + .col-sm-3 { + flex: 0 0 25%; + max-width: 25%; + } + .col-sm-4 { + flex: 0 0 33.33333333%; + max-width: 33.33333333%; + } + .col-sm-5 { + flex: 0 0 41.66666667%; + max-width: 41.66666667%; + } + .col-sm-6 { + flex: 0 0 50%; + max-width: 50%; + } + .col-sm-7 { + flex: 0 0 58.33333333%; + max-width: 58.33333333%; + } + .col-sm-8 { + flex: 0 0 66.66666667%; + max-width: 66.66666667%; + } + .col-sm-9 { + flex: 0 0 75%; + max-width: 75%; + } + .col-sm-10 { + flex: 0 0 83.33333333%; + max-width: 83.33333333%; + } + .col-sm-11 { + flex: 0 0 91.66666667%; + max-width: 91.66666667%; + } + .col-sm-12 { + flex: 0 0 100%; + max-width: 100%; + } + .order-sm-first { + order: -1; + } + .order-sm-last { + order: 13; + } + .order-sm-0 { + order: 0; + } + .order-sm-1 { + order: 1; + } + .order-sm-2 { + order: 2; + } + .order-sm-3 { + order: 3; + } + .order-sm-4 { + order: 4; + } + .order-sm-5 { + order: 5; + } + .order-sm-6 { + order: 6; + } + .order-sm-7 { + order: 7; + } + .order-sm-8 { + order: 8; + } + .order-sm-9 { + order: 9; + } + .order-sm-10 { + order: 10; + } + .order-sm-11 { + order: 11; + } + .order-sm-12 { + order: 12; + } + .offset-sm-0 { + margin-left: 0; + } + .offset-sm-1 { + margin-left: 8.33333333%; + } + .offset-sm-2 { + margin-left: 16.66666667%; + } + .offset-sm-3 { + margin-left: 25%; + } + .offset-sm-4 { + margin-left: 33.33333333%; + } + .offset-sm-5 { + margin-left: 41.66666667%; + } + .offset-sm-6 { + margin-left: 50%; + } + .offset-sm-7 { + margin-left: 58.33333333%; + } + .offset-sm-8 { + margin-left: 66.66666667%; + } + .offset-sm-9 { + margin-left: 75%; + } + .offset-sm-10 { + margin-left: 83.33333333%; + } + .offset-sm-11 { + margin-left: 91.66666667%; + } +} +@media (min-width: 768px) { + .col-md { + flex-basis: 0; + flex-grow: 1; + max-width: 100%; + } + .row-cols-md-1 > * { + flex: 0 0 100%; + max-width: 100%; + } + .row-cols-md-2 > * { + flex: 0 0 50%; + max-width: 50%; + } + .row-cols-md-3 > * { + flex: 0 0 33.3333333333%; + max-width: 33.3333333333%; + } + .row-cols-md-4 > * { + flex: 0 0 25%; + max-width: 25%; + } + .row-cols-md-5 > * { + flex: 0 0 20%; + max-width: 20%; + } + .row-cols-md-6 > * { + flex: 0 0 16.6666666667%; + max-width: 16.6666666667%; + } + .col-md-auto { + flex: 0 0 auto; + width: auto; + max-width: 100%; + } + .col-md-1 { + flex: 0 0 8.33333333%; + max-width: 8.33333333%; + } + .col-md-2 { + flex: 0 0 16.66666667%; + max-width: 16.66666667%; + } + .col-md-3 { + flex: 0 0 25%; + max-width: 25%; + } + .col-md-4 { + flex: 0 0 33.33333333%; + max-width: 33.33333333%; + } + .col-md-5 { + flex: 0 0 41.66666667%; + max-width: 41.66666667%; + } + .col-md-6 { + flex: 0 0 50%; + max-width: 50%; + } + .col-md-7 { + flex: 0 0 58.33333333%; + max-width: 58.33333333%; + } + .col-md-8 { + flex: 0 0 66.66666667%; + max-width: 66.66666667%; + } + .col-md-9 { + flex: 0 0 75%; + max-width: 75%; + } + .col-md-10 { + flex: 0 0 83.33333333%; + max-width: 83.33333333%; + } + .col-md-11 { + flex: 0 0 91.66666667%; + max-width: 91.66666667%; + } + .col-md-12 { + flex: 0 0 100%; + max-width: 100%; + } + .order-md-first { + order: -1; + } + .order-md-last { + order: 13; + } + .order-md-0 { + order: 0; + } + .order-md-1 { + order: 1; + } + .order-md-2 { + order: 2; + } + .order-md-3 { + order: 3; + } + .order-md-4 { + order: 4; + } + .order-md-5 { + order: 5; + } + .order-md-6 { + order: 6; + } + .order-md-7 { + order: 7; + } + .order-md-8 { + order: 8; + } + .order-md-9 { + order: 9; + } + .order-md-10 { + order: 10; + } + .order-md-11 { + order: 11; + } + .order-md-12 { + order: 12; + } + .offset-md-0 { + margin-left: 0; + } + .offset-md-1 { + margin-left: 8.33333333%; + } + .offset-md-2 { + margin-left: 16.66666667%; + } + .offset-md-3 { + margin-left: 25%; + } + .offset-md-4 { + margin-left: 33.33333333%; + } + .offset-md-5 { + margin-left: 41.66666667%; + } + .offset-md-6 { + margin-left: 50%; + } + .offset-md-7 { + margin-left: 58.33333333%; + } + .offset-md-8 { + margin-left: 66.66666667%; + } + .offset-md-9 { + margin-left: 75%; + } + .offset-md-10 { + margin-left: 83.33333333%; + } + .offset-md-11 { + margin-left: 91.66666667%; + } +} +@media (min-width: 992px) { + .col-lg { + flex-basis: 0; + flex-grow: 1; + max-width: 100%; + } + .row-cols-lg-1 > * { + flex: 0 0 100%; + max-width: 100%; + } + .row-cols-lg-2 > * { + flex: 0 0 50%; + max-width: 50%; + } + .row-cols-lg-3 > * { + flex: 0 0 33.3333333333%; + max-width: 33.3333333333%; + } + .row-cols-lg-4 > * { + flex: 0 0 25%; + max-width: 25%; + } + .row-cols-lg-5 > * { + flex: 0 0 20%; + max-width: 20%; + } + .row-cols-lg-6 > * { + flex: 0 0 16.6666666667%; + max-width: 16.6666666667%; + } + .col-lg-auto { + flex: 0 0 auto; + width: auto; + max-width: 100%; + } + .col-lg-1 { + flex: 0 0 8.33333333%; + max-width: 8.33333333%; + } + .col-lg-2 { + flex: 0 0 16.66666667%; + max-width: 16.66666667%; + } + .col-lg-3 { + flex: 0 0 25%; + max-width: 25%; + } + .col-lg-4 { + flex: 0 0 33.33333333%; + max-width: 33.33333333%; + } + .col-lg-5 { + flex: 0 0 41.66666667%; + max-width: 41.66666667%; + } + .col-lg-6 { + flex: 0 0 50%; + max-width: 50%; + } + .col-lg-7 { + flex: 0 0 58.33333333%; + max-width: 58.33333333%; + } + .col-lg-8 { + flex: 0 0 66.66666667%; + max-width: 66.66666667%; + } + .col-lg-9 { + flex: 0 0 75%; + max-width: 75%; + } + .col-lg-10 { + flex: 0 0 83.33333333%; + max-width: 83.33333333%; + } + .col-lg-11 { + flex: 0 0 91.66666667%; + max-width: 91.66666667%; + } + .col-lg-12 { + flex: 0 0 100%; + max-width: 100%; + } + .order-lg-first { + order: -1; + } + .order-lg-last { + order: 13; + } + .order-lg-0 { + order: 0; + } + .order-lg-1 { + order: 1; + } + .order-lg-2 { + order: 2; + } + .order-lg-3 { + order: 3; + } + .order-lg-4 { + order: 4; + } + .order-lg-5 { + order: 5; + } + .order-lg-6 { + order: 6; + } + .order-lg-7 { + order: 7; + } + .order-lg-8 { + order: 8; + } + .order-lg-9 { + order: 9; + } + .order-lg-10 { + order: 10; + } + .order-lg-11 { + order: 11; + } + .order-lg-12 { + order: 12; + } + .offset-lg-0 { + margin-left: 0; + } + .offset-lg-1 { + margin-left: 8.33333333%; + } + .offset-lg-2 { + margin-left: 16.66666667%; + } + .offset-lg-3 { + margin-left: 25%; + } + .offset-lg-4 { + margin-left: 33.33333333%; + } + .offset-lg-5 { + margin-left: 41.66666667%; + } + .offset-lg-6 { + margin-left: 50%; + } + .offset-lg-7 { + margin-left: 58.33333333%; + } + .offset-lg-8 { + margin-left: 66.66666667%; + } + .offset-lg-9 { + margin-left: 75%; + } + .offset-lg-10 { + margin-left: 83.33333333%; + } + .offset-lg-11 { + margin-left: 91.66666667%; + } +} +@media (min-width: 1200px) { + .col-xl { + flex-basis: 0; + flex-grow: 1; + max-width: 100%; + } + .row-cols-xl-1 > * { + flex: 0 0 100%; + max-width: 100%; + } + .row-cols-xl-2 > * { + flex: 0 0 50%; + max-width: 50%; + } + .row-cols-xl-3 > * { + flex: 0 0 33.3333333333%; + max-width: 33.3333333333%; + } + .row-cols-xl-4 > * { + flex: 0 0 25%; + max-width: 25%; + } + .row-cols-xl-5 > * { + flex: 0 0 20%; + max-width: 20%; + } + .row-cols-xl-6 > * { + flex: 0 0 16.6666666667%; + max-width: 16.6666666667%; + } + .col-xl-auto { + flex: 0 0 auto; + width: auto; + max-width: 100%; + } + .col-xl-1 { + flex: 0 0 8.33333333%; + max-width: 8.33333333%; + } + .col-xl-2 { + flex: 0 0 16.66666667%; + max-width: 16.66666667%; + } + .col-xl-3 { + flex: 0 0 25%; + max-width: 25%; + } + .col-xl-4 { + flex: 0 0 33.33333333%; + max-width: 33.33333333%; + } + .col-xl-5 { + flex: 0 0 41.66666667%; + max-width: 41.66666667%; + } + .col-xl-6 { + flex: 0 0 50%; + max-width: 50%; + } + .col-xl-7 { + flex: 0 0 58.33333333%; + max-width: 58.33333333%; + } + .col-xl-8 { + flex: 0 0 66.66666667%; + max-width: 66.66666667%; + } + .col-xl-9 { + flex: 0 0 75%; + max-width: 75%; + } + .col-xl-10 { + flex: 0 0 83.33333333%; + max-width: 83.33333333%; + } + .col-xl-11 { + flex: 0 0 91.66666667%; + max-width: 91.66666667%; + } + .col-xl-12 { + flex: 0 0 100%; + max-width: 100%; + } + .order-xl-first { + order: -1; + } + .order-xl-last { + order: 13; + } + .order-xl-0 { + order: 0; + } + .order-xl-1 { + order: 1; + } + .order-xl-2 { + order: 2; + } + .order-xl-3 { + order: 3; + } + .order-xl-4 { + order: 4; + } + .order-xl-5 { + order: 5; + } + .order-xl-6 { + order: 6; + } + .order-xl-7 { + order: 7; + } + .order-xl-8 { + order: 8; + } + .order-xl-9 { + order: 9; + } + .order-xl-10 { + order: 10; + } + .order-xl-11 { + order: 11; + } + .order-xl-12 { + order: 12; + } + .offset-xl-0 { + margin-left: 0; + } + .offset-xl-1 { + margin-left: 8.33333333%; + } + .offset-xl-2 { + margin-left: 16.66666667%; + } + .offset-xl-3 { + margin-left: 25%; + } + .offset-xl-4 { + margin-left: 33.33333333%; + } + .offset-xl-5 { + margin-left: 41.66666667%; + } + .offset-xl-6 { + margin-left: 50%; + } + .offset-xl-7 { + margin-left: 58.33333333%; + } + .offset-xl-8 { + margin-left: 66.66666667%; + } + .offset-xl-9 { + margin-left: 75%; + } + .offset-xl-10 { + margin-left: 83.33333333%; + } + .offset-xl-11 { + margin-left: 91.66666667%; + } +} +.table { + width: 100%; + margin-bottom: 1rem; + color: #212529; +} +.table th, +.table td { + padding: 0.75rem; + vertical-align: top; + border-top: 1px solid #dee2e6; +} +.table thead th { + vertical-align: bottom; + border-bottom: 2px solid #dee2e6; +} +.table tbody + tbody { + border-top: 2px solid #dee2e6; +} + +.table-sm th, +.table-sm td { + padding: 0.3rem; +} + +.table-bordered { + border: 1px solid #dee2e6; +} +.table-bordered th, +.table-bordered td { + border: 1px solid #dee2e6; +} +.table-bordered thead th, +.table-bordered thead td { + border-bottom-width: 2px; +} + +.table-borderless th, +.table-borderless td, +.table-borderless thead th, +.table-borderless tbody + tbody { + border: 0; +} + +.table-striped tbody tr:nth-of-type(odd) { + background-color: rgba(0, 0, 0, 0.05); +} + +.table-hover tbody tr:hover { + color: #212529; + background-color: rgba(0, 0, 0, 0.075); +} + +.table-primary, +.table-primary > th, +.table-primary > td { + background-color: #b8daff; +} +.table-primary th, +.table-primary td, +.table-primary thead th, +.table-primary tbody + tbody { + border-color: #7abaff; +} + +.table-hover .table-primary:hover { + background-color: #9fcdff; +} +.table-hover .table-primary:hover > td, +.table-hover .table-primary:hover > th { + background-color: #9fcdff; +} + +.table-secondary, +.table-secondary > th, +.table-secondary > td { + background-color: #d6d8db; +} +.table-secondary th, +.table-secondary td, +.table-secondary thead th, +.table-secondary tbody + tbody { + border-color: #b3b7bb; +} + +.table-hover .table-secondary:hover { + background-color: #c8cbcf; +} +.table-hover .table-secondary:hover > td, +.table-hover .table-secondary:hover > th { + background-color: #c8cbcf; +} + +.table-success, +.table-success > th, +.table-success > td { + background-color: #c3e6cb; +} +.table-success th, +.table-success td, +.table-success thead th, +.table-success tbody + tbody { + border-color: #8fd19e; +} + +.table-hover .table-success:hover { + background-color: #b1dfbb; +} +.table-hover .table-success:hover > td, +.table-hover .table-success:hover > th { + background-color: #b1dfbb; +} + +.table-info, +.table-info > th, +.table-info > td { + background-color: #bee5eb; +} +.table-info th, +.table-info td, +.table-info thead th, +.table-info tbody + tbody { + border-color: #86cfda; +} + +.table-hover .table-info:hover { + background-color: #abdde5; +} +.table-hover .table-info:hover > td, +.table-hover .table-info:hover > th { + background-color: #abdde5; +} + +.table-warning, +.table-warning > th, +.table-warning > td { + background-color: #ffeeba; +} +.table-warning th, +.table-warning td, +.table-warning thead th, +.table-warning tbody + tbody { + border-color: #ffdf7e; +} + +.table-hover .table-warning:hover { + background-color: #ffe8a1; +} +.table-hover .table-warning:hover > td, +.table-hover .table-warning:hover > th { + background-color: #ffe8a1; +} + +.table-danger, +.table-danger > th, +.table-danger > td { + background-color: #f5c6cb; +} +.table-danger th, +.table-danger td, +.table-danger thead th, +.table-danger tbody + tbody { + border-color: #ed969e; +} + +.table-hover .table-danger:hover { + background-color: #f1b0b7; +} +.table-hover .table-danger:hover > td, +.table-hover .table-danger:hover > th { + background-color: #f1b0b7; +} + +.table-light, +.table-light > th, +.table-light > td { + background-color: #fdfdfe; +} +.table-light th, +.table-light td, +.table-light thead th, +.table-light tbody + tbody { + border-color: #fbfcfc; +} + +.table-hover .table-light:hover { + background-color: #ececf6; +} +.table-hover .table-light:hover > td, +.table-hover .table-light:hover > th { + background-color: #ececf6; +} + +.table-dark, +.table-dark > th, +.table-dark > td { + background-color: #c6c8ca; +} +.table-dark th, +.table-dark td, +.table-dark thead th, +.table-dark tbody + tbody { + border-color: #95999c; +} + +.table-hover .table-dark:hover { + background-color: #b9bbbe; +} +.table-hover .table-dark:hover > td, +.table-hover .table-dark:hover > th { + background-color: #b9bbbe; +} + +.table-active, +.table-active > th, +.table-active > td { + background-color: rgba(0, 0, 0, 0.075); +} + +.table-hover .table-active:hover { + background-color: rgba(0, 0, 0, 0.075); +} +.table-hover .table-active:hover > td, +.table-hover .table-active:hover > th { + background-color: rgba(0, 0, 0, 0.075); +} + +.table .thead-dark th { + color: #fff; + background-color: #343a40; + border-color: #454d55; +} +.table .thead-light th { + color: #495057; + background-color: #e9ecef; + border-color: #dee2e6; +} + +.table-dark { + color: #fff; + background-color: #343a40; +} +.table-dark th, +.table-dark td, +.table-dark thead th { + border-color: #454d55; +} +.table-dark.table-bordered { + border: 0; +} +.table-dark.table-striped tbody tr:nth-of-type(odd) { + background-color: rgba(255, 255, 255, 0.05); +} +.table-dark.table-hover tbody tr:hover { + color: #fff; + background-color: rgba(255, 255, 255, 0.075); +} + +@media (max-width: 575.98px) { + .table-responsive-sm { + display: block; + width: 100%; + overflow-x: auto; + -webkit-overflow-scrolling: touch; + } + .table-responsive-sm > .table-bordered { + border: 0; + } +} +@media (max-width: 767.98px) { + .table-responsive-md { + display: block; + width: 100%; + overflow-x: auto; + -webkit-overflow-scrolling: touch; + } + .table-responsive-md > .table-bordered { + border: 0; + } +} +@media (max-width: 991.98px) { + .table-responsive-lg { + display: block; + width: 100%; + overflow-x: auto; + -webkit-overflow-scrolling: touch; + } + .table-responsive-lg > .table-bordered { + border: 0; + } +} +@media (max-width: 1199.98px) { + .table-responsive-xl { + display: block; + width: 100%; + overflow-x: auto; + -webkit-overflow-scrolling: touch; + } + .table-responsive-xl > .table-bordered { + border: 0; + } +} +.table-responsive { + display: block; + width: 100%; + overflow-x: auto; + -webkit-overflow-scrolling: touch; +} +.table-responsive > .table-bordered { + border: 0; +} + +.form-control { + display: block; + width: 100%; + height: calc(1.5em + 0.75rem + 2px); + padding: 0.375rem 0.75rem; + font-size: 1rem; + font-weight: 400; + line-height: 1.5; + color: #495057; + background-color: #fff; + background-clip: padding-box; + border: 1px solid #ced4da; + border-radius: 0.25rem; + transition: border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; +} +@media (prefers-reduced-motion: reduce) { + .form-control { + transition: none; + } +} +.form-control::-ms-expand { + background-color: transparent; + border: 0; +} +.form-control:focus { + color: #495057; + background-color: #fff; + border-color: #80bdff; + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.form-control::placeholder { + color: #6c757d; + opacity: 1; +} +.form-control:disabled, .form-control[readonly] { + background-color: #e9ecef; + opacity: 1; +} + +input[type=date].form-control, +input[type=time].form-control, +input[type=datetime-local].form-control, +input[type=month].form-control { + appearance: none; +} + +select.form-control:-moz-focusring { + color: transparent; + text-shadow: 0 0 0 #495057; +} +select.form-control:focus::-ms-value { + color: #495057; + background-color: #fff; +} + +.form-control-file, +.form-control-range { + display: block; + width: 100%; +} + +.col-form-label { + padding-top: calc(0.375rem + 1px); + padding-bottom: calc(0.375rem + 1px); + margin-bottom: 0; + font-size: inherit; + line-height: 1.5; +} + +.col-form-label-lg { + padding-top: calc(0.5rem + 1px); + padding-bottom: calc(0.5rem + 1px); + font-size: 1.25rem; + line-height: 1.5; +} + +.col-form-label-sm { + padding-top: calc(0.25rem + 1px); + padding-bottom: calc(0.25rem + 1px); + font-size: 0.875rem; + line-height: 1.5; +} + +.form-control-plaintext { + display: block; + width: 100%; + padding: 0.375rem 0; + margin-bottom: 0; + font-size: 1rem; + line-height: 1.5; + color: #212529; + background-color: transparent; + border: solid transparent; + border-width: 1px 0; +} +.form-control-plaintext.form-control-sm, .form-control-plaintext.form-control-lg { + padding-right: 0; + padding-left: 0; +} + +.form-control-sm { + height: calc(1.5em + 0.5rem + 2px); + padding: 0.25rem 0.5rem; + font-size: 0.875rem; + line-height: 1.5; + border-radius: 0.2rem; +} + +.form-control-lg { + height: calc(1.5em + 1rem + 2px); + padding: 0.5rem 1rem; + font-size: 1.25rem; + line-height: 1.5; + border-radius: 0.3rem; +} + +select.form-control[size], select.form-control[multiple] { + height: auto; +} + +textarea.form-control { + height: auto; +} + +.form-group { + margin-bottom: 1rem; +} + +.form-text { + display: block; + margin-top: 0.25rem; +} + +.form-row { + display: flex; + flex-wrap: wrap; + margin-right: -5px; + margin-left: -5px; +} +.form-row > .col, +.form-row > [class*=col-] { + padding-right: 5px; + padding-left: 5px; +} + +.form-check { + position: relative; + display: block; + padding-left: 1.25rem; +} + +.form-check-input { + position: absolute; + margin-top: 0.3rem; + margin-left: -1.25rem; +} +.form-check-input[disabled] ~ .form-check-label, .form-check-input:disabled ~ .form-check-label { + color: #6c757d; +} + +.form-check-label { + margin-bottom: 0; +} + +.form-check-inline { + display: inline-flex; + align-items: center; + padding-left: 0; + margin-right: 0.75rem; +} +.form-check-inline .form-check-input { + position: static; + margin-top: 0; + margin-right: 0.3125rem; + margin-left: 0; +} + +.valid-feedback { + display: none; + width: 100%; + margin-top: 0.25rem; + font-size: 0.875em; + color: #28a745; +} + +.valid-tooltip { + position: absolute; + top: 100%; + left: 0; + z-index: 5; + display: none; + max-width: 100%; + padding: 0.25rem 0.5rem; + margin-top: 0.1rem; + font-size: 0.875rem; + line-height: 1.5; + color: #fff; + background-color: rgba(40, 167, 69, 0.9); + border-radius: 0.25rem; +} +.form-row > .col > .valid-tooltip, .form-row > [class*=col-] > .valid-tooltip { + left: 5px; +} + +.was-validated :valid ~ .valid-feedback, +.was-validated :valid ~ .valid-tooltip, +.is-valid ~ .valid-feedback, +.is-valid ~ .valid-tooltip { + display: block; +} + +.was-validated .form-control:valid, .form-control.is-valid { + border-color: #28a745; + padding-right: calc(1.5em + 0.75rem) !important; + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_0___}); + background-repeat: no-repeat; + background-position: right calc(0.375em + 0.1875rem) center; + background-size: calc(0.75em + 0.375rem) calc(0.75em + 0.375rem); +} +.was-validated .form-control:valid:focus, .form-control.is-valid:focus { + border-color: #28a745; + box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.25); +} + +.was-validated select.form-control:valid, select.form-control.is-valid { + padding-right: 3rem !important; + background-position: right 1.5rem center; +} + +.was-validated textarea.form-control:valid, textarea.form-control.is-valid { + padding-right: calc(1.5em + 0.75rem); + background-position: top calc(0.375em + 0.1875rem) right calc(0.375em + 0.1875rem); +} + +.was-validated .custom-select:valid, .custom-select.is-valid { + border-color: #28a745; + padding-right: calc(0.75em + 2.3125rem) !important; + background: url(${___CSS_LOADER_URL_REPLACEMENT_1___}) right 0.75rem center/8px 10px no-repeat, #fff url(${___CSS_LOADER_URL_REPLACEMENT_0___}) center right 1.75rem/calc(0.75em + 0.375rem) calc(0.75em + 0.375rem) no-repeat; +} +.was-validated .custom-select:valid:focus, .custom-select.is-valid:focus { + border-color: #28a745; + box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.25); +} + +.was-validated .form-check-input:valid ~ .form-check-label, .form-check-input.is-valid ~ .form-check-label { + color: #28a745; +} +.was-validated .form-check-input:valid ~ .valid-feedback, +.was-validated .form-check-input:valid ~ .valid-tooltip, .form-check-input.is-valid ~ .valid-feedback, +.form-check-input.is-valid ~ .valid-tooltip { + display: block; +} + +.was-validated .custom-control-input:valid ~ .custom-control-label, .custom-control-input.is-valid ~ .custom-control-label { + color: #28a745; +} +.was-validated .custom-control-input:valid ~ .custom-control-label::before, .custom-control-input.is-valid ~ .custom-control-label::before { + border-color: #28a745; +} +.was-validated .custom-control-input:valid:checked ~ .custom-control-label::before, .custom-control-input.is-valid:checked ~ .custom-control-label::before { + border-color: #34ce57; + background-color: #34ce57; +} +.was-validated .custom-control-input:valid:focus ~ .custom-control-label::before, .custom-control-input.is-valid:focus ~ .custom-control-label::before { + box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.25); +} +.was-validated .custom-control-input:valid:focus:not(:checked) ~ .custom-control-label::before, .custom-control-input.is-valid:focus:not(:checked) ~ .custom-control-label::before { + border-color: #28a745; +} + +.was-validated .custom-file-input:valid ~ .custom-file-label, .custom-file-input.is-valid ~ .custom-file-label { + border-color: #28a745; +} +.was-validated .custom-file-input:valid:focus ~ .custom-file-label, .custom-file-input.is-valid:focus ~ .custom-file-label { + border-color: #28a745; + box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.25); +} + +.invalid-feedback { + display: none; + width: 100%; + margin-top: 0.25rem; + font-size: 0.875em; + color: #dc3545; +} + +.invalid-tooltip { + position: absolute; + top: 100%; + left: 0; + z-index: 5; + display: none; + max-width: 100%; + padding: 0.25rem 0.5rem; + margin-top: 0.1rem; + font-size: 0.875rem; + line-height: 1.5; + color: #fff; + background-color: rgba(220, 53, 69, 0.9); + border-radius: 0.25rem; +} +.form-row > .col > .invalid-tooltip, .form-row > [class*=col-] > .invalid-tooltip { + left: 5px; +} + +.was-validated :invalid ~ .invalid-feedback, +.was-validated :invalid ~ .invalid-tooltip, +.is-invalid ~ .invalid-feedback, +.is-invalid ~ .invalid-tooltip { + display: block; +} + +.was-validated .form-control:invalid, .form-control.is-invalid { + border-color: #dc3545; + padding-right: calc(1.5em + 0.75rem) !important; + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_2___}); + background-repeat: no-repeat; + background-position: right calc(0.375em + 0.1875rem) center; + background-size: calc(0.75em + 0.375rem) calc(0.75em + 0.375rem); +} +.was-validated .form-control:invalid:focus, .form-control.is-invalid:focus { + border-color: #dc3545; + box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.25); +} + +.was-validated select.form-control:invalid, select.form-control.is-invalid { + padding-right: 3rem !important; + background-position: right 1.5rem center; +} + +.was-validated textarea.form-control:invalid, textarea.form-control.is-invalid { + padding-right: calc(1.5em + 0.75rem); + background-position: top calc(0.375em + 0.1875rem) right calc(0.375em + 0.1875rem); +} + +.was-validated .custom-select:invalid, .custom-select.is-invalid { + border-color: #dc3545; + padding-right: calc(0.75em + 2.3125rem) !important; + background: url(${___CSS_LOADER_URL_REPLACEMENT_1___}) right 0.75rem center/8px 10px no-repeat, #fff url(${___CSS_LOADER_URL_REPLACEMENT_2___}) center right 1.75rem/calc(0.75em + 0.375rem) calc(0.75em + 0.375rem) no-repeat; +} +.was-validated .custom-select:invalid:focus, .custom-select.is-invalid:focus { + border-color: #dc3545; + box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.25); +} + +.was-validated .form-check-input:invalid ~ .form-check-label, .form-check-input.is-invalid ~ .form-check-label { + color: #dc3545; +} +.was-validated .form-check-input:invalid ~ .invalid-feedback, +.was-validated .form-check-input:invalid ~ .invalid-tooltip, .form-check-input.is-invalid ~ .invalid-feedback, +.form-check-input.is-invalid ~ .invalid-tooltip { + display: block; +} + +.was-validated .custom-control-input:invalid ~ .custom-control-label, .custom-control-input.is-invalid ~ .custom-control-label { + color: #dc3545; +} +.was-validated .custom-control-input:invalid ~ .custom-control-label::before, .custom-control-input.is-invalid ~ .custom-control-label::before { + border-color: #dc3545; +} +.was-validated .custom-control-input:invalid:checked ~ .custom-control-label::before, .custom-control-input.is-invalid:checked ~ .custom-control-label::before { + border-color: #e4606d; + background-color: #e4606d; +} +.was-validated .custom-control-input:invalid:focus ~ .custom-control-label::before, .custom-control-input.is-invalid:focus ~ .custom-control-label::before { + box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.25); +} +.was-validated .custom-control-input:invalid:focus:not(:checked) ~ .custom-control-label::before, .custom-control-input.is-invalid:focus:not(:checked) ~ .custom-control-label::before { + border-color: #dc3545; +} + +.was-validated .custom-file-input:invalid ~ .custom-file-label, .custom-file-input.is-invalid ~ .custom-file-label { + border-color: #dc3545; +} +.was-validated .custom-file-input:invalid:focus ~ .custom-file-label, .custom-file-input.is-invalid:focus ~ .custom-file-label { + border-color: #dc3545; + box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.25); +} + +.form-inline { + display: flex; + flex-flow: row wrap; + align-items: center; +} +.form-inline .form-check { + width: 100%; +} +@media (min-width: 576px) { + .form-inline label { + display: flex; + align-items: center; + justify-content: center; + margin-bottom: 0; + } + .form-inline .form-group { + display: flex; + flex: 0 0 auto; + flex-flow: row wrap; + align-items: center; + margin-bottom: 0; + } + .form-inline .form-control { + display: inline-block; + width: auto; + vertical-align: middle; + } + .form-inline .form-control-plaintext { + display: inline-block; + } + .form-inline .input-group, + .form-inline .custom-select { + width: auto; + } + .form-inline .form-check { + display: flex; + align-items: center; + justify-content: center; + width: auto; + padding-left: 0; + } + .form-inline .form-check-input { + position: relative; + flex-shrink: 0; + margin-top: 0; + margin-right: 0.25rem; + margin-left: 0; + } + .form-inline .custom-control { + align-items: center; + justify-content: center; + } + .form-inline .custom-control-label { + margin-bottom: 0; + } +} + +.btn { + display: inline-block; + font-weight: 400; + color: #212529; + text-align: center; + vertical-align: middle; + user-select: none; + background-color: transparent; + border: 1px solid transparent; + padding: 0.375rem 0.75rem; + font-size: 1rem; + line-height: 1.5; + border-radius: 0.25rem; + transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; +} +@media (prefers-reduced-motion: reduce) { + .btn { + transition: none; + } +} +.btn:hover { + color: #212529; + text-decoration: none; +} +.btn:focus, .btn.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.btn.disabled, .btn:disabled { + opacity: 0.65; +} +.btn:not(:disabled):not(.disabled) { + cursor: pointer; +} +a.btn.disabled, +fieldset:disabled a.btn { + pointer-events: none; +} + +.btn-primary { + color: #fff; + background-color: #007bff; + border-color: #007bff; +} +.btn-primary:hover { + color: #fff; + background-color: #0069d9; + border-color: #0062cc; +} +.btn-primary:focus, .btn-primary.focus { + color: #fff; + background-color: #0069d9; + border-color: #0062cc; + box-shadow: 0 0 0 0.2rem rgba(38, 143, 255, 0.5); +} +.btn-primary.disabled, .btn-primary:disabled { + color: #fff; + background-color: #007bff; + border-color: #007bff; +} +.btn-primary:not(:disabled):not(.disabled):active, .btn-primary:not(:disabled):not(.disabled).active, .show > .btn-primary.dropdown-toggle { + color: #fff; + background-color: #0062cc; + border-color: #005cbf; +} +.btn-primary:not(:disabled):not(.disabled):active:focus, .btn-primary:not(:disabled):not(.disabled).active:focus, .show > .btn-primary.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(38, 143, 255, 0.5); +} + +.btn-secondary { + color: #fff; + background-color: #6c757d; + border-color: #6c757d; +} +.btn-secondary:hover { + color: #fff; + background-color: #5a6268; + border-color: #545b62; +} +.btn-secondary:focus, .btn-secondary.focus { + color: #fff; + background-color: #5a6268; + border-color: #545b62; + box-shadow: 0 0 0 0.2rem rgba(130, 138, 145, 0.5); +} +.btn-secondary.disabled, .btn-secondary:disabled { + color: #fff; + background-color: #6c757d; + border-color: #6c757d; +} +.btn-secondary:not(:disabled):not(.disabled):active, .btn-secondary:not(:disabled):not(.disabled).active, .show > .btn-secondary.dropdown-toggle { + color: #fff; + background-color: #545b62; + border-color: #4e555b; +} +.btn-secondary:not(:disabled):not(.disabled):active:focus, .btn-secondary:not(:disabled):not(.disabled).active:focus, .show > .btn-secondary.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(130, 138, 145, 0.5); +} + +.btn-success { + color: #fff; + background-color: #28a745; + border-color: #28a745; +} +.btn-success:hover { + color: #fff; + background-color: #218838; + border-color: #1e7e34; +} +.btn-success:focus, .btn-success.focus { + color: #fff; + background-color: #218838; + border-color: #1e7e34; + box-shadow: 0 0 0 0.2rem rgba(72, 180, 97, 0.5); +} +.btn-success.disabled, .btn-success:disabled { + color: #fff; + background-color: #28a745; + border-color: #28a745; +} +.btn-success:not(:disabled):not(.disabled):active, .btn-success:not(:disabled):not(.disabled).active, .show > .btn-success.dropdown-toggle { + color: #fff; + background-color: #1e7e34; + border-color: #1c7430; +} +.btn-success:not(:disabled):not(.disabled):active:focus, .btn-success:not(:disabled):not(.disabled).active:focus, .show > .btn-success.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(72, 180, 97, 0.5); +} + +.btn-info { + color: #fff; + background-color: #17a2b8; + border-color: #17a2b8; +} +.btn-info:hover { + color: #fff; + background-color: #138496; + border-color: #117a8b; +} +.btn-info:focus, .btn-info.focus { + color: #fff; + background-color: #138496; + border-color: #117a8b; + box-shadow: 0 0 0 0.2rem rgba(58, 176, 195, 0.5); +} +.btn-info.disabled, .btn-info:disabled { + color: #fff; + background-color: #17a2b8; + border-color: #17a2b8; +} +.btn-info:not(:disabled):not(.disabled):active, .btn-info:not(:disabled):not(.disabled).active, .show > .btn-info.dropdown-toggle { + color: #fff; + background-color: #117a8b; + border-color: #10707f; +} +.btn-info:not(:disabled):not(.disabled):active:focus, .btn-info:not(:disabled):not(.disabled).active:focus, .show > .btn-info.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(58, 176, 195, 0.5); +} + +.btn-warning { + color: #212529; + background-color: #ffc107; + border-color: #ffc107; +} +.btn-warning:hover { + color: #212529; + background-color: #e0a800; + border-color: #d39e00; +} +.btn-warning:focus, .btn-warning.focus { + color: #212529; + background-color: #e0a800; + border-color: #d39e00; + box-shadow: 0 0 0 0.2rem rgba(222, 170, 12, 0.5); +} +.btn-warning.disabled, .btn-warning:disabled { + color: #212529; + background-color: #ffc107; + border-color: #ffc107; +} +.btn-warning:not(:disabled):not(.disabled):active, .btn-warning:not(:disabled):not(.disabled).active, .show > .btn-warning.dropdown-toggle { + color: #212529; + background-color: #d39e00; + border-color: #c69500; +} +.btn-warning:not(:disabled):not(.disabled):active:focus, .btn-warning:not(:disabled):not(.disabled).active:focus, .show > .btn-warning.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(222, 170, 12, 0.5); +} + +.btn-danger { + color: #fff; + background-color: #dc3545; + border-color: #dc3545; +} +.btn-danger:hover { + color: #fff; + background-color: #c82333; + border-color: #bd2130; +} +.btn-danger:focus, .btn-danger.focus { + color: #fff; + background-color: #c82333; + border-color: #bd2130; + box-shadow: 0 0 0 0.2rem rgba(225, 83, 97, 0.5); +} +.btn-danger.disabled, .btn-danger:disabled { + color: #fff; + background-color: #dc3545; + border-color: #dc3545; +} +.btn-danger:not(:disabled):not(.disabled):active, .btn-danger:not(:disabled):not(.disabled).active, .show > .btn-danger.dropdown-toggle { + color: #fff; + background-color: #bd2130; + border-color: #b21f2d; +} +.btn-danger:not(:disabled):not(.disabled):active:focus, .btn-danger:not(:disabled):not(.disabled).active:focus, .show > .btn-danger.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(225, 83, 97, 0.5); +} + +.btn-light { + color: #212529; + background-color: #f8f9fa; + border-color: #f8f9fa; +} +.btn-light:hover { + color: #212529; + background-color: #e2e6ea; + border-color: #dae0e5; +} +.btn-light:focus, .btn-light.focus { + color: #212529; + background-color: #e2e6ea; + border-color: #dae0e5; + box-shadow: 0 0 0 0.2rem rgba(216, 217, 219, 0.5); +} +.btn-light.disabled, .btn-light:disabled { + color: #212529; + background-color: #f8f9fa; + border-color: #f8f9fa; +} +.btn-light:not(:disabled):not(.disabled):active, .btn-light:not(:disabled):not(.disabled).active, .show > .btn-light.dropdown-toggle { + color: #212529; + background-color: #dae0e5; + border-color: #d3d9df; +} +.btn-light:not(:disabled):not(.disabled):active:focus, .btn-light:not(:disabled):not(.disabled).active:focus, .show > .btn-light.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(216, 217, 219, 0.5); +} + +.btn-dark { + color: #fff; + background-color: #343a40; + border-color: #343a40; +} +.btn-dark:hover { + color: #fff; + background-color: #23272b; + border-color: #1d2124; +} +.btn-dark:focus, .btn-dark.focus { + color: #fff; + background-color: #23272b; + border-color: #1d2124; + box-shadow: 0 0 0 0.2rem rgba(82, 88, 93, 0.5); +} +.btn-dark.disabled, .btn-dark:disabled { + color: #fff; + background-color: #343a40; + border-color: #343a40; +} +.btn-dark:not(:disabled):not(.disabled):active, .btn-dark:not(:disabled):not(.disabled).active, .show > .btn-dark.dropdown-toggle { + color: #fff; + background-color: #1d2124; + border-color: #171a1d; +} +.btn-dark:not(:disabled):not(.disabled):active:focus, .btn-dark:not(:disabled):not(.disabled).active:focus, .show > .btn-dark.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(82, 88, 93, 0.5); +} + +.btn-outline-primary { + color: #007bff; + border-color: #007bff; +} +.btn-outline-primary:hover { + color: #fff; + background-color: #007bff; + border-color: #007bff; +} +.btn-outline-primary:focus, .btn-outline-primary.focus { + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.5); +} +.btn-outline-primary.disabled, .btn-outline-primary:disabled { + color: #007bff; + background-color: transparent; +} +.btn-outline-primary:not(:disabled):not(.disabled):active, .btn-outline-primary:not(:disabled):not(.disabled).active, .show > .btn-outline-primary.dropdown-toggle { + color: #fff; + background-color: #007bff; + border-color: #007bff; +} +.btn-outline-primary:not(:disabled):not(.disabled):active:focus, .btn-outline-primary:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-primary.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.5); +} + +.btn-outline-secondary { + color: #6c757d; + border-color: #6c757d; +} +.btn-outline-secondary:hover { + color: #fff; + background-color: #6c757d; + border-color: #6c757d; +} +.btn-outline-secondary:focus, .btn-outline-secondary.focus { + box-shadow: 0 0 0 0.2rem rgba(108, 117, 125, 0.5); +} +.btn-outline-secondary.disabled, .btn-outline-secondary:disabled { + color: #6c757d; + background-color: transparent; +} +.btn-outline-secondary:not(:disabled):not(.disabled):active, .btn-outline-secondary:not(:disabled):not(.disabled).active, .show > .btn-outline-secondary.dropdown-toggle { + color: #fff; + background-color: #6c757d; + border-color: #6c757d; +} +.btn-outline-secondary:not(:disabled):not(.disabled):active:focus, .btn-outline-secondary:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-secondary.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(108, 117, 125, 0.5); +} + +.btn-outline-success { + color: #28a745; + border-color: #28a745; +} +.btn-outline-success:hover { + color: #fff; + background-color: #28a745; + border-color: #28a745; +} +.btn-outline-success:focus, .btn-outline-success.focus { + box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.5); +} +.btn-outline-success.disabled, .btn-outline-success:disabled { + color: #28a745; + background-color: transparent; +} +.btn-outline-success:not(:disabled):not(.disabled):active, .btn-outline-success:not(:disabled):not(.disabled).active, .show > .btn-outline-success.dropdown-toggle { + color: #fff; + background-color: #28a745; + border-color: #28a745; +} +.btn-outline-success:not(:disabled):not(.disabled):active:focus, .btn-outline-success:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-success.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.5); +} + +.btn-outline-info { + color: #17a2b8; + border-color: #17a2b8; +} +.btn-outline-info:hover { + color: #fff; + background-color: #17a2b8; + border-color: #17a2b8; +} +.btn-outline-info:focus, .btn-outline-info.focus { + box-shadow: 0 0 0 0.2rem rgba(23, 162, 184, 0.5); +} +.btn-outline-info.disabled, .btn-outline-info:disabled { + color: #17a2b8; + background-color: transparent; +} +.btn-outline-info:not(:disabled):not(.disabled):active, .btn-outline-info:not(:disabled):not(.disabled).active, .show > .btn-outline-info.dropdown-toggle { + color: #fff; + background-color: #17a2b8; + border-color: #17a2b8; +} +.btn-outline-info:not(:disabled):not(.disabled):active:focus, .btn-outline-info:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-info.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(23, 162, 184, 0.5); +} + +.btn-outline-warning { + color: #ffc107; + border-color: #ffc107; +} +.btn-outline-warning:hover { + color: #212529; + background-color: #ffc107; + border-color: #ffc107; +} +.btn-outline-warning:focus, .btn-outline-warning.focus { + box-shadow: 0 0 0 0.2rem rgba(255, 193, 7, 0.5); +} +.btn-outline-warning.disabled, .btn-outline-warning:disabled { + color: #ffc107; + background-color: transparent; +} +.btn-outline-warning:not(:disabled):not(.disabled):active, .btn-outline-warning:not(:disabled):not(.disabled).active, .show > .btn-outline-warning.dropdown-toggle { + color: #212529; + background-color: #ffc107; + border-color: #ffc107; +} +.btn-outline-warning:not(:disabled):not(.disabled):active:focus, .btn-outline-warning:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-warning.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(255, 193, 7, 0.5); +} + +.btn-outline-danger { + color: #dc3545; + border-color: #dc3545; +} +.btn-outline-danger:hover { + color: #fff; + background-color: #dc3545; + border-color: #dc3545; +} +.btn-outline-danger:focus, .btn-outline-danger.focus { + box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.5); +} +.btn-outline-danger.disabled, .btn-outline-danger:disabled { + color: #dc3545; + background-color: transparent; +} +.btn-outline-danger:not(:disabled):not(.disabled):active, .btn-outline-danger:not(:disabled):not(.disabled).active, .show > .btn-outline-danger.dropdown-toggle { + color: #fff; + background-color: #dc3545; + border-color: #dc3545; +} +.btn-outline-danger:not(:disabled):not(.disabled):active:focus, .btn-outline-danger:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-danger.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.5); +} + +.btn-outline-light { + color: #f8f9fa; + border-color: #f8f9fa; +} +.btn-outline-light:hover { + color: #212529; + background-color: #f8f9fa; + border-color: #f8f9fa; +} +.btn-outline-light:focus, .btn-outline-light.focus { + box-shadow: 0 0 0 0.2rem rgba(248, 249, 250, 0.5); +} +.btn-outline-light.disabled, .btn-outline-light:disabled { + color: #f8f9fa; + background-color: transparent; +} +.btn-outline-light:not(:disabled):not(.disabled):active, .btn-outline-light:not(:disabled):not(.disabled).active, .show > .btn-outline-light.dropdown-toggle { + color: #212529; + background-color: #f8f9fa; + border-color: #f8f9fa; +} +.btn-outline-light:not(:disabled):not(.disabled):active:focus, .btn-outline-light:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-light.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(248, 249, 250, 0.5); +} + +.btn-outline-dark { + color: #343a40; + border-color: #343a40; +} +.btn-outline-dark:hover { + color: #fff; + background-color: #343a40; + border-color: #343a40; +} +.btn-outline-dark:focus, .btn-outline-dark.focus { + box-shadow: 0 0 0 0.2rem rgba(52, 58, 64, 0.5); +} +.btn-outline-dark.disabled, .btn-outline-dark:disabled { + color: #343a40; + background-color: transparent; +} +.btn-outline-dark:not(:disabled):not(.disabled):active, .btn-outline-dark:not(:disabled):not(.disabled).active, .show > .btn-outline-dark.dropdown-toggle { + color: #fff; + background-color: #343a40; + border-color: #343a40; +} +.btn-outline-dark:not(:disabled):not(.disabled):active:focus, .btn-outline-dark:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-dark.dropdown-toggle:focus { + box-shadow: 0 0 0 0.2rem rgba(52, 58, 64, 0.5); +} + +.btn-link { + font-weight: 400; + color: #007bff; + text-decoration: none; +} +.btn-link:hover { + color: #0056b3; + text-decoration: underline; +} +.btn-link:focus, .btn-link.focus { + text-decoration: underline; +} +.btn-link:disabled, .btn-link.disabled { + color: #6c757d; + pointer-events: none; +} + +.btn-lg, .btn-group-lg > .btn { + padding: 0.5rem 1rem; + font-size: 1.25rem; + line-height: 1.5; + border-radius: 0.3rem; +} + +.btn-sm, .btn-group-sm > .btn { + padding: 0.25rem 0.5rem; + font-size: 0.875rem; + line-height: 1.5; + border-radius: 0.2rem; +} + +.btn-block { + display: block; + width: 100%; +} +.btn-block + .btn-block { + margin-top: 0.5rem; +} + +input[type=submit].btn-block, +input[type=reset].btn-block, +input[type=button].btn-block { + width: 100%; +} + +.fade { + transition: opacity 0.15s linear; +} +@media (prefers-reduced-motion: reduce) { + .fade { + transition: none; + } +} +.fade:not(.show) { + opacity: 0; +} + +.collapse:not(.show) { + display: none; +} + +.collapsing { + position: relative; + height: 0; + overflow: hidden; + transition: height 0.35s ease; +} +@media (prefers-reduced-motion: reduce) { + .collapsing { + transition: none; + } +} +.collapsing.width { + width: 0; + height: auto; + transition: width 0.35s ease; +} +@media (prefers-reduced-motion: reduce) { + .collapsing.width { + transition: none; + } +} + +.dropup, +.dropright, +.dropdown, +.dropleft { + position: relative; +} + +.dropdown-toggle { + white-space: nowrap; +} +.dropdown-toggle::after { + display: inline-block; + margin-left: 0.255em; + vertical-align: 0.255em; + content: ""; + border-top: 0.3em solid; + border-right: 0.3em solid transparent; + border-bottom: 0; + border-left: 0.3em solid transparent; +} +.dropdown-toggle:empty::after { + margin-left: 0; +} + +.dropdown-menu { + position: absolute; + top: 100%; + left: 0; + z-index: 1000; + display: none; + float: left; + min-width: 10rem; + padding: 0.5rem 0; + margin: 0.125rem 0 0; + font-size: 1rem; + color: #212529; + text-align: left; + list-style: none; + background-color: #fff; + background-clip: padding-box; + border: 1px solid rgba(0, 0, 0, 0.15); + border-radius: 0.25rem; +} + +.dropdown-menu-left { + right: auto; + left: 0; +} + +.dropdown-menu-right { + right: 0; + left: auto; +} + +@media (min-width: 576px) { + .dropdown-menu-sm-left { + right: auto; + left: 0; + } + .dropdown-menu-sm-right { + right: 0; + left: auto; + } +} +@media (min-width: 768px) { + .dropdown-menu-md-left { + right: auto; + left: 0; + } + .dropdown-menu-md-right { + right: 0; + left: auto; + } +} +@media (min-width: 992px) { + .dropdown-menu-lg-left { + right: auto; + left: 0; + } + .dropdown-menu-lg-right { + right: 0; + left: auto; + } +} +@media (min-width: 1200px) { + .dropdown-menu-xl-left { + right: auto; + left: 0; + } + .dropdown-menu-xl-right { + right: 0; + left: auto; + } +} +.dropup .dropdown-menu { + top: auto; + bottom: 100%; + margin-top: 0; + margin-bottom: 0.125rem; +} +.dropup .dropdown-toggle::after { + display: inline-block; + margin-left: 0.255em; + vertical-align: 0.255em; + content: ""; + border-top: 0; + border-right: 0.3em solid transparent; + border-bottom: 0.3em solid; + border-left: 0.3em solid transparent; +} +.dropup .dropdown-toggle:empty::after { + margin-left: 0; +} + +.dropright .dropdown-menu { + top: 0; + right: auto; + left: 100%; + margin-top: 0; + margin-left: 0.125rem; +} +.dropright .dropdown-toggle::after { + display: inline-block; + margin-left: 0.255em; + vertical-align: 0.255em; + content: ""; + border-top: 0.3em solid transparent; + border-right: 0; + border-bottom: 0.3em solid transparent; + border-left: 0.3em solid; +} +.dropright .dropdown-toggle:empty::after { + margin-left: 0; +} +.dropright .dropdown-toggle::after { + vertical-align: 0; +} + +.dropleft .dropdown-menu { + top: 0; + right: 100%; + left: auto; + margin-top: 0; + margin-right: 0.125rem; +} +.dropleft .dropdown-toggle::after { + display: inline-block; + margin-left: 0.255em; + vertical-align: 0.255em; + content: ""; +} +.dropleft .dropdown-toggle::after { + display: none; +} +.dropleft .dropdown-toggle::before { + display: inline-block; + margin-right: 0.255em; + vertical-align: 0.255em; + content: ""; + border-top: 0.3em solid transparent; + border-right: 0.3em solid; + border-bottom: 0.3em solid transparent; +} +.dropleft .dropdown-toggle:empty::after { + margin-left: 0; +} +.dropleft .dropdown-toggle::before { + vertical-align: 0; +} + +.dropdown-menu[x-placement^=top], .dropdown-menu[x-placement^=right], .dropdown-menu[x-placement^=bottom], .dropdown-menu[x-placement^=left] { + right: auto; + bottom: auto; +} + +.dropdown-divider { + height: 0; + margin: 0.5rem 0; + overflow: hidden; + border-top: 1px solid #e9ecef; +} + +.dropdown-item { + display: block; + width: 100%; + padding: 0.25rem 1.5rem; + clear: both; + font-weight: 400; + color: #212529; + text-align: inherit; + white-space: nowrap; + background-color: transparent; + border: 0; +} +.dropdown-item:hover, .dropdown-item:focus { + color: #16181b; + text-decoration: none; + background-color: #e9ecef; +} +.dropdown-item.active, .dropdown-item:active { + color: #fff; + text-decoration: none; + background-color: #007bff; +} +.dropdown-item.disabled, .dropdown-item:disabled { + color: #adb5bd; + pointer-events: none; + background-color: transparent; +} + +.dropdown-menu.show { + display: block; +} + +.dropdown-header { + display: block; + padding: 0.5rem 1.5rem; + margin-bottom: 0; + font-size: 0.875rem; + color: #6c757d; + white-space: nowrap; +} + +.dropdown-item-text { + display: block; + padding: 0.25rem 1.5rem; + color: #212529; +} + +.btn-group, +.btn-group-vertical { + position: relative; + display: inline-flex; + vertical-align: middle; +} +.btn-group > .btn, +.btn-group-vertical > .btn { + position: relative; + flex: 1 1 auto; +} +.btn-group > .btn:hover, +.btn-group-vertical > .btn:hover { + z-index: 1; +} +.btn-group > .btn:focus, .btn-group > .btn:active, .btn-group > .btn.active, +.btn-group-vertical > .btn:focus, +.btn-group-vertical > .btn:active, +.btn-group-vertical > .btn.active { + z-index: 1; +} + +.btn-toolbar { + display: flex; + flex-wrap: wrap; + justify-content: flex-start; +} +.btn-toolbar .input-group { + width: auto; +} + +.btn-group > .btn:not(:first-child), +.btn-group > .btn-group:not(:first-child) { + margin-left: -1px; +} +.btn-group > .btn:not(:last-child):not(.dropdown-toggle), +.btn-group > .btn-group:not(:last-child) > .btn { + border-top-right-radius: 0; + border-bottom-right-radius: 0; +} +.btn-group > .btn:not(:first-child), +.btn-group > .btn-group:not(:first-child) > .btn { + border-top-left-radius: 0; + border-bottom-left-radius: 0; +} + +.dropdown-toggle-split { + padding-right: 0.5625rem; + padding-left: 0.5625rem; +} +.dropdown-toggle-split::after, .dropup .dropdown-toggle-split::after, .dropright .dropdown-toggle-split::after { + margin-left: 0; +} +.dropleft .dropdown-toggle-split::before { + margin-right: 0; +} + +.btn-sm + .dropdown-toggle-split, .btn-group-sm > .btn + .dropdown-toggle-split { + padding-right: 0.375rem; + padding-left: 0.375rem; +} + +.btn-lg + .dropdown-toggle-split, .btn-group-lg > .btn + .dropdown-toggle-split { + padding-right: 0.75rem; + padding-left: 0.75rem; +} + +.btn-group-vertical { + flex-direction: column; + align-items: flex-start; + justify-content: center; +} +.btn-group-vertical > .btn, +.btn-group-vertical > .btn-group { + width: 100%; +} +.btn-group-vertical > .btn:not(:first-child), +.btn-group-vertical > .btn-group:not(:first-child) { + margin-top: -1px; +} +.btn-group-vertical > .btn:not(:last-child):not(.dropdown-toggle), +.btn-group-vertical > .btn-group:not(:last-child) > .btn { + border-bottom-right-radius: 0; + border-bottom-left-radius: 0; +} +.btn-group-vertical > .btn:not(:first-child), +.btn-group-vertical > .btn-group:not(:first-child) > .btn { + border-top-left-radius: 0; + border-top-right-radius: 0; +} + +.btn-group-toggle > .btn, +.btn-group-toggle > .btn-group > .btn { + margin-bottom: 0; +} +.btn-group-toggle > .btn input[type=radio], +.btn-group-toggle > .btn input[type=checkbox], +.btn-group-toggle > .btn-group > .btn input[type=radio], +.btn-group-toggle > .btn-group > .btn input[type=checkbox] { + position: absolute; + clip: rect(0, 0, 0, 0); + pointer-events: none; +} + +.input-group { + position: relative; + display: flex; + flex-wrap: wrap; + align-items: stretch; + width: 100%; +} +.input-group > .form-control, +.input-group > .form-control-plaintext, +.input-group > .custom-select, +.input-group > .custom-file { + position: relative; + flex: 1 1 auto; + width: 1%; + min-width: 0; + margin-bottom: 0; +} +.input-group > .form-control + .form-control, +.input-group > .form-control + .custom-select, +.input-group > .form-control + .custom-file, +.input-group > .form-control-plaintext + .form-control, +.input-group > .form-control-plaintext + .custom-select, +.input-group > .form-control-plaintext + .custom-file, +.input-group > .custom-select + .form-control, +.input-group > .custom-select + .custom-select, +.input-group > .custom-select + .custom-file, +.input-group > .custom-file + .form-control, +.input-group > .custom-file + .custom-select, +.input-group > .custom-file + .custom-file { + margin-left: -1px; +} +.input-group > .form-control:focus, +.input-group > .custom-select:focus, +.input-group > .custom-file .custom-file-input:focus ~ .custom-file-label { + z-index: 3; +} +.input-group > .custom-file .custom-file-input:focus { + z-index: 4; +} +.input-group > .form-control:not(:first-child), +.input-group > .custom-select:not(:first-child) { + border-top-left-radius: 0; + border-bottom-left-radius: 0; +} +.input-group > .custom-file { + display: flex; + align-items: center; +} +.input-group > .custom-file:not(:last-child) .custom-file-label, .input-group > .custom-file:not(:last-child) .custom-file-label::after { + border-top-right-radius: 0; + border-bottom-right-radius: 0; +} +.input-group > .custom-file:not(:first-child) .custom-file-label { + border-top-left-radius: 0; + border-bottom-left-radius: 0; +} +.input-group:not(.has-validation) > .form-control:not(:last-child), +.input-group:not(.has-validation) > .custom-select:not(:last-child), +.input-group:not(.has-validation) > .custom-file:not(:last-child) .custom-file-label, +.input-group:not(.has-validation) > .custom-file:not(:last-child) .custom-file-label::after { + border-top-right-radius: 0; + border-bottom-right-radius: 0; +} +.input-group.has-validation > .form-control:nth-last-child(n+3), +.input-group.has-validation > .custom-select:nth-last-child(n+3), +.input-group.has-validation > .custom-file:nth-last-child(n+3) .custom-file-label, +.input-group.has-validation > .custom-file:nth-last-child(n+3) .custom-file-label::after { + border-top-right-radius: 0; + border-bottom-right-radius: 0; +} + +.input-group-prepend, +.input-group-append { + display: flex; +} +.input-group-prepend .btn, +.input-group-append .btn { + position: relative; + z-index: 2; +} +.input-group-prepend .btn:focus, +.input-group-append .btn:focus { + z-index: 3; +} +.input-group-prepend .btn + .btn, +.input-group-prepend .btn + .input-group-text, +.input-group-prepend .input-group-text + .input-group-text, +.input-group-prepend .input-group-text + .btn, +.input-group-append .btn + .btn, +.input-group-append .btn + .input-group-text, +.input-group-append .input-group-text + .input-group-text, +.input-group-append .input-group-text + .btn { + margin-left: -1px; +} + +.input-group-prepend { + margin-right: -1px; +} + +.input-group-append { + margin-left: -1px; +} + +.input-group-text { + display: flex; + align-items: center; + padding: 0.375rem 0.75rem; + margin-bottom: 0; + font-size: 1rem; + font-weight: 400; + line-height: 1.5; + color: #495057; + text-align: center; + white-space: nowrap; + background-color: #e9ecef; + border: 1px solid #ced4da; + border-radius: 0.25rem; +} +.input-group-text input[type=radio], +.input-group-text input[type=checkbox] { + margin-top: 0; +} + +.input-group-lg > .form-control:not(textarea), +.input-group-lg > .custom-select { + height: calc(1.5em + 1rem + 2px); +} + +.input-group-lg > .form-control, +.input-group-lg > .custom-select, +.input-group-lg > .input-group-prepend > .input-group-text, +.input-group-lg > .input-group-append > .input-group-text, +.input-group-lg > .input-group-prepend > .btn, +.input-group-lg > .input-group-append > .btn { + padding: 0.5rem 1rem; + font-size: 1.25rem; + line-height: 1.5; + border-radius: 0.3rem; +} + +.input-group-sm > .form-control:not(textarea), +.input-group-sm > .custom-select { + height: calc(1.5em + 0.5rem + 2px); +} + +.input-group-sm > .form-control, +.input-group-sm > .custom-select, +.input-group-sm > .input-group-prepend > .input-group-text, +.input-group-sm > .input-group-append > .input-group-text, +.input-group-sm > .input-group-prepend > .btn, +.input-group-sm > .input-group-append > .btn { + padding: 0.25rem 0.5rem; + font-size: 0.875rem; + line-height: 1.5; + border-radius: 0.2rem; +} + +.input-group-lg > .custom-select, +.input-group-sm > .custom-select { + padding-right: 1.75rem; +} + +.input-group > .input-group-prepend > .btn, +.input-group > .input-group-prepend > .input-group-text, +.input-group:not(.has-validation) > .input-group-append:not(:last-child) > .btn, +.input-group:not(.has-validation) > .input-group-append:not(:last-child) > .input-group-text, +.input-group.has-validation > .input-group-append:nth-last-child(n+3) > .btn, +.input-group.has-validation > .input-group-append:nth-last-child(n+3) > .input-group-text, +.input-group > .input-group-append:last-child > .btn:not(:last-child):not(.dropdown-toggle), +.input-group > .input-group-append:last-child > .input-group-text:not(:last-child) { + border-top-right-radius: 0; + border-bottom-right-radius: 0; +} + +.input-group > .input-group-append > .btn, +.input-group > .input-group-append > .input-group-text, +.input-group > .input-group-prepend:not(:first-child) > .btn, +.input-group > .input-group-prepend:not(:first-child) > .input-group-text, +.input-group > .input-group-prepend:first-child > .btn:not(:first-child), +.input-group > .input-group-prepend:first-child > .input-group-text:not(:first-child) { + border-top-left-radius: 0; + border-bottom-left-radius: 0; +} + +.custom-control { + position: relative; + z-index: 1; + display: block; + min-height: 1.5rem; + padding-left: 1.5rem; + print-color-adjust: exact; +} + +.custom-control-inline { + display: inline-flex; + margin-right: 1rem; +} + +.custom-control-input { + position: absolute; + left: 0; + z-index: -1; + width: 1rem; + height: 1.25rem; + opacity: 0; +} +.custom-control-input:checked ~ .custom-control-label::before { + color: #fff; + border-color: #007bff; + background-color: #007bff; +} +.custom-control-input:focus ~ .custom-control-label::before { + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.custom-control-input:focus:not(:checked) ~ .custom-control-label::before { + border-color: #80bdff; +} +.custom-control-input:not(:disabled):active ~ .custom-control-label::before { + color: #fff; + background-color: #b3d7ff; + border-color: #b3d7ff; +} +.custom-control-input[disabled] ~ .custom-control-label, .custom-control-input:disabled ~ .custom-control-label { + color: #6c757d; +} +.custom-control-input[disabled] ~ .custom-control-label::before, .custom-control-input:disabled ~ .custom-control-label::before { + background-color: #e9ecef; +} + +.custom-control-label { + position: relative; + margin-bottom: 0; + vertical-align: top; +} +.custom-control-label::before { + position: absolute; + top: 0.25rem; + left: -1.5rem; + display: block; + width: 1rem; + height: 1rem; + pointer-events: none; + content: ""; + background-color: #fff; + border: 1px solid #adb5bd; +} +.custom-control-label::after { + position: absolute; + top: 0.25rem; + left: -1.5rem; + display: block; + width: 1rem; + height: 1rem; + content: ""; + background: 50%/50% 50% no-repeat; +} + +.custom-checkbox .custom-control-label::before { + border-radius: 0.25rem; +} +.custom-checkbox .custom-control-input:checked ~ .custom-control-label::after { + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_3___}); +} +.custom-checkbox .custom-control-input:indeterminate ~ .custom-control-label::before { + border-color: #007bff; + background-color: #007bff; +} +.custom-checkbox .custom-control-input:indeterminate ~ .custom-control-label::after { + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_4___}); +} +.custom-checkbox .custom-control-input:disabled:checked ~ .custom-control-label::before { + background-color: rgba(0, 123, 255, 0.5); +} +.custom-checkbox .custom-control-input:disabled:indeterminate ~ .custom-control-label::before { + background-color: rgba(0, 123, 255, 0.5); +} + +.custom-radio .custom-control-label::before { + border-radius: 50%; +} +.custom-radio .custom-control-input:checked ~ .custom-control-label::after { + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_5___}); +} +.custom-radio .custom-control-input:disabled:checked ~ .custom-control-label::before { + background-color: rgba(0, 123, 255, 0.5); +} + +.custom-switch { + padding-left: 2.25rem; +} +.custom-switch .custom-control-label::before { + left: -2.25rem; + width: 1.75rem; + pointer-events: all; + border-radius: 0.5rem; +} +.custom-switch .custom-control-label::after { + top: calc(0.25rem + 2px); + left: calc(-2.25rem + 2px); + width: calc(1rem - 4px); + height: calc(1rem - 4px); + background-color: #adb5bd; + border-radius: 0.5rem; + transition: transform 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; +} +@media (prefers-reduced-motion: reduce) { + .custom-switch .custom-control-label::after { + transition: none; + } +} +.custom-switch .custom-control-input:checked ~ .custom-control-label::after { + background-color: #fff; + transform: translateX(0.75rem); +} +.custom-switch .custom-control-input:disabled:checked ~ .custom-control-label::before { + background-color: rgba(0, 123, 255, 0.5); +} + +.custom-select { + display: inline-block; + width: 100%; + height: calc(1.5em + 0.75rem + 2px); + padding: 0.375rem 1.75rem 0.375rem 0.75rem; + font-size: 1rem; + font-weight: 400; + line-height: 1.5; + color: #495057; + vertical-align: middle; + background: #fff url(${___CSS_LOADER_URL_REPLACEMENT_1___}) right 0.75rem center/8px 10px no-repeat; + border: 1px solid #ced4da; + border-radius: 0.25rem; + appearance: none; +} +.custom-select:focus { + border-color: #80bdff; + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.custom-select:focus::-ms-value { + color: #495057; + background-color: #fff; +} +.custom-select[multiple], .custom-select[size]:not([size="1"]) { + height: auto; + padding-right: 0.75rem; + background-image: none; +} +.custom-select:disabled { + color: #6c757d; + background-color: #e9ecef; +} +.custom-select::-ms-expand { + display: none; +} +.custom-select:-moz-focusring { + color: transparent; + text-shadow: 0 0 0 #495057; +} + +.custom-select-sm { + height: calc(1.5em + 0.5rem + 2px); + padding-top: 0.25rem; + padding-bottom: 0.25rem; + padding-left: 0.5rem; + font-size: 0.875rem; +} + +.custom-select-lg { + height: calc(1.5em + 1rem + 2px); + padding-top: 0.5rem; + padding-bottom: 0.5rem; + padding-left: 1rem; + font-size: 1.25rem; +} + +.custom-file { + position: relative; + display: inline-block; + width: 100%; + height: calc(1.5em + 0.75rem + 2px); + margin-bottom: 0; +} + +.custom-file-input { + position: relative; + z-index: 2; + width: 100%; + height: calc(1.5em + 0.75rem + 2px); + margin: 0; + overflow: hidden; + opacity: 0; +} +.custom-file-input:focus ~ .custom-file-label { + border-color: #80bdff; + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.custom-file-input[disabled] ~ .custom-file-label, .custom-file-input:disabled ~ .custom-file-label { + background-color: #e9ecef; +} +.custom-file-input:lang(en) ~ .custom-file-label::after { + content: "Browse"; +} +.custom-file-input ~ .custom-file-label[data-browse]::after { + content: attr(data-browse); +} + +.custom-file-label { + position: absolute; + top: 0; + right: 0; + left: 0; + z-index: 1; + height: calc(1.5em + 0.75rem + 2px); + padding: 0.375rem 0.75rem; + overflow: hidden; + font-weight: 400; + line-height: 1.5; + color: #495057; + background-color: #fff; + border: 1px solid #ced4da; + border-radius: 0.25rem; +} +.custom-file-label::after { + position: absolute; + top: 0; + right: 0; + bottom: 0; + z-index: 3; + display: block; + height: calc(1.5em + 0.75rem); + padding: 0.375rem 0.75rem; + line-height: 1.5; + color: #495057; + content: "Browse"; + background-color: #e9ecef; + border-left: inherit; + border-radius: 0 0.25rem 0.25rem 0; +} + +.custom-range { + width: 100%; + height: 1.4rem; + padding: 0; + background-color: transparent; + appearance: none; +} +.custom-range:focus { + outline: 0; +} +.custom-range:focus::-webkit-slider-thumb { + box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.custom-range:focus::-moz-range-thumb { + box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.custom-range:focus::-ms-thumb { + box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} +.custom-range::-moz-focus-outer { + border: 0; +} +.custom-range::-webkit-slider-thumb { + width: 1rem; + height: 1rem; + margin-top: -0.25rem; + background-color: #007bff; + border: 0; + border-radius: 1rem; + transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; + appearance: none; +} +@media (prefers-reduced-motion: reduce) { + .custom-range::-webkit-slider-thumb { + transition: none; + } +} +.custom-range::-webkit-slider-thumb:active { + background-color: #b3d7ff; +} +.custom-range::-webkit-slider-runnable-track { + width: 100%; + height: 0.5rem; + color: transparent; + cursor: pointer; + background-color: #dee2e6; + border-color: transparent; + border-radius: 1rem; +} +.custom-range::-moz-range-thumb { + width: 1rem; + height: 1rem; + background-color: #007bff; + border: 0; + border-radius: 1rem; + transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; + appearance: none; +} +@media (prefers-reduced-motion: reduce) { + .custom-range::-moz-range-thumb { + transition: none; + } +} +.custom-range::-moz-range-thumb:active { + background-color: #b3d7ff; +} +.custom-range::-moz-range-track { + width: 100%; + height: 0.5rem; + color: transparent; + cursor: pointer; + background-color: #dee2e6; + border-color: transparent; + border-radius: 1rem; +} +.custom-range::-ms-thumb { + width: 1rem; + height: 1rem; + margin-top: 0; + margin-right: 0.2rem; + margin-left: 0.2rem; + background-color: #007bff; + border: 0; + border-radius: 1rem; + transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; + appearance: none; +} +@media (prefers-reduced-motion: reduce) { + .custom-range::-ms-thumb { + transition: none; + } +} +.custom-range::-ms-thumb:active { + background-color: #b3d7ff; +} +.custom-range::-ms-track { + width: 100%; + height: 0.5rem; + color: transparent; + cursor: pointer; + background-color: transparent; + border-color: transparent; + border-width: 0.5rem; +} +.custom-range::-ms-fill-lower { + background-color: #dee2e6; + border-radius: 1rem; +} +.custom-range::-ms-fill-upper { + margin-right: 15px; + background-color: #dee2e6; + border-radius: 1rem; +} +.custom-range:disabled::-webkit-slider-thumb { + background-color: #adb5bd; +} +.custom-range:disabled::-webkit-slider-runnable-track { + cursor: default; +} +.custom-range:disabled::-moz-range-thumb { + background-color: #adb5bd; +} +.custom-range:disabled::-moz-range-track { + cursor: default; +} +.custom-range:disabled::-ms-thumb { + background-color: #adb5bd; +} + +.custom-control-label::before, +.custom-file-label, +.custom-select { + transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; +} +@media (prefers-reduced-motion: reduce) { + .custom-control-label::before, + .custom-file-label, + .custom-select { + transition: none; + } +} + +.nav { + display: flex; + flex-wrap: wrap; + padding-left: 0; + margin-bottom: 0; + list-style: none; +} + +.nav-link { + display: block; + padding: 0.5rem 1rem; +} +.nav-link:hover, .nav-link:focus { + text-decoration: none; +} +.nav-link.disabled { + color: #6c757d; + pointer-events: none; + cursor: default; +} + +.nav-tabs { + border-bottom: 1px solid #dee2e6; +} +.nav-tabs .nav-link { + margin-bottom: -1px; + background-color: transparent; + border: 1px solid transparent; + border-top-left-radius: 0.25rem; + border-top-right-radius: 0.25rem; +} +.nav-tabs .nav-link:hover, .nav-tabs .nav-link:focus { + isolation: isolate; + border-color: #e9ecef #e9ecef #dee2e6; +} +.nav-tabs .nav-link.disabled { + color: #6c757d; + background-color: transparent; + border-color: transparent; +} +.nav-tabs .nav-link.active, +.nav-tabs .nav-item.show .nav-link { + color: #495057; + background-color: #fff; + border-color: #dee2e6 #dee2e6 #fff; +} +.nav-tabs .dropdown-menu { + margin-top: -1px; + border-top-left-radius: 0; + border-top-right-radius: 0; +} + +.nav-pills .nav-link { + background: none; + border: 0; + border-radius: 0.25rem; +} +.nav-pills .nav-link.active, +.nav-pills .show > .nav-link { + color: #fff; + background-color: #007bff; +} + +.nav-fill > .nav-link, +.nav-fill .nav-item { + flex: 1 1 auto; + text-align: center; +} + +.nav-justified > .nav-link, +.nav-justified .nav-item { + flex-basis: 0; + flex-grow: 1; + text-align: center; +} + +.tab-content > .tab-pane { + display: none; +} +.tab-content > .active { + display: block; +} + +.navbar { + position: relative; + display: flex; + flex-wrap: wrap; + align-items: center; + justify-content: space-between; + padding: 0.5rem 1rem; +} +.navbar .container, +.navbar .container-fluid, +.navbar .container-sm, +.navbar .container-md, +.navbar .container-lg, +.navbar .container-xl { + display: flex; + flex-wrap: wrap; + align-items: center; + justify-content: space-between; +} +.navbar-brand { + display: inline-block; + padding-top: 0.3125rem; + padding-bottom: 0.3125rem; + margin-right: 1rem; + font-size: 1.25rem; + line-height: inherit; + white-space: nowrap; +} +.navbar-brand:hover, .navbar-brand:focus { + text-decoration: none; +} + +.navbar-nav { + display: flex; + flex-direction: column; + padding-left: 0; + margin-bottom: 0; + list-style: none; +} +.navbar-nav .nav-link { + padding-right: 0; + padding-left: 0; +} +.navbar-nav .dropdown-menu { + position: static; + float: none; +} + +.navbar-text { + display: inline-block; + padding-top: 0.5rem; + padding-bottom: 0.5rem; +} + +.navbar-collapse { + flex-basis: 100%; + flex-grow: 1; + align-items: center; +} + +.navbar-toggler { + padding: 0.25rem 0.75rem; + font-size: 1.25rem; + line-height: 1; + background-color: transparent; + border: 1px solid transparent; + border-radius: 0.25rem; +} +.navbar-toggler:hover, .navbar-toggler:focus { + text-decoration: none; +} + +.navbar-toggler-icon { + display: inline-block; + width: 1.5em; + height: 1.5em; + vertical-align: middle; + content: ""; + background: 50%/100% 100% no-repeat; +} + +.navbar-nav-scroll { + max-height: 75vh; + overflow-y: auto; +} + +@media (max-width: 575.98px) { + .navbar-expand-sm > .container, + .navbar-expand-sm > .container-fluid, + .navbar-expand-sm > .container-sm, + .navbar-expand-sm > .container-md, + .navbar-expand-sm > .container-lg, + .navbar-expand-sm > .container-xl { + padding-right: 0; + padding-left: 0; + } +} +@media (min-width: 576px) { + .navbar-expand-sm { + flex-flow: row nowrap; + justify-content: flex-start; + } + .navbar-expand-sm .navbar-nav { + flex-direction: row; + } + .navbar-expand-sm .navbar-nav .dropdown-menu { + position: absolute; + } + .navbar-expand-sm .navbar-nav .nav-link { + padding-right: 0.5rem; + padding-left: 0.5rem; + } + .navbar-expand-sm > .container, + .navbar-expand-sm > .container-fluid, + .navbar-expand-sm > .container-sm, + .navbar-expand-sm > .container-md, + .navbar-expand-sm > .container-lg, + .navbar-expand-sm > .container-xl { + flex-wrap: nowrap; + } + .navbar-expand-sm .navbar-nav-scroll { + overflow: visible; + } + .navbar-expand-sm .navbar-collapse { + display: flex !important; + flex-basis: auto; + } + .navbar-expand-sm .navbar-toggler { + display: none; + } +} +@media (max-width: 767.98px) { + .navbar-expand-md > .container, + .navbar-expand-md > .container-fluid, + .navbar-expand-md > .container-sm, + .navbar-expand-md > .container-md, + .navbar-expand-md > .container-lg, + .navbar-expand-md > .container-xl { + padding-right: 0; + padding-left: 0; + } +} +@media (min-width: 768px) { + .navbar-expand-md { + flex-flow: row nowrap; + justify-content: flex-start; + } + .navbar-expand-md .navbar-nav { + flex-direction: row; + } + .navbar-expand-md .navbar-nav .dropdown-menu { + position: absolute; + } + .navbar-expand-md .navbar-nav .nav-link { + padding-right: 0.5rem; + padding-left: 0.5rem; + } + .navbar-expand-md > .container, + .navbar-expand-md > .container-fluid, + .navbar-expand-md > .container-sm, + .navbar-expand-md > .container-md, + .navbar-expand-md > .container-lg, + .navbar-expand-md > .container-xl { + flex-wrap: nowrap; + } + .navbar-expand-md .navbar-nav-scroll { + overflow: visible; + } + .navbar-expand-md .navbar-collapse { + display: flex !important; + flex-basis: auto; + } + .navbar-expand-md .navbar-toggler { + display: none; + } +} +@media (max-width: 991.98px) { + .navbar-expand-lg > .container, + .navbar-expand-lg > .container-fluid, + .navbar-expand-lg > .container-sm, + .navbar-expand-lg > .container-md, + .navbar-expand-lg > .container-lg, + .navbar-expand-lg > .container-xl { + padding-right: 0; + padding-left: 0; + } +} +@media (min-width: 992px) { + .navbar-expand-lg { + flex-flow: row nowrap; + justify-content: flex-start; + } + .navbar-expand-lg .navbar-nav { + flex-direction: row; + } + .navbar-expand-lg .navbar-nav .dropdown-menu { + position: absolute; + } + .navbar-expand-lg .navbar-nav .nav-link { + padding-right: 0.5rem; + padding-left: 0.5rem; + } + .navbar-expand-lg > .container, + .navbar-expand-lg > .container-fluid, + .navbar-expand-lg > .container-sm, + .navbar-expand-lg > .container-md, + .navbar-expand-lg > .container-lg, + .navbar-expand-lg > .container-xl { + flex-wrap: nowrap; + } + .navbar-expand-lg .navbar-nav-scroll { + overflow: visible; + } + .navbar-expand-lg .navbar-collapse { + display: flex !important; + flex-basis: auto; + } + .navbar-expand-lg .navbar-toggler { + display: none; + } +} +@media (max-width: 1199.98px) { + .navbar-expand-xl > .container, + .navbar-expand-xl > .container-fluid, + .navbar-expand-xl > .container-sm, + .navbar-expand-xl > .container-md, + .navbar-expand-xl > .container-lg, + .navbar-expand-xl > .container-xl { + padding-right: 0; + padding-left: 0; + } +} +@media (min-width: 1200px) { + .navbar-expand-xl { + flex-flow: row nowrap; + justify-content: flex-start; + } + .navbar-expand-xl .navbar-nav { + flex-direction: row; + } + .navbar-expand-xl .navbar-nav .dropdown-menu { + position: absolute; + } + .navbar-expand-xl .navbar-nav .nav-link { + padding-right: 0.5rem; + padding-left: 0.5rem; + } + .navbar-expand-xl > .container, + .navbar-expand-xl > .container-fluid, + .navbar-expand-xl > .container-sm, + .navbar-expand-xl > .container-md, + .navbar-expand-xl > .container-lg, + .navbar-expand-xl > .container-xl { + flex-wrap: nowrap; + } + .navbar-expand-xl .navbar-nav-scroll { + overflow: visible; + } + .navbar-expand-xl .navbar-collapse { + display: flex !important; + flex-basis: auto; + } + .navbar-expand-xl .navbar-toggler { + display: none; + } +} +.navbar-expand { + flex-flow: row nowrap; + justify-content: flex-start; +} +.navbar-expand > .container, +.navbar-expand > .container-fluid, +.navbar-expand > .container-sm, +.navbar-expand > .container-md, +.navbar-expand > .container-lg, +.navbar-expand > .container-xl { + padding-right: 0; + padding-left: 0; +} +.navbar-expand .navbar-nav { + flex-direction: row; +} +.navbar-expand .navbar-nav .dropdown-menu { + position: absolute; +} +.navbar-expand .navbar-nav .nav-link { + padding-right: 0.5rem; + padding-left: 0.5rem; +} +.navbar-expand > .container, +.navbar-expand > .container-fluid, +.navbar-expand > .container-sm, +.navbar-expand > .container-md, +.navbar-expand > .container-lg, +.navbar-expand > .container-xl { + flex-wrap: nowrap; +} +.navbar-expand .navbar-nav-scroll { + overflow: visible; +} +.navbar-expand .navbar-collapse { + display: flex !important; + flex-basis: auto; +} +.navbar-expand .navbar-toggler { + display: none; +} + +.navbar-light .navbar-brand { + color: rgba(0, 0, 0, 0.9); +} +.navbar-light .navbar-brand:hover, .navbar-light .navbar-brand:focus { + color: rgba(0, 0, 0, 0.9); +} +.navbar-light .navbar-nav .nav-link { + color: rgba(0, 0, 0, 0.5); +} +.navbar-light .navbar-nav .nav-link:hover, .navbar-light .navbar-nav .nav-link:focus { + color: rgba(0, 0, 0, 0.7); +} +.navbar-light .navbar-nav .nav-link.disabled { + color: rgba(0, 0, 0, 0.3); +} +.navbar-light .navbar-nav .show > .nav-link, +.navbar-light .navbar-nav .active > .nav-link, +.navbar-light .navbar-nav .nav-link.show, +.navbar-light .navbar-nav .nav-link.active { + color: rgba(0, 0, 0, 0.9); +} +.navbar-light .navbar-toggler { + color: rgba(0, 0, 0, 0.5); + border-color: rgba(0, 0, 0, 0.1); +} +.navbar-light .navbar-toggler-icon { + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_6___}); +} +.navbar-light .navbar-text { + color: rgba(0, 0, 0, 0.5); +} +.navbar-light .navbar-text a { + color: rgba(0, 0, 0, 0.9); +} +.navbar-light .navbar-text a:hover, .navbar-light .navbar-text a:focus { + color: rgba(0, 0, 0, 0.9); +} + +.navbar-dark .navbar-brand { + color: #fff; +} +.navbar-dark .navbar-brand:hover, .navbar-dark .navbar-brand:focus { + color: #fff; +} +.navbar-dark .navbar-nav .nav-link { + color: rgba(255, 255, 255, 0.5); +} +.navbar-dark .navbar-nav .nav-link:hover, .navbar-dark .navbar-nav .nav-link:focus { + color: rgba(255, 255, 255, 0.75); +} +.navbar-dark .navbar-nav .nav-link.disabled { + color: rgba(255, 255, 255, 0.25); +} +.navbar-dark .navbar-nav .show > .nav-link, +.navbar-dark .navbar-nav .active > .nav-link, +.navbar-dark .navbar-nav .nav-link.show, +.navbar-dark .navbar-nav .nav-link.active { + color: #fff; +} +.navbar-dark .navbar-toggler { + color: rgba(255, 255, 255, 0.5); + border-color: rgba(255, 255, 255, 0.1); +} +.navbar-dark .navbar-toggler-icon { + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_7___}); +} +.navbar-dark .navbar-text { + color: rgba(255, 255, 255, 0.5); +} +.navbar-dark .navbar-text a { + color: #fff; +} +.navbar-dark .navbar-text a:hover, .navbar-dark .navbar-text a:focus { + color: #fff; +} + +.card { + position: relative; + display: flex; + flex-direction: column; + min-width: 0; + word-wrap: break-word; + background-color: #fff; + background-clip: border-box; + border: 1px solid rgba(0, 0, 0, 0.125); + border-radius: 0.25rem; +} +.card > hr { + margin-right: 0; + margin-left: 0; +} +.card > .list-group { + border-top: inherit; + border-bottom: inherit; +} +.card > .list-group:first-child { + border-top-width: 0; + border-top-left-radius: calc(0.25rem - 1px); + border-top-right-radius: calc(0.25rem - 1px); +} +.card > .list-group:last-child { + border-bottom-width: 0; + border-bottom-right-radius: calc(0.25rem - 1px); + border-bottom-left-radius: calc(0.25rem - 1px); +} +.card > .card-header + .list-group, +.card > .list-group + .card-footer { + border-top: 0; +} + +.card-body { + flex: 1 1 auto; + min-height: 1px; + padding: 1.25rem; +} + +.card-title { + margin-bottom: 0.75rem; +} + +.card-subtitle { + margin-top: -0.375rem; + margin-bottom: 0; +} + +.card-text:last-child { + margin-bottom: 0; +} + +.card-link:hover { + text-decoration: none; +} +.card-link + .card-link { + margin-left: 1.25rem; +} + +.card-header { + padding: 0.75rem 1.25rem; + margin-bottom: 0; + background-color: rgba(0, 0, 0, 0.03); + border-bottom: 1px solid rgba(0, 0, 0, 0.125); +} +.card-header:first-child { + border-radius: calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0; +} + +.card-footer { + padding: 0.75rem 1.25rem; + background-color: rgba(0, 0, 0, 0.03); + border-top: 1px solid rgba(0, 0, 0, 0.125); +} +.card-footer:last-child { + border-radius: 0 0 calc(0.25rem - 1px) calc(0.25rem - 1px); +} + +.card-header-tabs { + margin-right: -0.625rem; + margin-bottom: -0.75rem; + margin-left: -0.625rem; + border-bottom: 0; +} + +.card-header-pills { + margin-right: -0.625rem; + margin-left: -0.625rem; +} + +.card-img-overlay { + position: absolute; + top: 0; + right: 0; + bottom: 0; + left: 0; + padding: 1.25rem; + border-radius: calc(0.25rem - 1px); +} + +.card-img, +.card-img-top, +.card-img-bottom { + flex-shrink: 0; + width: 100%; +} + +.card-img, +.card-img-top { + border-top-left-radius: calc(0.25rem - 1px); + border-top-right-radius: calc(0.25rem - 1px); +} + +.card-img, +.card-img-bottom { + border-bottom-right-radius: calc(0.25rem - 1px); + border-bottom-left-radius: calc(0.25rem - 1px); +} + +.card-deck .card { + margin-bottom: 15px; +} +@media (min-width: 576px) { + .card-deck { + display: flex; + flex-flow: row wrap; + margin-right: -15px; + margin-left: -15px; + } + .card-deck .card { + flex: 1 0 0%; + margin-right: 15px; + margin-bottom: 0; + margin-left: 15px; + } +} + +.card-group > .card { + margin-bottom: 15px; +} +@media (min-width: 576px) { + .card-group { + display: flex; + flex-flow: row wrap; + } + .card-group > .card { + flex: 1 0 0%; + margin-bottom: 0; + } + .card-group > .card + .card { + margin-left: 0; + border-left: 0; + } + .card-group > .card:not(:last-child) { + border-top-right-radius: 0; + border-bottom-right-radius: 0; + } + .card-group > .card:not(:last-child) .card-img-top, + .card-group > .card:not(:last-child) .card-header { + border-top-right-radius: 0; + } + .card-group > .card:not(:last-child) .card-img-bottom, + .card-group > .card:not(:last-child) .card-footer { + border-bottom-right-radius: 0; + } + .card-group > .card:not(:first-child) { + border-top-left-radius: 0; + border-bottom-left-radius: 0; + } + .card-group > .card:not(:first-child) .card-img-top, + .card-group > .card:not(:first-child) .card-header { + border-top-left-radius: 0; + } + .card-group > .card:not(:first-child) .card-img-bottom, + .card-group > .card:not(:first-child) .card-footer { + border-bottom-left-radius: 0; + } +} + +.card-columns .card { + margin-bottom: 0.75rem; +} +@media (min-width: 576px) { + .card-columns { + column-count: 3; + column-gap: 1.25rem; + orphans: 1; + widows: 1; + } + .card-columns .card { + display: inline-block; + width: 100%; + } +} + +.accordion { + overflow-anchor: none; +} +.accordion > .card { + overflow: hidden; +} +.accordion > .card:not(:last-of-type) { + border-bottom: 0; + border-bottom-right-radius: 0; + border-bottom-left-radius: 0; +} +.accordion > .card:not(:first-of-type) { + border-top-left-radius: 0; + border-top-right-radius: 0; +} +.accordion > .card > .card-header { + border-radius: 0; + margin-bottom: -1px; +} + +.breadcrumb { + display: flex; + flex-wrap: wrap; + padding: 0.75rem 1rem; + margin-bottom: 1rem; + list-style: none; + background-color: #e9ecef; + border-radius: 0.25rem; +} + +.breadcrumb-item + .breadcrumb-item { + padding-left: 0.5rem; +} +.breadcrumb-item + .breadcrumb-item::before { + float: left; + padding-right: 0.5rem; + color: #6c757d; + content: "/"; +} +.breadcrumb-item + .breadcrumb-item:hover::before { + text-decoration: underline; +} +.breadcrumb-item + .breadcrumb-item:hover::before { + text-decoration: none; +} +.breadcrumb-item.active { + color: #6c757d; +} + +.pagination { + display: flex; + padding-left: 0; + list-style: none; + border-radius: 0.25rem; +} + +.page-link { + position: relative; + display: block; + padding: 0.5rem 0.75rem; + margin-left: -1px; + line-height: 1.25; + color: #007bff; + background-color: #fff; + border: 1px solid #dee2e6; +} +.page-link:hover { + z-index: 2; + color: #0056b3; + text-decoration: none; + background-color: #e9ecef; + border-color: #dee2e6; +} +.page-link:focus { + z-index: 3; + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25); +} + +.page-item:first-child .page-link { + margin-left: 0; + border-top-left-radius: 0.25rem; + border-bottom-left-radius: 0.25rem; +} +.page-item:last-child .page-link { + border-top-right-radius: 0.25rem; + border-bottom-right-radius: 0.25rem; +} +.page-item.active .page-link { + z-index: 3; + color: #fff; + background-color: #007bff; + border-color: #007bff; +} +.page-item.disabled .page-link { + color: #6c757d; + pointer-events: none; + cursor: auto; + background-color: #fff; + border-color: #dee2e6; +} + +.pagination-lg .page-link { + padding: 0.75rem 1.5rem; + font-size: 1.25rem; + line-height: 1.5; +} +.pagination-lg .page-item:first-child .page-link { + border-top-left-radius: 0.3rem; + border-bottom-left-radius: 0.3rem; +} +.pagination-lg .page-item:last-child .page-link { + border-top-right-radius: 0.3rem; + border-bottom-right-radius: 0.3rem; +} + +.pagination-sm .page-link { + padding: 0.25rem 0.5rem; + font-size: 0.875rem; + line-height: 1.5; +} +.pagination-sm .page-item:first-child .page-link { + border-top-left-radius: 0.2rem; + border-bottom-left-radius: 0.2rem; +} +.pagination-sm .page-item:last-child .page-link { + border-top-right-radius: 0.2rem; + border-bottom-right-radius: 0.2rem; +} + +.badge { + display: inline-block; + padding: 0.25em 0.4em; + font-size: 75%; + font-weight: 700; + line-height: 1; + text-align: center; + white-space: nowrap; + vertical-align: baseline; + border-radius: 0.25rem; + transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out; +} +@media (prefers-reduced-motion: reduce) { + .badge { + transition: none; + } +} +a.badge:hover, a.badge:focus { + text-decoration: none; +} + +.badge:empty { + display: none; +} + +.btn .badge { + position: relative; + top: -1px; +} + +.badge-pill { + padding-right: 0.6em; + padding-left: 0.6em; + border-radius: 10rem; +} + +.badge-primary { + color: #fff; + background-color: #007bff; +} +a.badge-primary:hover, a.badge-primary:focus { + color: #fff; + background-color: #0062cc; +} +a.badge-primary:focus, a.badge-primary.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.5); +} + +.badge-secondary { + color: #fff; + background-color: #6c757d; +} +a.badge-secondary:hover, a.badge-secondary:focus { + color: #fff; + background-color: #545b62; +} +a.badge-secondary:focus, a.badge-secondary.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(108, 117, 125, 0.5); +} + +.badge-success { + color: #fff; + background-color: #28a745; +} +a.badge-success:hover, a.badge-success:focus { + color: #fff; + background-color: #1e7e34; +} +a.badge-success:focus, a.badge-success.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.5); +} + +.badge-info { + color: #fff; + background-color: #17a2b8; +} +a.badge-info:hover, a.badge-info:focus { + color: #fff; + background-color: #117a8b; +} +a.badge-info:focus, a.badge-info.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(23, 162, 184, 0.5); +} + +.badge-warning { + color: #212529; + background-color: #ffc107; +} +a.badge-warning:hover, a.badge-warning:focus { + color: #212529; + background-color: #d39e00; +} +a.badge-warning:focus, a.badge-warning.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(255, 193, 7, 0.5); +} + +.badge-danger { + color: #fff; + background-color: #dc3545; +} +a.badge-danger:hover, a.badge-danger:focus { + color: #fff; + background-color: #bd2130; +} +a.badge-danger:focus, a.badge-danger.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.5); +} + +.badge-light { + color: #212529; + background-color: #f8f9fa; +} +a.badge-light:hover, a.badge-light:focus { + color: #212529; + background-color: #dae0e5; +} +a.badge-light:focus, a.badge-light.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(248, 249, 250, 0.5); +} + +.badge-dark { + color: #fff; + background-color: #343a40; +} +a.badge-dark:hover, a.badge-dark:focus { + color: #fff; + background-color: #1d2124; +} +a.badge-dark:focus, a.badge-dark.focus { + outline: 0; + box-shadow: 0 0 0 0.2rem rgba(52, 58, 64, 0.5); +} + +.jumbotron { + padding: 2rem 1rem; + margin-bottom: 2rem; + background-color: #e9ecef; + border-radius: 0.3rem; +} +@media (min-width: 576px) { + .jumbotron { + padding: 4rem 2rem; + } +} + +.jumbotron-fluid { + padding-right: 0; + padding-left: 0; + border-radius: 0; +} + +.alert { + position: relative; + padding: 0.75rem 1.25rem; + margin-bottom: 1rem; + border: 1px solid transparent; + border-radius: 0.25rem; +} + +.alert-heading { + color: inherit; +} + +.alert-link { + font-weight: 700; +} + +.alert-dismissible { + padding-right: 4rem; +} +.alert-dismissible .close { + position: absolute; + top: 0; + right: 0; + z-index: 2; + padding: 0.75rem 1.25rem; + color: inherit; +} + +.alert-primary { + color: #004085; + background-color: #cce5ff; + border-color: #b8daff; +} +.alert-primary hr { + border-top-color: #9fcdff; +} +.alert-primary .alert-link { + color: #002752; +} + +.alert-secondary { + color: #383d41; + background-color: #e2e3e5; + border-color: #d6d8db; +} +.alert-secondary hr { + border-top-color: #c8cbcf; +} +.alert-secondary .alert-link { + color: #202326; +} + +.alert-success { + color: #155724; + background-color: #d4edda; + border-color: #c3e6cb; +} +.alert-success hr { + border-top-color: #b1dfbb; +} +.alert-success .alert-link { + color: #0b2e13; +} + +.alert-info { + color: #0c5460; + background-color: #d1ecf1; + border-color: #bee5eb; +} +.alert-info hr { + border-top-color: #abdde5; +} +.alert-info .alert-link { + color: #062c33; +} + +.alert-warning { + color: #856404; + background-color: #fff3cd; + border-color: #ffeeba; +} +.alert-warning hr { + border-top-color: #ffe8a1; +} +.alert-warning .alert-link { + color: #533f03; +} + +.alert-danger { + color: #721c24; + background-color: #f8d7da; + border-color: #f5c6cb; +} +.alert-danger hr { + border-top-color: #f1b0b7; +} +.alert-danger .alert-link { + color: #491217; +} + +.alert-light { + color: #818182; + background-color: #fefefe; + border-color: #fdfdfe; +} +.alert-light hr { + border-top-color: #ececf6; +} +.alert-light .alert-link { + color: #686868; +} + +.alert-dark { + color: #1b1e21; + background-color: #d6d8d9; + border-color: #c6c8ca; +} +.alert-dark hr { + border-top-color: #b9bbbe; +} +.alert-dark .alert-link { + color: #040505; +} + +@keyframes progress-bar-stripes { + from { + background-position: 1rem 0; + } + to { + background-position: 0 0; + } +} +.progress { + display: flex; + height: 1rem; + overflow: hidden; + line-height: 0; + font-size: 0.75rem; + background-color: #e9ecef; + border-radius: 0.25rem; +} + +.progress-bar { + display: flex; + flex-direction: column; + justify-content: center; + overflow: hidden; + color: #fff; + text-align: center; + white-space: nowrap; + background-color: #007bff; + transition: width 0.6s ease; +} +@media (prefers-reduced-motion: reduce) { + .progress-bar { + transition: none; + } +} + +.progress-bar-striped { + background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-size: 1rem 1rem; +} + +.progress-bar-animated { + animation: 1s linear infinite progress-bar-stripes; +} +@media (prefers-reduced-motion: reduce) { + .progress-bar-animated { + animation: none; + } +} + +.media { + display: flex; + align-items: flex-start; +} + +.media-body { + flex: 1; +} + +.list-group { + display: flex; + flex-direction: column; + padding-left: 0; + margin-bottom: 0; + border-radius: 0.25rem; +} + +.list-group-item-action { + width: 100%; + color: #495057; + text-align: inherit; +} +.list-group-item-action:hover, .list-group-item-action:focus { + z-index: 1; + color: #495057; + text-decoration: none; + background-color: #f8f9fa; +} +.list-group-item-action:active { + color: #212529; + background-color: #e9ecef; +} + +.list-group-item { + position: relative; + display: block; + padding: 0.75rem 1.25rem; + background-color: #fff; + border: 1px solid rgba(0, 0, 0, 0.125); +} +.list-group-item:first-child { + border-top-left-radius: inherit; + border-top-right-radius: inherit; +} +.list-group-item:last-child { + border-bottom-right-radius: inherit; + border-bottom-left-radius: inherit; +} +.list-group-item.disabled, .list-group-item:disabled { + color: #6c757d; + pointer-events: none; + background-color: #fff; +} +.list-group-item.active { + z-index: 2; + color: #fff; + background-color: #007bff; + border-color: #007bff; +} +.list-group-item + .list-group-item { + border-top-width: 0; +} +.list-group-item + .list-group-item.active { + margin-top: -1px; + border-top-width: 1px; +} + +.list-group-horizontal { + flex-direction: row; +} +.list-group-horizontal > .list-group-item:first-child { + border-bottom-left-radius: 0.25rem; + border-top-right-radius: 0; +} +.list-group-horizontal > .list-group-item:last-child { + border-top-right-radius: 0.25rem; + border-bottom-left-radius: 0; +} +.list-group-horizontal > .list-group-item.active { + margin-top: 0; +} +.list-group-horizontal > .list-group-item + .list-group-item { + border-top-width: 1px; + border-left-width: 0; +} +.list-group-horizontal > .list-group-item + .list-group-item.active { + margin-left: -1px; + border-left-width: 1px; +} + +@media (min-width: 576px) { + .list-group-horizontal-sm { + flex-direction: row; + } + .list-group-horizontal-sm > .list-group-item:first-child { + border-bottom-left-radius: 0.25rem; + border-top-right-radius: 0; + } + .list-group-horizontal-sm > .list-group-item:last-child { + border-top-right-radius: 0.25rem; + border-bottom-left-radius: 0; + } + .list-group-horizontal-sm > .list-group-item.active { + margin-top: 0; + } + .list-group-horizontal-sm > .list-group-item + .list-group-item { + border-top-width: 1px; + border-left-width: 0; + } + .list-group-horizontal-sm > .list-group-item + .list-group-item.active { + margin-left: -1px; + border-left-width: 1px; + } +} +@media (min-width: 768px) { + .list-group-horizontal-md { + flex-direction: row; + } + .list-group-horizontal-md > .list-group-item:first-child { + border-bottom-left-radius: 0.25rem; + border-top-right-radius: 0; + } + .list-group-horizontal-md > .list-group-item:last-child { + border-top-right-radius: 0.25rem; + border-bottom-left-radius: 0; + } + .list-group-horizontal-md > .list-group-item.active { + margin-top: 0; + } + .list-group-horizontal-md > .list-group-item + .list-group-item { + border-top-width: 1px; + border-left-width: 0; + } + .list-group-horizontal-md > .list-group-item + .list-group-item.active { + margin-left: -1px; + border-left-width: 1px; + } +} +@media (min-width: 992px) { + .list-group-horizontal-lg { + flex-direction: row; + } + .list-group-horizontal-lg > .list-group-item:first-child { + border-bottom-left-radius: 0.25rem; + border-top-right-radius: 0; + } + .list-group-horizontal-lg > .list-group-item:last-child { + border-top-right-radius: 0.25rem; + border-bottom-left-radius: 0; + } + .list-group-horizontal-lg > .list-group-item.active { + margin-top: 0; + } + .list-group-horizontal-lg > .list-group-item + .list-group-item { + border-top-width: 1px; + border-left-width: 0; + } + .list-group-horizontal-lg > .list-group-item + .list-group-item.active { + margin-left: -1px; + border-left-width: 1px; + } +} +@media (min-width: 1200px) { + .list-group-horizontal-xl { + flex-direction: row; + } + .list-group-horizontal-xl > .list-group-item:first-child { + border-bottom-left-radius: 0.25rem; + border-top-right-radius: 0; + } + .list-group-horizontal-xl > .list-group-item:last-child { + border-top-right-radius: 0.25rem; + border-bottom-left-radius: 0; + } + .list-group-horizontal-xl > .list-group-item.active { + margin-top: 0; + } + .list-group-horizontal-xl > .list-group-item + .list-group-item { + border-top-width: 1px; + border-left-width: 0; + } + .list-group-horizontal-xl > .list-group-item + .list-group-item.active { + margin-left: -1px; + border-left-width: 1px; + } +} +.list-group-flush { + border-radius: 0; +} +.list-group-flush > .list-group-item { + border-width: 0 0 1px; +} +.list-group-flush > .list-group-item:last-child { + border-bottom-width: 0; +} + +.list-group-item-primary { + color: #004085; + background-color: #b8daff; +} +.list-group-item-primary.list-group-item-action:hover, .list-group-item-primary.list-group-item-action:focus { + color: #004085; + background-color: #9fcdff; +} +.list-group-item-primary.list-group-item-action.active { + color: #fff; + background-color: #004085; + border-color: #004085; +} + +.list-group-item-secondary { + color: #383d41; + background-color: #d6d8db; +} +.list-group-item-secondary.list-group-item-action:hover, .list-group-item-secondary.list-group-item-action:focus { + color: #383d41; + background-color: #c8cbcf; +} +.list-group-item-secondary.list-group-item-action.active { + color: #fff; + background-color: #383d41; + border-color: #383d41; +} + +.list-group-item-success { + color: #155724; + background-color: #c3e6cb; +} +.list-group-item-success.list-group-item-action:hover, .list-group-item-success.list-group-item-action:focus { + color: #155724; + background-color: #b1dfbb; +} +.list-group-item-success.list-group-item-action.active { + color: #fff; + background-color: #155724; + border-color: #155724; +} + +.list-group-item-info { + color: #0c5460; + background-color: #bee5eb; +} +.list-group-item-info.list-group-item-action:hover, .list-group-item-info.list-group-item-action:focus { + color: #0c5460; + background-color: #abdde5; +} +.list-group-item-info.list-group-item-action.active { + color: #fff; + background-color: #0c5460; + border-color: #0c5460; +} + +.list-group-item-warning { + color: #856404; + background-color: #ffeeba; +} +.list-group-item-warning.list-group-item-action:hover, .list-group-item-warning.list-group-item-action:focus { + color: #856404; + background-color: #ffe8a1; +} +.list-group-item-warning.list-group-item-action.active { + color: #fff; + background-color: #856404; + border-color: #856404; +} + +.list-group-item-danger { + color: #721c24; + background-color: #f5c6cb; +} +.list-group-item-danger.list-group-item-action:hover, .list-group-item-danger.list-group-item-action:focus { + color: #721c24; + background-color: #f1b0b7; +} +.list-group-item-danger.list-group-item-action.active { + color: #fff; + background-color: #721c24; + border-color: #721c24; +} + +.list-group-item-light { + color: #818182; + background-color: #fdfdfe; +} +.list-group-item-light.list-group-item-action:hover, .list-group-item-light.list-group-item-action:focus { + color: #818182; + background-color: #ececf6; +} +.list-group-item-light.list-group-item-action.active { + color: #fff; + background-color: #818182; + border-color: #818182; +} + +.list-group-item-dark { + color: #1b1e21; + background-color: #c6c8ca; +} +.list-group-item-dark.list-group-item-action:hover, .list-group-item-dark.list-group-item-action:focus { + color: #1b1e21; + background-color: #b9bbbe; +} +.list-group-item-dark.list-group-item-action.active { + color: #fff; + background-color: #1b1e21; + border-color: #1b1e21; +} + +.close { + float: right; + font-size: 1.5rem; + font-weight: 700; + line-height: 1; + color: #000; + text-shadow: 0 1px 0 #fff; + opacity: 0.5; +} +.close:hover { + color: #000; + text-decoration: none; +} +.close:not(:disabled):not(.disabled):hover, .close:not(:disabled):not(.disabled):focus { + opacity: 0.75; +} + +button.close { + padding: 0; + background-color: transparent; + border: 0; +} + +a.close.disabled { + pointer-events: none; +} + +.toast { + flex-basis: 350px; + max-width: 350px; + font-size: 0.875rem; + background-color: rgba(255, 255, 255, 0.85); + background-clip: padding-box; + border: 1px solid rgba(0, 0, 0, 0.1); + box-shadow: 0 0.25rem 0.75rem rgba(0, 0, 0, 0.1); + opacity: 0; + border-radius: 0.25rem; +} +.toast:not(:last-child) { + margin-bottom: 0.75rem; +} +.toast.showing { + opacity: 1; +} +.toast.show { + display: block; + opacity: 1; +} +.toast.hide { + display: none; +} + +.toast-header { + display: flex; + align-items: center; + padding: 0.25rem 0.75rem; + color: #6c757d; + background-color: rgba(255, 255, 255, 0.85); + background-clip: padding-box; + border-bottom: 1px solid rgba(0, 0, 0, 0.05); + border-top-left-radius: calc(0.25rem - 1px); + border-top-right-radius: calc(0.25rem - 1px); +} + +.toast-body { + padding: 0.75rem; +} + +.modal-open { + overflow: hidden; +} +.modal-open .modal { + overflow-x: hidden; + overflow-y: auto; +} + +.modal { + position: fixed; + top: 0; + left: 0; + z-index: 1050; + display: none; + width: 100%; + height: 100%; + overflow: hidden; + outline: 0; +} + +.modal-dialog { + position: relative; + width: auto; + margin: 0.5rem; + pointer-events: none; +} +.modal.fade .modal-dialog { + transition: transform 0.3s ease-out; + transform: translate(0, -50px); +} +@media (prefers-reduced-motion: reduce) { + .modal.fade .modal-dialog { + transition: none; + } +} +.modal.show .modal-dialog { + transform: none; +} +.modal.modal-static .modal-dialog { + transform: scale(1.02); +} + +.modal-dialog-scrollable { + display: flex; + max-height: calc(100% - 1rem); +} +.modal-dialog-scrollable .modal-content { + max-height: calc(100vh - 1rem); + overflow: hidden; +} +.modal-dialog-scrollable .modal-header, +.modal-dialog-scrollable .modal-footer { + flex-shrink: 0; +} +.modal-dialog-scrollable .modal-body { + overflow-y: auto; +} + +.modal-dialog-centered { + display: flex; + align-items: center; + min-height: calc(100% - 1rem); +} +.modal-dialog-centered::before { + display: block; + height: calc(100vh - 1rem); + height: min-content; + content: ""; +} +.modal-dialog-centered.modal-dialog-scrollable { + flex-direction: column; + justify-content: center; + height: 100%; +} +.modal-dialog-centered.modal-dialog-scrollable .modal-content { + max-height: none; +} +.modal-dialog-centered.modal-dialog-scrollable::before { + content: none; +} + +.modal-content { + position: relative; + display: flex; + flex-direction: column; + width: 100%; + pointer-events: auto; + background-color: #fff; + background-clip: padding-box; + border: 1px solid rgba(0, 0, 0, 0.2); + border-radius: 0.3rem; + outline: 0; +} + +.modal-backdrop { + position: fixed; + top: 0; + left: 0; + z-index: 1040; + width: 100vw; + height: 100vh; + background-color: #000; +} +.modal-backdrop.fade { + opacity: 0; +} +.modal-backdrop.show { + opacity: 0.5; +} + +.modal-header { + display: flex; + align-items: flex-start; + justify-content: space-between; + padding: 1rem 1rem; + border-bottom: 1px solid #dee2e6; + border-top-left-radius: calc(0.3rem - 1px); + border-top-right-radius: calc(0.3rem - 1px); +} +.modal-header .close { + padding: 1rem 1rem; + margin: -1rem -1rem -1rem auto; +} + +.modal-title { + margin-bottom: 0; + line-height: 1.5; +} + +.modal-body { + position: relative; + flex: 1 1 auto; + padding: 1rem; +} + +.modal-footer { + display: flex; + flex-wrap: wrap; + align-items: center; + justify-content: flex-end; + padding: 0.75rem; + border-top: 1px solid #dee2e6; + border-bottom-right-radius: calc(0.3rem - 1px); + border-bottom-left-radius: calc(0.3rem - 1px); +} +.modal-footer > * { + margin: 0.25rem; +} + +.modal-scrollbar-measure { + position: absolute; + top: -9999px; + width: 50px; + height: 50px; + overflow: scroll; +} + +@media (min-width: 576px) { + .modal-dialog { + max-width: 500px; + margin: 1.75rem auto; + } + .modal-dialog-scrollable { + max-height: calc(100% - 3.5rem); + } + .modal-dialog-scrollable .modal-content { + max-height: calc(100vh - 3.5rem); + } + .modal-dialog-centered { + min-height: calc(100% - 3.5rem); + } + .modal-dialog-centered::before { + height: calc(100vh - 3.5rem); + height: min-content; + } + .modal-sm { + max-width: 300px; + } +} +@media (min-width: 992px) { + .modal-lg, + .modal-xl { + max-width: 800px; + } +} +@media (min-width: 1200px) { + .modal-xl { + max-width: 1140px; + } +} +.tooltip { + position: absolute; + z-index: 1070; + display: block; + margin: 0; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; + font-style: normal; + font-weight: 400; + line-height: 1.5; + text-align: left; + text-align: start; + text-decoration: none; + text-shadow: none; + text-transform: none; + letter-spacing: normal; + word-break: normal; + white-space: normal; + word-spacing: normal; + line-break: auto; + font-size: 0.875rem; + word-wrap: break-word; + opacity: 0; +} +.tooltip.show { + opacity: 0.9; +} +.tooltip .arrow { + position: absolute; + display: block; + width: 0.8rem; + height: 0.4rem; +} +.tooltip .arrow::before { + position: absolute; + content: ""; + border-color: transparent; + border-style: solid; +} + +.bs-tooltip-top, .bs-tooltip-auto[x-placement^=top] { + padding: 0.4rem 0; +} +.bs-tooltip-top .arrow, .bs-tooltip-auto[x-placement^=top] .arrow { + bottom: 0; +} +.bs-tooltip-top .arrow::before, .bs-tooltip-auto[x-placement^=top] .arrow::before { + top: 0; + border-width: 0.4rem 0.4rem 0; + border-top-color: #000; +} + +.bs-tooltip-right, .bs-tooltip-auto[x-placement^=right] { + padding: 0 0.4rem; +} +.bs-tooltip-right .arrow, .bs-tooltip-auto[x-placement^=right] .arrow { + left: 0; + width: 0.4rem; + height: 0.8rem; +} +.bs-tooltip-right .arrow::before, .bs-tooltip-auto[x-placement^=right] .arrow::before { + right: 0; + border-width: 0.4rem 0.4rem 0.4rem 0; + border-right-color: #000; +} + +.bs-tooltip-bottom, .bs-tooltip-auto[x-placement^=bottom] { + padding: 0.4rem 0; +} +.bs-tooltip-bottom .arrow, .bs-tooltip-auto[x-placement^=bottom] .arrow { + top: 0; +} +.bs-tooltip-bottom .arrow::before, .bs-tooltip-auto[x-placement^=bottom] .arrow::before { + bottom: 0; + border-width: 0 0.4rem 0.4rem; + border-bottom-color: #000; +} + +.bs-tooltip-left, .bs-tooltip-auto[x-placement^=left] { + padding: 0 0.4rem; +} +.bs-tooltip-left .arrow, .bs-tooltip-auto[x-placement^=left] .arrow { + right: 0; + width: 0.4rem; + height: 0.8rem; +} +.bs-tooltip-left .arrow::before, .bs-tooltip-auto[x-placement^=left] .arrow::before { + left: 0; + border-width: 0.4rem 0 0.4rem 0.4rem; + border-left-color: #000; +} + +.tooltip-inner { + max-width: 200px; + padding: 0.25rem 0.5rem; + color: #fff; + text-align: center; + background-color: #000; + border-radius: 0.25rem; +} + +.popover { + position: absolute; + top: 0; + left: 0; + z-index: 1060; + display: block; + max-width: 276px; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; + font-style: normal; + font-weight: 400; + line-height: 1.5; + text-align: left; + text-align: start; + text-decoration: none; + text-shadow: none; + text-transform: none; + letter-spacing: normal; + word-break: normal; + white-space: normal; + word-spacing: normal; + line-break: auto; + font-size: 0.875rem; + word-wrap: break-word; + background-color: #fff; + background-clip: padding-box; + border: 1px solid rgba(0, 0, 0, 0.2); + border-radius: 0.3rem; +} +.popover .arrow { + position: absolute; + display: block; + width: 1rem; + height: 0.5rem; + margin: 0 0.3rem; +} +.popover .arrow::before, .popover .arrow::after { + position: absolute; + display: block; + content: ""; + border-color: transparent; + border-style: solid; +} + +.bs-popover-top, .bs-popover-auto[x-placement^=top] { + margin-bottom: 0.5rem; +} +.bs-popover-top > .arrow, .bs-popover-auto[x-placement^=top] > .arrow { + bottom: calc(-0.5rem - 1px); +} +.bs-popover-top > .arrow::before, .bs-popover-auto[x-placement^=top] > .arrow::before { + bottom: 0; + border-width: 0.5rem 0.5rem 0; + border-top-color: rgba(0, 0, 0, 0.25); +} +.bs-popover-top > .arrow::after, .bs-popover-auto[x-placement^=top] > .arrow::after { + bottom: 1px; + border-width: 0.5rem 0.5rem 0; + border-top-color: #fff; +} + +.bs-popover-right, .bs-popover-auto[x-placement^=right] { + margin-left: 0.5rem; +} +.bs-popover-right > .arrow, .bs-popover-auto[x-placement^=right] > .arrow { + left: calc(-0.5rem - 1px); + width: 0.5rem; + height: 1rem; + margin: 0.3rem 0; +} +.bs-popover-right > .arrow::before, .bs-popover-auto[x-placement^=right] > .arrow::before { + left: 0; + border-width: 0.5rem 0.5rem 0.5rem 0; + border-right-color: rgba(0, 0, 0, 0.25); +} +.bs-popover-right > .arrow::after, .bs-popover-auto[x-placement^=right] > .arrow::after { + left: 1px; + border-width: 0.5rem 0.5rem 0.5rem 0; + border-right-color: #fff; +} + +.bs-popover-bottom, .bs-popover-auto[x-placement^=bottom] { + margin-top: 0.5rem; +} +.bs-popover-bottom > .arrow, .bs-popover-auto[x-placement^=bottom] > .arrow { + top: calc(-0.5rem - 1px); +} +.bs-popover-bottom > .arrow::before, .bs-popover-auto[x-placement^=bottom] > .arrow::before { + top: 0; + border-width: 0 0.5rem 0.5rem 0.5rem; + border-bottom-color: rgba(0, 0, 0, 0.25); +} +.bs-popover-bottom > .arrow::after, .bs-popover-auto[x-placement^=bottom] > .arrow::after { + top: 1px; + border-width: 0 0.5rem 0.5rem 0.5rem; + border-bottom-color: #fff; +} +.bs-popover-bottom .popover-header::before, .bs-popover-auto[x-placement^=bottom] .popover-header::before { + position: absolute; + top: 0; + left: 50%; + display: block; + width: 1rem; + margin-left: -0.5rem; + content: ""; + border-bottom: 1px solid #f7f7f7; +} + +.bs-popover-left, .bs-popover-auto[x-placement^=left] { + margin-right: 0.5rem; +} +.bs-popover-left > .arrow, .bs-popover-auto[x-placement^=left] > .arrow { + right: calc(-0.5rem - 1px); + width: 0.5rem; + height: 1rem; + margin: 0.3rem 0; +} +.bs-popover-left > .arrow::before, .bs-popover-auto[x-placement^=left] > .arrow::before { + right: 0; + border-width: 0.5rem 0 0.5rem 0.5rem; + border-left-color: rgba(0, 0, 0, 0.25); +} +.bs-popover-left > .arrow::after, .bs-popover-auto[x-placement^=left] > .arrow::after { + right: 1px; + border-width: 0.5rem 0 0.5rem 0.5rem; + border-left-color: #fff; +} + +.popover-header { + padding: 0.5rem 0.75rem; + margin-bottom: 0; + font-size: 1rem; + background-color: #f7f7f7; + border-bottom: 1px solid #ebebeb; + border-top-left-radius: calc(0.3rem - 1px); + border-top-right-radius: calc(0.3rem - 1px); +} +.popover-header:empty { + display: none; +} + +.popover-body { + padding: 0.5rem 0.75rem; + color: #212529; +} + +.carousel { + position: relative; +} + +.carousel.pointer-event { + touch-action: pan-y; +} + +.carousel-inner { + position: relative; + width: 100%; + overflow: hidden; +} +.carousel-inner::after { + display: block; + clear: both; + content: ""; +} + +.carousel-item { + position: relative; + display: none; + float: left; + width: 100%; + margin-right: -100%; + backface-visibility: hidden; + transition: transform 0.6s ease-in-out; +} +@media (prefers-reduced-motion: reduce) { + .carousel-item { + transition: none; + } +} + +.carousel-item.active, +.carousel-item-next, +.carousel-item-prev { + display: block; +} + +.carousel-item-next:not(.carousel-item-left), +.active.carousel-item-right { + transform: translateX(100%); +} + +.carousel-item-prev:not(.carousel-item-right), +.active.carousel-item-left { + transform: translateX(-100%); +} + +.carousel-fade .carousel-item { + opacity: 0; + transition-property: opacity; + transform: none; +} +.carousel-fade .carousel-item.active, +.carousel-fade .carousel-item-next.carousel-item-left, +.carousel-fade .carousel-item-prev.carousel-item-right { + z-index: 1; + opacity: 1; +} +.carousel-fade .active.carousel-item-left, +.carousel-fade .active.carousel-item-right { + z-index: 0; + opacity: 0; + transition: opacity 0s 0.6s; +} +@media (prefers-reduced-motion: reduce) { + .carousel-fade .active.carousel-item-left, + .carousel-fade .active.carousel-item-right { + transition: none; + } +} + +.carousel-control-prev, +.carousel-control-next { + position: absolute; + top: 0; + bottom: 0; + z-index: 1; + display: flex; + align-items: center; + justify-content: center; + width: 15%; + padding: 0; + color: #fff; + text-align: center; + background: none; + border: 0; + opacity: 0.5; + transition: opacity 0.15s ease; +} +@media (prefers-reduced-motion: reduce) { + .carousel-control-prev, + .carousel-control-next { + transition: none; + } +} +.carousel-control-prev:hover, .carousel-control-prev:focus, +.carousel-control-next:hover, +.carousel-control-next:focus { + color: #fff; + text-decoration: none; + outline: 0; + opacity: 0.9; +} + +.carousel-control-prev { + left: 0; +} + +.carousel-control-next { + right: 0; +} + +.carousel-control-prev-icon, +.carousel-control-next-icon { + display: inline-block; + width: 20px; + height: 20px; + background: 50%/100% 100% no-repeat; +} + +.carousel-control-prev-icon { + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_8___}); +} + +.carousel-control-next-icon { + background-image: url(${___CSS_LOADER_URL_REPLACEMENT_9___}); +} + +.carousel-indicators { + position: absolute; + right: 0; + bottom: 0; + left: 0; + z-index: 15; + display: flex; + justify-content: center; + padding-left: 0; + margin-right: 15%; + margin-left: 15%; + list-style: none; +} +.carousel-indicators li { + box-sizing: content-box; + flex: 0 1 auto; + width: 30px; + height: 3px; + margin-right: 3px; + margin-left: 3px; + text-indent: -999px; + cursor: pointer; + background-color: #fff; + background-clip: padding-box; + border-top: 10px solid transparent; + border-bottom: 10px solid transparent; + opacity: 0.5; + transition: opacity 0.6s ease; +} +@media (prefers-reduced-motion: reduce) { + .carousel-indicators li { + transition: none; + } +} +.carousel-indicators .active { + opacity: 1; +} + +.carousel-caption { + position: absolute; + right: 15%; + bottom: 20px; + left: 15%; + z-index: 10; + padding-top: 20px; + padding-bottom: 20px; + color: #fff; + text-align: center; +} + +@keyframes spinner-border { + to { + transform: rotate(360deg); + } +} +.spinner-border { + display: inline-block; + width: 2rem; + height: 2rem; + vertical-align: -0.125em; + border: 0.25em solid currentcolor; + border-right-color: transparent; + border-radius: 50%; + animation: 0.75s linear infinite spinner-border; +} + +.spinner-border-sm { + width: 1rem; + height: 1rem; + border-width: 0.2em; +} + +@keyframes spinner-grow { + 0% { + transform: scale(0); + } + 50% { + opacity: 1; + transform: none; + } +} +.spinner-grow { + display: inline-block; + width: 2rem; + height: 2rem; + vertical-align: -0.125em; + background-color: currentcolor; + border-radius: 50%; + opacity: 0; + animation: 0.75s linear infinite spinner-grow; +} + +.spinner-grow-sm { + width: 1rem; + height: 1rem; +} + +@media (prefers-reduced-motion: reduce) { + .spinner-border, + .spinner-grow { + animation-duration: 1.5s; + } +} +.align-baseline { + vertical-align: baseline !important; +} + +.align-top { + vertical-align: top !important; +} + +.align-middle { + vertical-align: middle !important; +} + +.align-bottom { + vertical-align: bottom !important; +} + +.align-text-bottom { + vertical-align: text-bottom !important; +} + +.align-text-top { + vertical-align: text-top !important; +} + +.bg-primary { + background-color: #007bff !important; +} + +a.bg-primary:hover, a.bg-primary:focus, +button.bg-primary:hover, +button.bg-primary:focus { + background-color: #0062cc !important; +} + +.bg-secondary { + background-color: #6c757d !important; +} + +a.bg-secondary:hover, a.bg-secondary:focus, +button.bg-secondary:hover, +button.bg-secondary:focus { + background-color: #545b62 !important; +} + +.bg-success { + background-color: #28a745 !important; +} + +a.bg-success:hover, a.bg-success:focus, +button.bg-success:hover, +button.bg-success:focus { + background-color: #1e7e34 !important; +} + +.bg-info { + background-color: #17a2b8 !important; +} + +a.bg-info:hover, a.bg-info:focus, +button.bg-info:hover, +button.bg-info:focus { + background-color: #117a8b !important; +} + +.bg-warning { + background-color: #ffc107 !important; +} + +a.bg-warning:hover, a.bg-warning:focus, +button.bg-warning:hover, +button.bg-warning:focus { + background-color: #d39e00 !important; +} + +.bg-danger { + background-color: #dc3545 !important; +} + +a.bg-danger:hover, a.bg-danger:focus, +button.bg-danger:hover, +button.bg-danger:focus { + background-color: #bd2130 !important; +} + +.bg-light { + background-color: #f8f9fa !important; +} + +a.bg-light:hover, a.bg-light:focus, +button.bg-light:hover, +button.bg-light:focus { + background-color: #dae0e5 !important; +} + +.bg-dark { + background-color: #343a40 !important; +} + +a.bg-dark:hover, a.bg-dark:focus, +button.bg-dark:hover, +button.bg-dark:focus { + background-color: #1d2124 !important; +} + +.bg-white { + background-color: #fff !important; +} + +.bg-transparent { + background-color: transparent !important; +} + +.border { + border: 1px solid #dee2e6 !important; +} + +.border-top { + border-top: 1px solid #dee2e6 !important; +} + +.border-right { + border-right: 1px solid #dee2e6 !important; +} + +.border-bottom { + border-bottom: 1px solid #dee2e6 !important; +} + +.border-left { + border-left: 1px solid #dee2e6 !important; +} + +.border-0 { + border: 0 !important; +} + +.border-top-0 { + border-top: 0 !important; +} + +.border-right-0 { + border-right: 0 !important; +} + +.border-bottom-0 { + border-bottom: 0 !important; +} + +.border-left-0 { + border-left: 0 !important; +} + +.border-primary { + border-color: #007bff !important; +} + +.border-secondary { + border-color: #6c757d !important; +} + +.border-success { + border-color: #28a745 !important; +} + +.border-info { + border-color: #17a2b8 !important; +} + +.border-warning { + border-color: #ffc107 !important; +} + +.border-danger { + border-color: #dc3545 !important; +} + +.border-light { + border-color: #f8f9fa !important; +} + +.border-dark { + border-color: #343a40 !important; +} + +.border-white { + border-color: #fff !important; +} + +.rounded-sm { + border-radius: 0.2rem !important; +} + +.rounded { + border-radius: 0.25rem !important; +} + +.rounded-top { + border-top-left-radius: 0.25rem !important; + border-top-right-radius: 0.25rem !important; +} + +.rounded-right { + border-top-right-radius: 0.25rem !important; + border-bottom-right-radius: 0.25rem !important; +} + +.rounded-bottom { + border-bottom-right-radius: 0.25rem !important; + border-bottom-left-radius: 0.25rem !important; +} + +.rounded-left { + border-top-left-radius: 0.25rem !important; + border-bottom-left-radius: 0.25rem !important; +} + +.rounded-lg { + border-radius: 0.3rem !important; +} + +.rounded-circle { + border-radius: 50% !important; +} + +.rounded-pill { + border-radius: 50rem !important; +} + +.rounded-0 { + border-radius: 0 !important; +} + +.clearfix::after { + display: block; + clear: both; + content: ""; +} + +.d-none { + display: none !important; +} + +.d-inline { + display: inline !important; +} + +.d-inline-block { + display: inline-block !important; +} + +.d-block { + display: block !important; +} + +.d-table { + display: table !important; +} + +.d-table-row { + display: table-row !important; +} + +.d-table-cell { + display: table-cell !important; +} + +.d-flex { + display: flex !important; +} + +.d-inline-flex { + display: inline-flex !important; +} + +@media (min-width: 576px) { + .d-sm-none { + display: none !important; + } + .d-sm-inline { + display: inline !important; + } + .d-sm-inline-block { + display: inline-block !important; + } + .d-sm-block { + display: block !important; + } + .d-sm-table { + display: table !important; + } + .d-sm-table-row { + display: table-row !important; + } + .d-sm-table-cell { + display: table-cell !important; + } + .d-sm-flex { + display: flex !important; + } + .d-sm-inline-flex { + display: inline-flex !important; + } +} +@media (min-width: 768px) { + .d-md-none { + display: none !important; + } + .d-md-inline { + display: inline !important; + } + .d-md-inline-block { + display: inline-block !important; + } + .d-md-block { + display: block !important; + } + .d-md-table { + display: table !important; + } + .d-md-table-row { + display: table-row !important; + } + .d-md-table-cell { + display: table-cell !important; + } + .d-md-flex { + display: flex !important; + } + .d-md-inline-flex { + display: inline-flex !important; + } +} +@media (min-width: 992px) { + .d-lg-none { + display: none !important; + } + .d-lg-inline { + display: inline !important; + } + .d-lg-inline-block { + display: inline-block !important; + } + .d-lg-block { + display: block !important; + } + .d-lg-table { + display: table !important; + } + .d-lg-table-row { + display: table-row !important; + } + .d-lg-table-cell { + display: table-cell !important; + } + .d-lg-flex { + display: flex !important; + } + .d-lg-inline-flex { + display: inline-flex !important; + } +} +@media (min-width: 1200px) { + .d-xl-none { + display: none !important; + } + .d-xl-inline { + display: inline !important; + } + .d-xl-inline-block { + display: inline-block !important; + } + .d-xl-block { + display: block !important; + } + .d-xl-table { + display: table !important; + } + .d-xl-table-row { + display: table-row !important; + } + .d-xl-table-cell { + display: table-cell !important; + } + .d-xl-flex { + display: flex !important; + } + .d-xl-inline-flex { + display: inline-flex !important; + } +} +@media print { + .d-print-none { + display: none !important; + } + .d-print-inline { + display: inline !important; + } + .d-print-inline-block { + display: inline-block !important; + } + .d-print-block { + display: block !important; + } + .d-print-table { + display: table !important; + } + .d-print-table-row { + display: table-row !important; + } + .d-print-table-cell { + display: table-cell !important; + } + .d-print-flex { + display: flex !important; + } + .d-print-inline-flex { + display: inline-flex !important; + } +} +.embed-responsive { + position: relative; + display: block; + width: 100%; + padding: 0; + overflow: hidden; +} +.embed-responsive::before { + display: block; + content: ""; +} +.embed-responsive .embed-responsive-item, +.embed-responsive iframe, +.embed-responsive embed, +.embed-responsive object, +.embed-responsive video { + position: absolute; + top: 0; + bottom: 0; + left: 0; + width: 100%; + height: 100%; + border: 0; +} + +.embed-responsive-21by9::before { + padding-top: 42.85714286%; +} + +.embed-responsive-16by9::before { + padding-top: 56.25%; +} + +.embed-responsive-4by3::before { + padding-top: 75%; +} + +.embed-responsive-1by1::before { + padding-top: 100%; +} + +.flex-row { + flex-direction: row !important; +} + +.flex-column { + flex-direction: column !important; +} + +.flex-row-reverse { + flex-direction: row-reverse !important; +} + +.flex-column-reverse { + flex-direction: column-reverse !important; +} + +.flex-wrap { + flex-wrap: wrap !important; +} + +.flex-nowrap { + flex-wrap: nowrap !important; +} + +.flex-wrap-reverse { + flex-wrap: wrap-reverse !important; +} + +.flex-fill { + flex: 1 1 auto !important; +} + +.flex-grow-0 { + flex-grow: 0 !important; +} + +.flex-grow-1 { + flex-grow: 1 !important; +} + +.flex-shrink-0 { + flex-shrink: 0 !important; +} + +.flex-shrink-1 { + flex-shrink: 1 !important; +} + +.justify-content-start { + justify-content: flex-start !important; +} + +.justify-content-end { + justify-content: flex-end !important; +} + +.justify-content-center { + justify-content: center !important; +} + +.justify-content-between { + justify-content: space-between !important; +} + +.justify-content-around { + justify-content: space-around !important; +} + +.align-items-start { + align-items: flex-start !important; +} + +.align-items-end { + align-items: flex-end !important; +} + +.align-items-center { + align-items: center !important; +} + +.align-items-baseline { + align-items: baseline !important; +} + +.align-items-stretch { + align-items: stretch !important; +} + +.align-content-start { + align-content: flex-start !important; +} + +.align-content-end { + align-content: flex-end !important; +} + +.align-content-center { + align-content: center !important; +} + +.align-content-between { + align-content: space-between !important; +} + +.align-content-around { + align-content: space-around !important; +} + +.align-content-stretch { + align-content: stretch !important; +} + +.align-self-auto { + align-self: auto !important; +} + +.align-self-start { + align-self: flex-start !important; +} + +.align-self-end { + align-self: flex-end !important; +} + +.align-self-center { + align-self: center !important; +} + +.align-self-baseline { + align-self: baseline !important; +} + +.align-self-stretch { + align-self: stretch !important; +} + +@media (min-width: 576px) { + .flex-sm-row { + flex-direction: row !important; + } + .flex-sm-column { + flex-direction: column !important; + } + .flex-sm-row-reverse { + flex-direction: row-reverse !important; + } + .flex-sm-column-reverse { + flex-direction: column-reverse !important; + } + .flex-sm-wrap { + flex-wrap: wrap !important; + } + .flex-sm-nowrap { + flex-wrap: nowrap !important; + } + .flex-sm-wrap-reverse { + flex-wrap: wrap-reverse !important; + } + .flex-sm-fill { + flex: 1 1 auto !important; + } + .flex-sm-grow-0 { + flex-grow: 0 !important; + } + .flex-sm-grow-1 { + flex-grow: 1 !important; + } + .flex-sm-shrink-0 { + flex-shrink: 0 !important; + } + .flex-sm-shrink-1 { + flex-shrink: 1 !important; + } + .justify-content-sm-start { + justify-content: flex-start !important; + } + .justify-content-sm-end { + justify-content: flex-end !important; + } + .justify-content-sm-center { + justify-content: center !important; + } + .justify-content-sm-between { + justify-content: space-between !important; + } + .justify-content-sm-around { + justify-content: space-around !important; + } + .align-items-sm-start { + align-items: flex-start !important; + } + .align-items-sm-end { + align-items: flex-end !important; + } + .align-items-sm-center { + align-items: center !important; + } + .align-items-sm-baseline { + align-items: baseline !important; + } + .align-items-sm-stretch { + align-items: stretch !important; + } + .align-content-sm-start { + align-content: flex-start !important; + } + .align-content-sm-end { + align-content: flex-end !important; + } + .align-content-sm-center { + align-content: center !important; + } + .align-content-sm-between { + align-content: space-between !important; + } + .align-content-sm-around { + align-content: space-around !important; + } + .align-content-sm-stretch { + align-content: stretch !important; + } + .align-self-sm-auto { + align-self: auto !important; + } + .align-self-sm-start { + align-self: flex-start !important; + } + .align-self-sm-end { + align-self: flex-end !important; + } + .align-self-sm-center { + align-self: center !important; + } + .align-self-sm-baseline { + align-self: baseline !important; + } + .align-self-sm-stretch { + align-self: stretch !important; + } +} +@media (min-width: 768px) { + .flex-md-row { + flex-direction: row !important; + } + .flex-md-column { + flex-direction: column !important; + } + .flex-md-row-reverse { + flex-direction: row-reverse !important; + } + .flex-md-column-reverse { + flex-direction: column-reverse !important; + } + .flex-md-wrap { + flex-wrap: wrap !important; + } + .flex-md-nowrap { + flex-wrap: nowrap !important; + } + .flex-md-wrap-reverse { + flex-wrap: wrap-reverse !important; + } + .flex-md-fill { + flex: 1 1 auto !important; + } + .flex-md-grow-0 { + flex-grow: 0 !important; + } + .flex-md-grow-1 { + flex-grow: 1 !important; + } + .flex-md-shrink-0 { + flex-shrink: 0 !important; + } + .flex-md-shrink-1 { + flex-shrink: 1 !important; + } + .justify-content-md-start { + justify-content: flex-start !important; + } + .justify-content-md-end { + justify-content: flex-end !important; + } + .justify-content-md-center { + justify-content: center !important; + } + .justify-content-md-between { + justify-content: space-between !important; + } + .justify-content-md-around { + justify-content: space-around !important; + } + .align-items-md-start { + align-items: flex-start !important; + } + .align-items-md-end { + align-items: flex-end !important; + } + .align-items-md-center { + align-items: center !important; + } + .align-items-md-baseline { + align-items: baseline !important; + } + .align-items-md-stretch { + align-items: stretch !important; + } + .align-content-md-start { + align-content: flex-start !important; + } + .align-content-md-end { + align-content: flex-end !important; + } + .align-content-md-center { + align-content: center !important; + } + .align-content-md-between { + align-content: space-between !important; + } + .align-content-md-around { + align-content: space-around !important; + } + .align-content-md-stretch { + align-content: stretch !important; + } + .align-self-md-auto { + align-self: auto !important; + } + .align-self-md-start { + align-self: flex-start !important; + } + .align-self-md-end { + align-self: flex-end !important; + } + .align-self-md-center { + align-self: center !important; + } + .align-self-md-baseline { + align-self: baseline !important; + } + .align-self-md-stretch { + align-self: stretch !important; + } +} +@media (min-width: 992px) { + .flex-lg-row { + flex-direction: row !important; + } + .flex-lg-column { + flex-direction: column !important; + } + .flex-lg-row-reverse { + flex-direction: row-reverse !important; + } + .flex-lg-column-reverse { + flex-direction: column-reverse !important; + } + .flex-lg-wrap { + flex-wrap: wrap !important; + } + .flex-lg-nowrap { + flex-wrap: nowrap !important; + } + .flex-lg-wrap-reverse { + flex-wrap: wrap-reverse !important; + } + .flex-lg-fill { + flex: 1 1 auto !important; + } + .flex-lg-grow-0 { + flex-grow: 0 !important; + } + .flex-lg-grow-1 { + flex-grow: 1 !important; + } + .flex-lg-shrink-0 { + flex-shrink: 0 !important; + } + .flex-lg-shrink-1 { + flex-shrink: 1 !important; + } + .justify-content-lg-start { + justify-content: flex-start !important; + } + .justify-content-lg-end { + justify-content: flex-end !important; + } + .justify-content-lg-center { + justify-content: center !important; + } + .justify-content-lg-between { + justify-content: space-between !important; + } + .justify-content-lg-around { + justify-content: space-around !important; + } + .align-items-lg-start { + align-items: flex-start !important; + } + .align-items-lg-end { + align-items: flex-end !important; + } + .align-items-lg-center { + align-items: center !important; + } + .align-items-lg-baseline { + align-items: baseline !important; + } + .align-items-lg-stretch { + align-items: stretch !important; + } + .align-content-lg-start { + align-content: flex-start !important; + } + .align-content-lg-end { + align-content: flex-end !important; + } + .align-content-lg-center { + align-content: center !important; + } + .align-content-lg-between { + align-content: space-between !important; + } + .align-content-lg-around { + align-content: space-around !important; + } + .align-content-lg-stretch { + align-content: stretch !important; + } + .align-self-lg-auto { + align-self: auto !important; + } + .align-self-lg-start { + align-self: flex-start !important; + } + .align-self-lg-end { + align-self: flex-end !important; + } + .align-self-lg-center { + align-self: center !important; + } + .align-self-lg-baseline { + align-self: baseline !important; + } + .align-self-lg-stretch { + align-self: stretch !important; + } +} +@media (min-width: 1200px) { + .flex-xl-row { + flex-direction: row !important; + } + .flex-xl-column { + flex-direction: column !important; + } + .flex-xl-row-reverse { + flex-direction: row-reverse !important; + } + .flex-xl-column-reverse { + flex-direction: column-reverse !important; + } + .flex-xl-wrap { + flex-wrap: wrap !important; + } + .flex-xl-nowrap { + flex-wrap: nowrap !important; + } + .flex-xl-wrap-reverse { + flex-wrap: wrap-reverse !important; + } + .flex-xl-fill { + flex: 1 1 auto !important; + } + .flex-xl-grow-0 { + flex-grow: 0 !important; + } + .flex-xl-grow-1 { + flex-grow: 1 !important; + } + .flex-xl-shrink-0 { + flex-shrink: 0 !important; + } + .flex-xl-shrink-1 { + flex-shrink: 1 !important; + } + .justify-content-xl-start { + justify-content: flex-start !important; + } + .justify-content-xl-end { + justify-content: flex-end !important; + } + .justify-content-xl-center { + justify-content: center !important; + } + .justify-content-xl-between { + justify-content: space-between !important; + } + .justify-content-xl-around { + justify-content: space-around !important; + } + .align-items-xl-start { + align-items: flex-start !important; + } + .align-items-xl-end { + align-items: flex-end !important; + } + .align-items-xl-center { + align-items: center !important; + } + .align-items-xl-baseline { + align-items: baseline !important; + } + .align-items-xl-stretch { + align-items: stretch !important; + } + .align-content-xl-start { + align-content: flex-start !important; + } + .align-content-xl-end { + align-content: flex-end !important; + } + .align-content-xl-center { + align-content: center !important; + } + .align-content-xl-between { + align-content: space-between !important; + } + .align-content-xl-around { + align-content: space-around !important; + } + .align-content-xl-stretch { + align-content: stretch !important; + } + .align-self-xl-auto { + align-self: auto !important; + } + .align-self-xl-start { + align-self: flex-start !important; + } + .align-self-xl-end { + align-self: flex-end !important; + } + .align-self-xl-center { + align-self: center !important; + } + .align-self-xl-baseline { + align-self: baseline !important; + } + .align-self-xl-stretch { + align-self: stretch !important; + } +} +.float-left { + float: left !important; +} + +.float-right { + float: right !important; +} + +.float-none { + float: none !important; +} + +@media (min-width: 576px) { + .float-sm-left { + float: left !important; + } + .float-sm-right { + float: right !important; + } + .float-sm-none { + float: none !important; + } +} +@media (min-width: 768px) { + .float-md-left { + float: left !important; + } + .float-md-right { + float: right !important; + } + .float-md-none { + float: none !important; + } +} +@media (min-width: 992px) { + .float-lg-left { + float: left !important; + } + .float-lg-right { + float: right !important; + } + .float-lg-none { + float: none !important; + } +} +@media (min-width: 1200px) { + .float-xl-left { + float: left !important; + } + .float-xl-right { + float: right !important; + } + .float-xl-none { + float: none !important; + } +} +.user-select-all { + user-select: all !important; +} + +.user-select-auto { + user-select: auto !important; +} + +.user-select-none { + user-select: none !important; +} + +.overflow-auto { + overflow: auto !important; +} + +.overflow-hidden { + overflow: hidden !important; +} + +.position-static { + position: static !important; +} + +.position-relative { + position: relative !important; +} + +.position-absolute { + position: absolute !important; +} + +.position-fixed { + position: fixed !important; +} + +.position-sticky { + position: sticky !important; +} + +.fixed-top { + position: fixed; + top: 0; + right: 0; + left: 0; + z-index: 1030; +} + +.fixed-bottom { + position: fixed; + right: 0; + bottom: 0; + left: 0; + z-index: 1030; +} + +@supports (position: sticky) { + .sticky-top { + position: sticky; + top: 0; + z-index: 1020; + } +} + +.sr-only { + position: absolute; + width: 1px; + height: 1px; + padding: 0; + margin: -1px; + overflow: hidden; + clip: rect(0, 0, 0, 0); + white-space: nowrap; + border: 0; +} + +.sr-only-focusable:active, .sr-only-focusable:focus { + position: static; + width: auto; + height: auto; + overflow: visible; + clip: auto; + white-space: normal; +} + +.shadow-sm { + box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075) !important; +} + +.shadow { + box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15) !important; +} + +.shadow-lg { + box-shadow: 0 1rem 3rem rgba(0, 0, 0, 0.175) !important; +} + +.shadow-none { + box-shadow: none !important; +} + +.w-25 { + width: 25% !important; +} + +.w-50 { + width: 50% !important; +} + +.w-75 { + width: 75% !important; +} + +.w-100 { + width: 100% !important; +} + +.w-auto { + width: auto !important; +} + +.h-25 { + height: 25% !important; +} + +.h-50 { + height: 50% !important; +} + +.h-75 { + height: 75% !important; +} + +.h-100 { + height: 100% !important; +} + +.h-auto { + height: auto !important; +} + +.mw-100 { + max-width: 100% !important; +} + +.mh-100 { + max-height: 100% !important; +} + +.min-vw-100 { + min-width: 100vw !important; +} + +.min-vh-100 { + min-height: 100vh !important; +} + +.vw-100 { + width: 100vw !important; +} + +.vh-100 { + height: 100vh !important; +} + +.m-0 { + margin: 0 !important; +} + +.mt-0, +.my-0 { + margin-top: 0 !important; +} + +.mr-0, +.mx-0 { + margin-right: 0 !important; +} + +.mb-0, +.my-0 { + margin-bottom: 0 !important; +} + +.ml-0, +.mx-0 { + margin-left: 0 !important; +} + +.m-1 { + margin: 0.25rem !important; +} + +.mt-1, +.my-1 { + margin-top: 0.25rem !important; +} + +.mr-1, +.mx-1 { + margin-right: 0.25rem !important; +} + +.mb-1, +.my-1 { + margin-bottom: 0.25rem !important; +} + +.ml-1, +.mx-1 { + margin-left: 0.25rem !important; +} + +.m-2 { + margin: 0.5rem !important; +} + +.mt-2, +.my-2 { + margin-top: 0.5rem !important; +} + +.mr-2, +.mx-2 { + margin-right: 0.5rem !important; +} + +.mb-2, +.my-2 { + margin-bottom: 0.5rem !important; +} + +.ml-2, +.mx-2 { + margin-left: 0.5rem !important; +} + +.m-3 { + margin: 1rem !important; +} + +.mt-3, +.my-3 { + margin-top: 1rem !important; +} + +.mr-3, +.mx-3 { + margin-right: 1rem !important; +} + +.mb-3, +.my-3 { + margin-bottom: 1rem !important; +} + +.ml-3, +.mx-3 { + margin-left: 1rem !important; +} + +.m-4 { + margin: 1.5rem !important; +} + +.mt-4, +.my-4 { + margin-top: 1.5rem !important; +} + +.mr-4, +.mx-4 { + margin-right: 1.5rem !important; +} + +.mb-4, +.my-4 { + margin-bottom: 1.5rem !important; +} + +.ml-4, +.mx-4 { + margin-left: 1.5rem !important; +} + +.m-5 { + margin: 3rem !important; +} + +.mt-5, +.my-5 { + margin-top: 3rem !important; +} + +.mr-5, +.mx-5 { + margin-right: 3rem !important; +} + +.mb-5, +.my-5 { + margin-bottom: 3rem !important; +} + +.ml-5, +.mx-5 { + margin-left: 3rem !important; +} + +.p-0 { + padding: 0 !important; +} + +.pt-0, +.py-0 { + padding-top: 0 !important; +} + +.pr-0, +.px-0 { + padding-right: 0 !important; +} + +.pb-0, +.py-0 { + padding-bottom: 0 !important; +} + +.pl-0, +.px-0 { + padding-left: 0 !important; +} + +.p-1 { + padding: 0.25rem !important; +} + +.pt-1, +.py-1 { + padding-top: 0.25rem !important; +} + +.pr-1, +.px-1 { + padding-right: 0.25rem !important; +} + +.pb-1, +.py-1 { + padding-bottom: 0.25rem !important; +} + +.pl-1, +.px-1 { + padding-left: 0.25rem !important; +} + +.p-2 { + padding: 0.5rem !important; +} + +.pt-2, +.py-2 { + padding-top: 0.5rem !important; +} + +.pr-2, +.px-2 { + padding-right: 0.5rem !important; +} + +.pb-2, +.py-2 { + padding-bottom: 0.5rem !important; +} + +.pl-2, +.px-2 { + padding-left: 0.5rem !important; +} + +.p-3 { + padding: 1rem !important; +} + +.pt-3, +.py-3 { + padding-top: 1rem !important; +} + +.pr-3, +.px-3 { + padding-right: 1rem !important; +} + +.pb-3, +.py-3 { + padding-bottom: 1rem !important; +} + +.pl-3, +.px-3 { + padding-left: 1rem !important; +} + +.p-4 { + padding: 1.5rem !important; +} + +.pt-4, +.py-4 { + padding-top: 1.5rem !important; +} + +.pr-4, +.px-4 { + padding-right: 1.5rem !important; +} + +.pb-4, +.py-4 { + padding-bottom: 1.5rem !important; +} + +.pl-4, +.px-4 { + padding-left: 1.5rem !important; +} + +.p-5 { + padding: 3rem !important; +} + +.pt-5, +.py-5 { + padding-top: 3rem !important; +} + +.pr-5, +.px-5 { + padding-right: 3rem !important; +} + +.pb-5, +.py-5 { + padding-bottom: 3rem !important; +} + +.pl-5, +.px-5 { + padding-left: 3rem !important; +} + +.m-n1 { + margin: -0.25rem !important; +} + +.mt-n1, +.my-n1 { + margin-top: -0.25rem !important; +} + +.mr-n1, +.mx-n1 { + margin-right: -0.25rem !important; +} + +.mb-n1, +.my-n1 { + margin-bottom: -0.25rem !important; +} + +.ml-n1, +.mx-n1 { + margin-left: -0.25rem !important; +} + +.m-n2 { + margin: -0.5rem !important; +} + +.mt-n2, +.my-n2 { + margin-top: -0.5rem !important; +} + +.mr-n2, +.mx-n2 { + margin-right: -0.5rem !important; +} + +.mb-n2, +.my-n2 { + margin-bottom: -0.5rem !important; +} + +.ml-n2, +.mx-n2 { + margin-left: -0.5rem !important; +} + +.m-n3 { + margin: -1rem !important; +} + +.mt-n3, +.my-n3 { + margin-top: -1rem !important; +} + +.mr-n3, +.mx-n3 { + margin-right: -1rem !important; +} + +.mb-n3, +.my-n3 { + margin-bottom: -1rem !important; +} + +.ml-n3, +.mx-n3 { + margin-left: -1rem !important; +} + +.m-n4 { + margin: -1.5rem !important; +} + +.mt-n4, +.my-n4 { + margin-top: -1.5rem !important; +} + +.mr-n4, +.mx-n4 { + margin-right: -1.5rem !important; +} + +.mb-n4, +.my-n4 { + margin-bottom: -1.5rem !important; +} + +.ml-n4, +.mx-n4 { + margin-left: -1.5rem !important; +} + +.m-n5 { + margin: -3rem !important; +} + +.mt-n5, +.my-n5 { + margin-top: -3rem !important; +} + +.mr-n5, +.mx-n5 { + margin-right: -3rem !important; +} + +.mb-n5, +.my-n5 { + margin-bottom: -3rem !important; +} + +.ml-n5, +.mx-n5 { + margin-left: -3rem !important; +} + +.m-auto { + margin: auto !important; +} + +.mt-auto, +.my-auto { + margin-top: auto !important; +} + +.mr-auto, +.mx-auto { + margin-right: auto !important; +} + +.mb-auto, +.my-auto { + margin-bottom: auto !important; +} + +.ml-auto, +.mx-auto { + margin-left: auto !important; +} + +@media (min-width: 576px) { + .m-sm-0 { + margin: 0 !important; + } + .mt-sm-0, + .my-sm-0 { + margin-top: 0 !important; + } + .mr-sm-0, + .mx-sm-0 { + margin-right: 0 !important; + } + .mb-sm-0, + .my-sm-0 { + margin-bottom: 0 !important; + } + .ml-sm-0, + .mx-sm-0 { + margin-left: 0 !important; + } + .m-sm-1 { + margin: 0.25rem !important; + } + .mt-sm-1, + .my-sm-1 { + margin-top: 0.25rem !important; + } + .mr-sm-1, + .mx-sm-1 { + margin-right: 0.25rem !important; + } + .mb-sm-1, + .my-sm-1 { + margin-bottom: 0.25rem !important; + } + .ml-sm-1, + .mx-sm-1 { + margin-left: 0.25rem !important; + } + .m-sm-2 { + margin: 0.5rem !important; + } + .mt-sm-2, + .my-sm-2 { + margin-top: 0.5rem !important; + } + .mr-sm-2, + .mx-sm-2 { + margin-right: 0.5rem !important; + } + .mb-sm-2, + .my-sm-2 { + margin-bottom: 0.5rem !important; + } + .ml-sm-2, + .mx-sm-2 { + margin-left: 0.5rem !important; + } + .m-sm-3 { + margin: 1rem !important; + } + .mt-sm-3, + .my-sm-3 { + margin-top: 1rem !important; + } + .mr-sm-3, + .mx-sm-3 { + margin-right: 1rem !important; + } + .mb-sm-3, + .my-sm-3 { + margin-bottom: 1rem !important; + } + .ml-sm-3, + .mx-sm-3 { + margin-left: 1rem !important; + } + .m-sm-4 { + margin: 1.5rem !important; + } + .mt-sm-4, + .my-sm-4 { + margin-top: 1.5rem !important; + } + .mr-sm-4, + .mx-sm-4 { + margin-right: 1.5rem !important; + } + .mb-sm-4, + .my-sm-4 { + margin-bottom: 1.5rem !important; + } + .ml-sm-4, + .mx-sm-4 { + margin-left: 1.5rem !important; + } + .m-sm-5 { + margin: 3rem !important; + } + .mt-sm-5, + .my-sm-5 { + margin-top: 3rem !important; + } + .mr-sm-5, + .mx-sm-5 { + margin-right: 3rem !important; + } + .mb-sm-5, + .my-sm-5 { + margin-bottom: 3rem !important; + } + .ml-sm-5, + .mx-sm-5 { + margin-left: 3rem !important; + } + .p-sm-0 { + padding: 0 !important; + } + .pt-sm-0, + .py-sm-0 { + padding-top: 0 !important; + } + .pr-sm-0, + .px-sm-0 { + padding-right: 0 !important; + } + .pb-sm-0, + .py-sm-0 { + padding-bottom: 0 !important; + } + .pl-sm-0, + .px-sm-0 { + padding-left: 0 !important; + } + .p-sm-1 { + padding: 0.25rem !important; + } + .pt-sm-1, + .py-sm-1 { + padding-top: 0.25rem !important; + } + .pr-sm-1, + .px-sm-1 { + padding-right: 0.25rem !important; + } + .pb-sm-1, + .py-sm-1 { + padding-bottom: 0.25rem !important; + } + .pl-sm-1, + .px-sm-1 { + padding-left: 0.25rem !important; + } + .p-sm-2 { + padding: 0.5rem !important; + } + .pt-sm-2, + .py-sm-2 { + padding-top: 0.5rem !important; + } + .pr-sm-2, + .px-sm-2 { + padding-right: 0.5rem !important; + } + .pb-sm-2, + .py-sm-2 { + padding-bottom: 0.5rem !important; + } + .pl-sm-2, + .px-sm-2 { + padding-left: 0.5rem !important; + } + .p-sm-3 { + padding: 1rem !important; + } + .pt-sm-3, + .py-sm-3 { + padding-top: 1rem !important; + } + .pr-sm-3, + .px-sm-3 { + padding-right: 1rem !important; + } + .pb-sm-3, + .py-sm-3 { + padding-bottom: 1rem !important; + } + .pl-sm-3, + .px-sm-3 { + padding-left: 1rem !important; + } + .p-sm-4 { + padding: 1.5rem !important; + } + .pt-sm-4, + .py-sm-4 { + padding-top: 1.5rem !important; + } + .pr-sm-4, + .px-sm-4 { + padding-right: 1.5rem !important; + } + .pb-sm-4, + .py-sm-4 { + padding-bottom: 1.5rem !important; + } + .pl-sm-4, + .px-sm-4 { + padding-left: 1.5rem !important; + } + .p-sm-5 { + padding: 3rem !important; + } + .pt-sm-5, + .py-sm-5 { + padding-top: 3rem !important; + } + .pr-sm-5, + .px-sm-5 { + padding-right: 3rem !important; + } + .pb-sm-5, + .py-sm-5 { + padding-bottom: 3rem !important; + } + .pl-sm-5, + .px-sm-5 { + padding-left: 3rem !important; + } + .m-sm-n1 { + margin: -0.25rem !important; + } + .mt-sm-n1, + .my-sm-n1 { + margin-top: -0.25rem !important; + } + .mr-sm-n1, + .mx-sm-n1 { + margin-right: -0.25rem !important; + } + .mb-sm-n1, + .my-sm-n1 { + margin-bottom: -0.25rem !important; + } + .ml-sm-n1, + .mx-sm-n1 { + margin-left: -0.25rem !important; + } + .m-sm-n2 { + margin: -0.5rem !important; + } + .mt-sm-n2, + .my-sm-n2 { + margin-top: -0.5rem !important; + } + .mr-sm-n2, + .mx-sm-n2 { + margin-right: -0.5rem !important; + } + .mb-sm-n2, + .my-sm-n2 { + margin-bottom: -0.5rem !important; + } + .ml-sm-n2, + .mx-sm-n2 { + margin-left: -0.5rem !important; + } + .m-sm-n3 { + margin: -1rem !important; + } + .mt-sm-n3, + .my-sm-n3 { + margin-top: -1rem !important; + } + .mr-sm-n3, + .mx-sm-n3 { + margin-right: -1rem !important; + } + .mb-sm-n3, + .my-sm-n3 { + margin-bottom: -1rem !important; + } + .ml-sm-n3, + .mx-sm-n3 { + margin-left: -1rem !important; + } + .m-sm-n4 { + margin: -1.5rem !important; + } + .mt-sm-n4, + .my-sm-n4 { + margin-top: -1.5rem !important; + } + .mr-sm-n4, + .mx-sm-n4 { + margin-right: -1.5rem !important; + } + .mb-sm-n4, + .my-sm-n4 { + margin-bottom: -1.5rem !important; + } + .ml-sm-n4, + .mx-sm-n4 { + margin-left: -1.5rem !important; + } + .m-sm-n5 { + margin: -3rem !important; + } + .mt-sm-n5, + .my-sm-n5 { + margin-top: -3rem !important; + } + .mr-sm-n5, + .mx-sm-n5 { + margin-right: -3rem !important; + } + .mb-sm-n5, + .my-sm-n5 { + margin-bottom: -3rem !important; + } + .ml-sm-n5, + .mx-sm-n5 { + margin-left: -3rem !important; + } + .m-sm-auto { + margin: auto !important; + } + .mt-sm-auto, + .my-sm-auto { + margin-top: auto !important; + } + .mr-sm-auto, + .mx-sm-auto { + margin-right: auto !important; + } + .mb-sm-auto, + .my-sm-auto { + margin-bottom: auto !important; + } + .ml-sm-auto, + .mx-sm-auto { + margin-left: auto !important; + } +} +@media (min-width: 768px) { + .m-md-0 { + margin: 0 !important; + } + .mt-md-0, + .my-md-0 { + margin-top: 0 !important; + } + .mr-md-0, + .mx-md-0 { + margin-right: 0 !important; + } + .mb-md-0, + .my-md-0 { + margin-bottom: 0 !important; + } + .ml-md-0, + .mx-md-0 { + margin-left: 0 !important; + } + .m-md-1 { + margin: 0.25rem !important; + } + .mt-md-1, + .my-md-1 { + margin-top: 0.25rem !important; + } + .mr-md-1, + .mx-md-1 { + margin-right: 0.25rem !important; + } + .mb-md-1, + .my-md-1 { + margin-bottom: 0.25rem !important; + } + .ml-md-1, + .mx-md-1 { + margin-left: 0.25rem !important; + } + .m-md-2 { + margin: 0.5rem !important; + } + .mt-md-2, + .my-md-2 { + margin-top: 0.5rem !important; + } + .mr-md-2, + .mx-md-2 { + margin-right: 0.5rem !important; + } + .mb-md-2, + .my-md-2 { + margin-bottom: 0.5rem !important; + } + .ml-md-2, + .mx-md-2 { + margin-left: 0.5rem !important; + } + .m-md-3 { + margin: 1rem !important; + } + .mt-md-3, + .my-md-3 { + margin-top: 1rem !important; + } + .mr-md-3, + .mx-md-3 { + margin-right: 1rem !important; + } + .mb-md-3, + .my-md-3 { + margin-bottom: 1rem !important; + } + .ml-md-3, + .mx-md-3 { + margin-left: 1rem !important; + } + .m-md-4 { + margin: 1.5rem !important; + } + .mt-md-4, + .my-md-4 { + margin-top: 1.5rem !important; + } + .mr-md-4, + .mx-md-4 { + margin-right: 1.5rem !important; + } + .mb-md-4, + .my-md-4 { + margin-bottom: 1.5rem !important; + } + .ml-md-4, + .mx-md-4 { + margin-left: 1.5rem !important; + } + .m-md-5 { + margin: 3rem !important; + } + .mt-md-5, + .my-md-5 { + margin-top: 3rem !important; + } + .mr-md-5, + .mx-md-5 { + margin-right: 3rem !important; + } + .mb-md-5, + .my-md-5 { + margin-bottom: 3rem !important; + } + .ml-md-5, + .mx-md-5 { + margin-left: 3rem !important; + } + .p-md-0 { + padding: 0 !important; + } + .pt-md-0, + .py-md-0 { + padding-top: 0 !important; + } + .pr-md-0, + .px-md-0 { + padding-right: 0 !important; + } + .pb-md-0, + .py-md-0 { + padding-bottom: 0 !important; + } + .pl-md-0, + .px-md-0 { + padding-left: 0 !important; + } + .p-md-1 { + padding: 0.25rem !important; + } + .pt-md-1, + .py-md-1 { + padding-top: 0.25rem !important; + } + .pr-md-1, + .px-md-1 { + padding-right: 0.25rem !important; + } + .pb-md-1, + .py-md-1 { + padding-bottom: 0.25rem !important; + } + .pl-md-1, + .px-md-1 { + padding-left: 0.25rem !important; + } + .p-md-2 { + padding: 0.5rem !important; + } + .pt-md-2, + .py-md-2 { + padding-top: 0.5rem !important; + } + .pr-md-2, + .px-md-2 { + padding-right: 0.5rem !important; + } + .pb-md-2, + .py-md-2 { + padding-bottom: 0.5rem !important; + } + .pl-md-2, + .px-md-2 { + padding-left: 0.5rem !important; + } + .p-md-3 { + padding: 1rem !important; + } + .pt-md-3, + .py-md-3 { + padding-top: 1rem !important; + } + .pr-md-3, + .px-md-3 { + padding-right: 1rem !important; + } + .pb-md-3, + .py-md-3 { + padding-bottom: 1rem !important; + } + .pl-md-3, + .px-md-3 { + padding-left: 1rem !important; + } + .p-md-4 { + padding: 1.5rem !important; + } + .pt-md-4, + .py-md-4 { + padding-top: 1.5rem !important; + } + .pr-md-4, + .px-md-4 { + padding-right: 1.5rem !important; + } + .pb-md-4, + .py-md-4 { + padding-bottom: 1.5rem !important; + } + .pl-md-4, + .px-md-4 { + padding-left: 1.5rem !important; + } + .p-md-5 { + padding: 3rem !important; + } + .pt-md-5, + .py-md-5 { + padding-top: 3rem !important; + } + .pr-md-5, + .px-md-5 { + padding-right: 3rem !important; + } + .pb-md-5, + .py-md-5 { + padding-bottom: 3rem !important; + } + .pl-md-5, + .px-md-5 { + padding-left: 3rem !important; + } + .m-md-n1 { + margin: -0.25rem !important; + } + .mt-md-n1, + .my-md-n1 { + margin-top: -0.25rem !important; + } + .mr-md-n1, + .mx-md-n1 { + margin-right: -0.25rem !important; + } + .mb-md-n1, + .my-md-n1 { + margin-bottom: -0.25rem !important; + } + .ml-md-n1, + .mx-md-n1 { + margin-left: -0.25rem !important; + } + .m-md-n2 { + margin: -0.5rem !important; + } + .mt-md-n2, + .my-md-n2 { + margin-top: -0.5rem !important; + } + .mr-md-n2, + .mx-md-n2 { + margin-right: -0.5rem !important; + } + .mb-md-n2, + .my-md-n2 { + margin-bottom: -0.5rem !important; + } + .ml-md-n2, + .mx-md-n2 { + margin-left: -0.5rem !important; + } + .m-md-n3 { + margin: -1rem !important; + } + .mt-md-n3, + .my-md-n3 { + margin-top: -1rem !important; + } + .mr-md-n3, + .mx-md-n3 { + margin-right: -1rem !important; + } + .mb-md-n3, + .my-md-n3 { + margin-bottom: -1rem !important; + } + .ml-md-n3, + .mx-md-n3 { + margin-left: -1rem !important; + } + .m-md-n4 { + margin: -1.5rem !important; + } + .mt-md-n4, + .my-md-n4 { + margin-top: -1.5rem !important; + } + .mr-md-n4, + .mx-md-n4 { + margin-right: -1.5rem !important; + } + .mb-md-n4, + .my-md-n4 { + margin-bottom: -1.5rem !important; + } + .ml-md-n4, + .mx-md-n4 { + margin-left: -1.5rem !important; + } + .m-md-n5 { + margin: -3rem !important; + } + .mt-md-n5, + .my-md-n5 { + margin-top: -3rem !important; + } + .mr-md-n5, + .mx-md-n5 { + margin-right: -3rem !important; + } + .mb-md-n5, + .my-md-n5 { + margin-bottom: -3rem !important; + } + .ml-md-n5, + .mx-md-n5 { + margin-left: -3rem !important; + } + .m-md-auto { + margin: auto !important; + } + .mt-md-auto, + .my-md-auto { + margin-top: auto !important; + } + .mr-md-auto, + .mx-md-auto { + margin-right: auto !important; + } + .mb-md-auto, + .my-md-auto { + margin-bottom: auto !important; + } + .ml-md-auto, + .mx-md-auto { + margin-left: auto !important; + } +} +@media (min-width: 992px) { + .m-lg-0 { + margin: 0 !important; + } + .mt-lg-0, + .my-lg-0 { + margin-top: 0 !important; + } + .mr-lg-0, + .mx-lg-0 { + margin-right: 0 !important; + } + .mb-lg-0, + .my-lg-0 { + margin-bottom: 0 !important; + } + .ml-lg-0, + .mx-lg-0 { + margin-left: 0 !important; + } + .m-lg-1 { + margin: 0.25rem !important; + } + .mt-lg-1, + .my-lg-1 { + margin-top: 0.25rem !important; + } + .mr-lg-1, + .mx-lg-1 { + margin-right: 0.25rem !important; + } + .mb-lg-1, + .my-lg-1 { + margin-bottom: 0.25rem !important; + } + .ml-lg-1, + .mx-lg-1 { + margin-left: 0.25rem !important; + } + .m-lg-2 { + margin: 0.5rem !important; + } + .mt-lg-2, + .my-lg-2 { + margin-top: 0.5rem !important; + } + .mr-lg-2, + .mx-lg-2 { + margin-right: 0.5rem !important; + } + .mb-lg-2, + .my-lg-2 { + margin-bottom: 0.5rem !important; + } + .ml-lg-2, + .mx-lg-2 { + margin-left: 0.5rem !important; + } + .m-lg-3 { + margin: 1rem !important; + } + .mt-lg-3, + .my-lg-3 { + margin-top: 1rem !important; + } + .mr-lg-3, + .mx-lg-3 { + margin-right: 1rem !important; + } + .mb-lg-3, + .my-lg-3 { + margin-bottom: 1rem !important; + } + .ml-lg-3, + .mx-lg-3 { + margin-left: 1rem !important; + } + .m-lg-4 { + margin: 1.5rem !important; + } + .mt-lg-4, + .my-lg-4 { + margin-top: 1.5rem !important; + } + .mr-lg-4, + .mx-lg-4 { + margin-right: 1.5rem !important; + } + .mb-lg-4, + .my-lg-4 { + margin-bottom: 1.5rem !important; + } + .ml-lg-4, + .mx-lg-4 { + margin-left: 1.5rem !important; + } + .m-lg-5 { + margin: 3rem !important; + } + .mt-lg-5, + .my-lg-5 { + margin-top: 3rem !important; + } + .mr-lg-5, + .mx-lg-5 { + margin-right: 3rem !important; + } + .mb-lg-5, + .my-lg-5 { + margin-bottom: 3rem !important; + } + .ml-lg-5, + .mx-lg-5 { + margin-left: 3rem !important; + } + .p-lg-0 { + padding: 0 !important; + } + .pt-lg-0, + .py-lg-0 { + padding-top: 0 !important; + } + .pr-lg-0, + .px-lg-0 { + padding-right: 0 !important; + } + .pb-lg-0, + .py-lg-0 { + padding-bottom: 0 !important; + } + .pl-lg-0, + .px-lg-0 { + padding-left: 0 !important; + } + .p-lg-1 { + padding: 0.25rem !important; + } + .pt-lg-1, + .py-lg-1 { + padding-top: 0.25rem !important; + } + .pr-lg-1, + .px-lg-1 { + padding-right: 0.25rem !important; + } + .pb-lg-1, + .py-lg-1 { + padding-bottom: 0.25rem !important; + } + .pl-lg-1, + .px-lg-1 { + padding-left: 0.25rem !important; + } + .p-lg-2 { + padding: 0.5rem !important; + } + .pt-lg-2, + .py-lg-2 { + padding-top: 0.5rem !important; + } + .pr-lg-2, + .px-lg-2 { + padding-right: 0.5rem !important; + } + .pb-lg-2, + .py-lg-2 { + padding-bottom: 0.5rem !important; + } + .pl-lg-2, + .px-lg-2 { + padding-left: 0.5rem !important; + } + .p-lg-3 { + padding: 1rem !important; + } + .pt-lg-3, + .py-lg-3 { + padding-top: 1rem !important; + } + .pr-lg-3, + .px-lg-3 { + padding-right: 1rem !important; + } + .pb-lg-3, + .py-lg-3 { + padding-bottom: 1rem !important; + } + .pl-lg-3, + .px-lg-3 { + padding-left: 1rem !important; + } + .p-lg-4 { + padding: 1.5rem !important; + } + .pt-lg-4, + .py-lg-4 { + padding-top: 1.5rem !important; + } + .pr-lg-4, + .px-lg-4 { + padding-right: 1.5rem !important; + } + .pb-lg-4, + .py-lg-4 { + padding-bottom: 1.5rem !important; + } + .pl-lg-4, + .px-lg-4 { + padding-left: 1.5rem !important; + } + .p-lg-5 { + padding: 3rem !important; + } + .pt-lg-5, + .py-lg-5 { + padding-top: 3rem !important; + } + .pr-lg-5, + .px-lg-5 { + padding-right: 3rem !important; + } + .pb-lg-5, + .py-lg-5 { + padding-bottom: 3rem !important; + } + .pl-lg-5, + .px-lg-5 { + padding-left: 3rem !important; + } + .m-lg-n1 { + margin: -0.25rem !important; + } + .mt-lg-n1, + .my-lg-n1 { + margin-top: -0.25rem !important; + } + .mr-lg-n1, + .mx-lg-n1 { + margin-right: -0.25rem !important; + } + .mb-lg-n1, + .my-lg-n1 { + margin-bottom: -0.25rem !important; + } + .ml-lg-n1, + .mx-lg-n1 { + margin-left: -0.25rem !important; + } + .m-lg-n2 { + margin: -0.5rem !important; + } + .mt-lg-n2, + .my-lg-n2 { + margin-top: -0.5rem !important; + } + .mr-lg-n2, + .mx-lg-n2 { + margin-right: -0.5rem !important; + } + .mb-lg-n2, + .my-lg-n2 { + margin-bottom: -0.5rem !important; + } + .ml-lg-n2, + .mx-lg-n2 { + margin-left: -0.5rem !important; + } + .m-lg-n3 { + margin: -1rem !important; + } + .mt-lg-n3, + .my-lg-n3 { + margin-top: -1rem !important; + } + .mr-lg-n3, + .mx-lg-n3 { + margin-right: -1rem !important; + } + .mb-lg-n3, + .my-lg-n3 { + margin-bottom: -1rem !important; + } + .ml-lg-n3, + .mx-lg-n3 { + margin-left: -1rem !important; + } + .m-lg-n4 { + margin: -1.5rem !important; + } + .mt-lg-n4, + .my-lg-n4 { + margin-top: -1.5rem !important; + } + .mr-lg-n4, + .mx-lg-n4 { + margin-right: -1.5rem !important; + } + .mb-lg-n4, + .my-lg-n4 { + margin-bottom: -1.5rem !important; + } + .ml-lg-n4, + .mx-lg-n4 { + margin-left: -1.5rem !important; + } + .m-lg-n5 { + margin: -3rem !important; + } + .mt-lg-n5, + .my-lg-n5 { + margin-top: -3rem !important; + } + .mr-lg-n5, + .mx-lg-n5 { + margin-right: -3rem !important; + } + .mb-lg-n5, + .my-lg-n5 { + margin-bottom: -3rem !important; + } + .ml-lg-n5, + .mx-lg-n5 { + margin-left: -3rem !important; + } + .m-lg-auto { + margin: auto !important; + } + .mt-lg-auto, + .my-lg-auto { + margin-top: auto !important; + } + .mr-lg-auto, + .mx-lg-auto { + margin-right: auto !important; + } + .mb-lg-auto, + .my-lg-auto { + margin-bottom: auto !important; + } + .ml-lg-auto, + .mx-lg-auto { + margin-left: auto !important; + } +} +@media (min-width: 1200px) { + .m-xl-0 { + margin: 0 !important; + } + .mt-xl-0, + .my-xl-0 { + margin-top: 0 !important; + } + .mr-xl-0, + .mx-xl-0 { + margin-right: 0 !important; + } + .mb-xl-0, + .my-xl-0 { + margin-bottom: 0 !important; + } + .ml-xl-0, + .mx-xl-0 { + margin-left: 0 !important; + } + .m-xl-1 { + margin: 0.25rem !important; + } + .mt-xl-1, + .my-xl-1 { + margin-top: 0.25rem !important; + } + .mr-xl-1, + .mx-xl-1 { + margin-right: 0.25rem !important; + } + .mb-xl-1, + .my-xl-1 { + margin-bottom: 0.25rem !important; + } + .ml-xl-1, + .mx-xl-1 { + margin-left: 0.25rem !important; + } + .m-xl-2 { + margin: 0.5rem !important; + } + .mt-xl-2, + .my-xl-2 { + margin-top: 0.5rem !important; + } + .mr-xl-2, + .mx-xl-2 { + margin-right: 0.5rem !important; + } + .mb-xl-2, + .my-xl-2 { + margin-bottom: 0.5rem !important; + } + .ml-xl-2, + .mx-xl-2 { + margin-left: 0.5rem !important; + } + .m-xl-3 { + margin: 1rem !important; + } + .mt-xl-3, + .my-xl-3 { + margin-top: 1rem !important; + } + .mr-xl-3, + .mx-xl-3 { + margin-right: 1rem !important; + } + .mb-xl-3, + .my-xl-3 { + margin-bottom: 1rem !important; + } + .ml-xl-3, + .mx-xl-3 { + margin-left: 1rem !important; + } + .m-xl-4 { + margin: 1.5rem !important; + } + .mt-xl-4, + .my-xl-4 { + margin-top: 1.5rem !important; + } + .mr-xl-4, + .mx-xl-4 { + margin-right: 1.5rem !important; + } + .mb-xl-4, + .my-xl-4 { + margin-bottom: 1.5rem !important; + } + .ml-xl-4, + .mx-xl-4 { + margin-left: 1.5rem !important; + } + .m-xl-5 { + margin: 3rem !important; + } + .mt-xl-5, + .my-xl-5 { + margin-top: 3rem !important; + } + .mr-xl-5, + .mx-xl-5 { + margin-right: 3rem !important; + } + .mb-xl-5, + .my-xl-5 { + margin-bottom: 3rem !important; + } + .ml-xl-5, + .mx-xl-5 { + margin-left: 3rem !important; + } + .p-xl-0 { + padding: 0 !important; + } + .pt-xl-0, + .py-xl-0 { + padding-top: 0 !important; + } + .pr-xl-0, + .px-xl-0 { + padding-right: 0 !important; + } + .pb-xl-0, + .py-xl-0 { + padding-bottom: 0 !important; + } + .pl-xl-0, + .px-xl-0 { + padding-left: 0 !important; + } + .p-xl-1 { + padding: 0.25rem !important; + } + .pt-xl-1, + .py-xl-1 { + padding-top: 0.25rem !important; + } + .pr-xl-1, + .px-xl-1 { + padding-right: 0.25rem !important; + } + .pb-xl-1, + .py-xl-1 { + padding-bottom: 0.25rem !important; + } + .pl-xl-1, + .px-xl-1 { + padding-left: 0.25rem !important; + } + .p-xl-2 { + padding: 0.5rem !important; + } + .pt-xl-2, + .py-xl-2 { + padding-top: 0.5rem !important; + } + .pr-xl-2, + .px-xl-2 { + padding-right: 0.5rem !important; + } + .pb-xl-2, + .py-xl-2 { + padding-bottom: 0.5rem !important; + } + .pl-xl-2, + .px-xl-2 { + padding-left: 0.5rem !important; + } + .p-xl-3 { + padding: 1rem !important; + } + .pt-xl-3, + .py-xl-3 { + padding-top: 1rem !important; + } + .pr-xl-3, + .px-xl-3 { + padding-right: 1rem !important; + } + .pb-xl-3, + .py-xl-3 { + padding-bottom: 1rem !important; + } + .pl-xl-3, + .px-xl-3 { + padding-left: 1rem !important; + } + .p-xl-4 { + padding: 1.5rem !important; + } + .pt-xl-4, + .py-xl-4 { + padding-top: 1.5rem !important; + } + .pr-xl-4, + .px-xl-4 { + padding-right: 1.5rem !important; + } + .pb-xl-4, + .py-xl-4 { + padding-bottom: 1.5rem !important; + } + .pl-xl-4, + .px-xl-4 { + padding-left: 1.5rem !important; + } + .p-xl-5 { + padding: 3rem !important; + } + .pt-xl-5, + .py-xl-5 { + padding-top: 3rem !important; + } + .pr-xl-5, + .px-xl-5 { + padding-right: 3rem !important; + } + .pb-xl-5, + .py-xl-5 { + padding-bottom: 3rem !important; + } + .pl-xl-5, + .px-xl-5 { + padding-left: 3rem !important; + } + .m-xl-n1 { + margin: -0.25rem !important; + } + .mt-xl-n1, + .my-xl-n1 { + margin-top: -0.25rem !important; + } + .mr-xl-n1, + .mx-xl-n1 { + margin-right: -0.25rem !important; + } + .mb-xl-n1, + .my-xl-n1 { + margin-bottom: -0.25rem !important; + } + .ml-xl-n1, + .mx-xl-n1 { + margin-left: -0.25rem !important; + } + .m-xl-n2 { + margin: -0.5rem !important; + } + .mt-xl-n2, + .my-xl-n2 { + margin-top: -0.5rem !important; + } + .mr-xl-n2, + .mx-xl-n2 { + margin-right: -0.5rem !important; + } + .mb-xl-n2, + .my-xl-n2 { + margin-bottom: -0.5rem !important; + } + .ml-xl-n2, + .mx-xl-n2 { + margin-left: -0.5rem !important; + } + .m-xl-n3 { + margin: -1rem !important; + } + .mt-xl-n3, + .my-xl-n3 { + margin-top: -1rem !important; + } + .mr-xl-n3, + .mx-xl-n3 { + margin-right: -1rem !important; + } + .mb-xl-n3, + .my-xl-n3 { + margin-bottom: -1rem !important; + } + .ml-xl-n3, + .mx-xl-n3 { + margin-left: -1rem !important; + } + .m-xl-n4 { + margin: -1.5rem !important; + } + .mt-xl-n4, + .my-xl-n4 { + margin-top: -1.5rem !important; + } + .mr-xl-n4, + .mx-xl-n4 { + margin-right: -1.5rem !important; + } + .mb-xl-n4, + .my-xl-n4 { + margin-bottom: -1.5rem !important; + } + .ml-xl-n4, + .mx-xl-n4 { + margin-left: -1.5rem !important; + } + .m-xl-n5 { + margin: -3rem !important; + } + .mt-xl-n5, + .my-xl-n5 { + margin-top: -3rem !important; + } + .mr-xl-n5, + .mx-xl-n5 { + margin-right: -3rem !important; + } + .mb-xl-n5, + .my-xl-n5 { + margin-bottom: -3rem !important; + } + .ml-xl-n5, + .mx-xl-n5 { + margin-left: -3rem !important; + } + .m-xl-auto { + margin: auto !important; + } + .mt-xl-auto, + .my-xl-auto { + margin-top: auto !important; + } + .mr-xl-auto, + .mx-xl-auto { + margin-right: auto !important; + } + .mb-xl-auto, + .my-xl-auto { + margin-bottom: auto !important; + } + .ml-xl-auto, + .mx-xl-auto { + margin-left: auto !important; + } +} +.stretched-link::after { + position: absolute; + top: 0; + right: 0; + bottom: 0; + left: 0; + z-index: 1; + pointer-events: auto; + content: ""; + background-color: rgba(0, 0, 0, 0); +} + +.text-monospace { + font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace !important; +} + +.text-justify { + text-align: justify !important; +} + +.text-wrap { + white-space: normal !important; +} + +.text-nowrap { + white-space: nowrap !important; +} + +.text-truncate { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.text-left { + text-align: left !important; +} + +.text-right { + text-align: right !important; +} + +.text-center { + text-align: center !important; +} + +@media (min-width: 576px) { + .text-sm-left { + text-align: left !important; + } + .text-sm-right { + text-align: right !important; + } + .text-sm-center { + text-align: center !important; + } +} +@media (min-width: 768px) { + .text-md-left { + text-align: left !important; + } + .text-md-right { + text-align: right !important; + } + .text-md-center { + text-align: center !important; + } +} +@media (min-width: 992px) { + .text-lg-left { + text-align: left !important; + } + .text-lg-right { + text-align: right !important; + } + .text-lg-center { + text-align: center !important; + } +} +@media (min-width: 1200px) { + .text-xl-left { + text-align: left !important; + } + .text-xl-right { + text-align: right !important; + } + .text-xl-center { + text-align: center !important; + } +} +.text-lowercase { + text-transform: lowercase !important; +} + +.text-uppercase { + text-transform: uppercase !important; +} + +.text-capitalize { + text-transform: capitalize !important; +} + +.font-weight-light { + font-weight: 300 !important; +} + +.font-weight-lighter { + font-weight: lighter !important; +} + +.font-weight-normal { + font-weight: 400 !important; +} + +.font-weight-bold { + font-weight: 700 !important; +} + +.font-weight-bolder { + font-weight: bolder !important; +} + +.font-italic { + font-style: italic !important; +} + +.text-white { + color: #fff !important; +} + +.text-primary { + color: #007bff !important; +} + +a.text-primary:hover, a.text-primary:focus { + color: #0056b3 !important; +} + +.text-secondary { + color: #6c757d !important; +} + +a.text-secondary:hover, a.text-secondary:focus { + color: #494f54 !important; +} + +.text-success { + color: #28a745 !important; +} + +a.text-success:hover, a.text-success:focus { + color: #19692c !important; +} + +.text-info { + color: #17a2b8 !important; +} + +a.text-info:hover, a.text-info:focus { + color: #0f6674 !important; +} + +.text-warning { + color: #ffc107 !important; +} + +a.text-warning:hover, a.text-warning:focus { + color: #ba8b00 !important; +} + +.text-danger { + color: #dc3545 !important; +} + +a.text-danger:hover, a.text-danger:focus { + color: #a71d2a !important; +} + +.text-light { + color: #f8f9fa !important; +} + +a.text-light:hover, a.text-light:focus { + color: #cbd3da !important; +} + +.text-dark { + color: #343a40 !important; +} + +a.text-dark:hover, a.text-dark:focus { + color: #121416 !important; +} + +.text-body { + color: #212529 !important; +} + +.text-muted { + color: #6c757d !important; +} + +.text-black-50 { + color: rgba(0, 0, 0, 0.5) !important; +} + +.text-white-50 { + color: rgba(255, 255, 255, 0.5) !important; +} + +.text-hide { + font: 0/0 a; + color: transparent; + text-shadow: none; + background-color: transparent; + border: 0; +} + +.text-decoration-none { + text-decoration: none !important; +} + +.text-break { + word-break: break-word !important; + word-wrap: break-word !important; +} + +.text-reset { + color: inherit !important; +} + +.visible { + visibility: visible !important; +} + +.invisible { + visibility: hidden !important; +} + +@media print { + *, + *::before, + *::after { + text-shadow: none !important; + box-shadow: none !important; + } + a:not(.btn) { + text-decoration: underline; + } + abbr[title]::after { + content: " (" attr(title) ")"; + } + pre { + white-space: pre-wrap !important; + } + pre, + blockquote { + border: 1px solid #adb5bd; + page-break-inside: avoid; + } + tr, + img { + page-break-inside: avoid; + } + p, + h2, + h3 { + orphans: 3; + widows: 3; + } + h2, + h3 { + page-break-after: avoid; + } + @page { + size: a3; + } + body { + min-width: 992px !important; + } + .container { + min-width: 992px !important; + } + .navbar { + display: none; + } + .badge { + border: 1px solid #000; + } + .table { + border-collapse: collapse !important; + } + .table td, + .table th { + background-color: #fff !important; + } + .table-bordered th, + .table-bordered td { + border: 1px solid #dee2e6 !important; + } + .table-dark { + color: inherit; + } + .table-dark th, + .table-dark td, + .table-dark thead th, + .table-dark tbody + tbody { + border-color: #dee2e6; + } + .table .thead-dark th { + color: inherit; + border-color: #dee2e6; + } +}`, "",{"version":3,"sources":["webpack://./node_modules/bootstrap/scss/bootstrap.scss","webpack://./node_modules/bootstrap/scss/_root.scss","webpack://./node_modules/bootstrap/scss/_reboot.scss","webpack://./node_modules/bootstrap/scss/_variables.scss","webpack://./node_modules/bootstrap/scss/vendor/_rfs.scss","webpack://./node_modules/bootstrap/scss/mixins/_hover.scss","webpack://./node_modules/bootstrap/scss/_type.scss","webpack://./node_modules/bootstrap/scss/mixins/_lists.scss","webpack://./node_modules/bootstrap/scss/_images.scss","webpack://./node_modules/bootstrap/scss/mixins/_image.scss","webpack://./node_modules/bootstrap/scss/mixins/_border-radius.scss","webpack://./node_modules/bootstrap/scss/_code.scss","webpack://./node_modules/bootstrap/scss/_grid.scss","webpack://./node_modules/bootstrap/scss/mixins/_grid.scss","webpack://./node_modules/bootstrap/scss/mixins/_breakpoints.scss","webpack://./node_modules/bootstrap/scss/mixins/_grid-framework.scss","webpack://./node_modules/bootstrap/scss/_tables.scss","webpack://./node_modules/bootstrap/scss/mixins/_table-row.scss","webpack://./node_modules/bootstrap/scss/_forms.scss","webpack://./node_modules/bootstrap/scss/mixins/_transition.scss","webpack://./node_modules/bootstrap/scss/mixins/_forms.scss","webpack://./node_modules/bootstrap/scss/mixins/_gradients.scss","webpack://./node_modules/bootstrap/scss/_buttons.scss","webpack://./node_modules/bootstrap/scss/mixins/_buttons.scss","webpack://./node_modules/bootstrap/scss/_transitions.scss","webpack://./node_modules/bootstrap/scss/_dropdown.scss","webpack://./node_modules/bootstrap/scss/mixins/_caret.scss","webpack://./node_modules/bootstrap/scss/mixins/_nav-divider.scss","webpack://./node_modules/bootstrap/scss/_button-group.scss","webpack://./node_modules/bootstrap/scss/_input-group.scss","webpack://./node_modules/bootstrap/scss/_custom-forms.scss","webpack://./node_modules/bootstrap/scss/_nav.scss","webpack://./node_modules/bootstrap/scss/_navbar.scss","webpack://./node_modules/bootstrap/scss/_card.scss","webpack://./node_modules/bootstrap/scss/_breadcrumb.scss","webpack://./node_modules/bootstrap/scss/_pagination.scss","webpack://./node_modules/bootstrap/scss/mixins/_pagination.scss","webpack://./node_modules/bootstrap/scss/_badge.scss","webpack://./node_modules/bootstrap/scss/mixins/_badge.scss","webpack://./node_modules/bootstrap/scss/_jumbotron.scss","webpack://./node_modules/bootstrap/scss/_alert.scss","webpack://./node_modules/bootstrap/scss/mixins/_alert.scss","webpack://./node_modules/bootstrap/scss/_progress.scss","webpack://./node_modules/bootstrap/scss/_media.scss","webpack://./node_modules/bootstrap/scss/_list-group.scss","webpack://./node_modules/bootstrap/scss/mixins/_list-group.scss","webpack://./node_modules/bootstrap/scss/_close.scss","webpack://./node_modules/bootstrap/scss/_toasts.scss","webpack://./node_modules/bootstrap/scss/_modal.scss","webpack://./node_modules/bootstrap/scss/_tooltip.scss","webpack://./node_modules/bootstrap/scss/mixins/_reset-text.scss","webpack://./node_modules/bootstrap/scss/_popover.scss","webpack://./node_modules/bootstrap/scss/_carousel.scss","webpack://./node_modules/bootstrap/scss/mixins/_clearfix.scss","webpack://./node_modules/bootstrap/scss/_spinners.scss","webpack://./node_modules/bootstrap/scss/utilities/_align.scss","webpack://./node_modules/bootstrap/scss/mixins/_background-variant.scss","webpack://./node_modules/bootstrap/scss/utilities/_background.scss","webpack://./node_modules/bootstrap/scss/utilities/_borders.scss","webpack://./node_modules/bootstrap/scss/utilities/_display.scss","webpack://./node_modules/bootstrap/scss/utilities/_embed.scss","webpack://./node_modules/bootstrap/scss/utilities/_flex.scss","webpack://./node_modules/bootstrap/scss/utilities/_float.scss","webpack://./node_modules/bootstrap/scss/utilities/_interactions.scss","webpack://./node_modules/bootstrap/scss/utilities/_overflow.scss","webpack://./node_modules/bootstrap/scss/utilities/_position.scss","webpack://./node_modules/bootstrap/scss/utilities/_screenreaders.scss","webpack://./node_modules/bootstrap/scss/mixins/_screen-reader.scss","webpack://./node_modules/bootstrap/scss/utilities/_shadows.scss","webpack://./node_modules/bootstrap/scss/utilities/_sizing.scss","webpack://./node_modules/bootstrap/scss/utilities/_spacing.scss","webpack://./node_modules/bootstrap/scss/utilities/_stretched-link.scss","webpack://./node_modules/bootstrap/scss/utilities/_text.scss","webpack://./node_modules/bootstrap/scss/mixins/_text-truncate.scss","webpack://./node_modules/bootstrap/scss/mixins/_text-emphasis.scss","webpack://./node_modules/bootstrap/scss/mixins/_text-hide.scss","webpack://./node_modules/bootstrap/scss/utilities/_visibility.scss","webpack://./node_modules/bootstrap/scss/_print.scss"],"names":[],"mappings":"AAAA,gBAAgB;AAAhB;;;;;EAAA;ACAA;EAGI,eAAA;EAAA,iBAAA;EAAA,iBAAA;EAAA,eAAA;EAAA,cAAA;EAAA,iBAAA;EAAA,iBAAA;EAAA,gBAAA;EAAA,eAAA;EAAA,eAAA;EAAA,aAAA;EAAA,eAAA;EAAA,oBAAA;EAIA,kBAAA;EAAA,oBAAA;EAAA,kBAAA;EAAA,eAAA;EAAA,kBAAA;EAAA,iBAAA;EAAA,gBAAA;EAAA,eAAA;EAIA,kBAAA;EAAA,sBAAA;EAAA,sBAAA;EAAA,sBAAA;EAAA,uBAAA;EAKF,kOAAA;EACA,6GAAA;ADmBF;;AElBA;;;EAGE,sBAAA;AFqBF;;AElBA;EACE,uBAAA;EACA,iBAAA;EACA,8BAAA;EACA,6CAAA;AFqBF;;AEfA;EACE,cAAA;AFkBF;;AERA;EACE,SAAA;EACA,qNCsO4B;ECjGxB,eAAA;EFnIJ,gBC+O4B;ED9O5B,gBCmP4B;EDlP5B,cCnCS;EDoCT,gBAAA;EACA,sBC9CS;AHyDX;;AECA;EACE,qBAAA;AFEF;;AEOA;EACE,uBAAA;EACA,SAAA;EACA,iBAAA;AFJF;;AEiBA;EACE,aAAA;EACA,qBCiN4B;AH/N9B;;AEqBA;EACE,aAAA;EACA,mBCoF0B;AHtG5B;;AE6BA;;EAEE,0BAAA;EACA,iCAAA;EACA,YAAA;EACA,gBAAA;EACA,8BAAA;AF1BF;;AE6BA;EACE,mBAAA;EACA,kBAAA;EACA,oBAAA;AF1BF;;AE6BA;;;EAGE,aAAA;EACA,mBAAA;AF1BF;;AE6BA;;;;EAIE,gBAAA;AF1BF;;AE6BA;EACE,gBCkJ4B;AH5K9B;;AE6BA;EACE,qBAAA;EACA,cAAA;AF1BF;;AE6BA;EACE,gBAAA;AF1BF;;AE6BA;;EAEE,mBCqI4B;AH/J9B;;AE6BA;EEII,cAAA;AJ7BJ;;AEkCA;;EAEE,kBAAA;EEPE,cAAA;EFSF,cAAA;EACA,wBAAA;AF/BF;;AEkCA;EAAM,eAAA;AF9BN;;AE+BA;EAAM,WAAA;AF3BN;;AEkCA;EACE,cCXwC;EDYxC,qBCXwC;EDYxC,6BAAA;AF/BF;AKjJE;EHmLE,cCdsC;EDetC,0BCdsC;AHjB1C;;AEwCA;EACE,cAAA;EACA,qBAAA;AFrCF;AK1JE;EHkME,cAAA;EACA,qBAAA;AFrCJ;;AE8CA;;;;EAIE,iGC0D4B;EClH1B,cAAA;AJcJ;;AE8CA;EAEE,aAAA;EAEA,mBAAA;EAEA,cAAA;EAGA,6BAAA;AFhDF;;AEwDA;EAEE,gBAAA;AFtDF;;AE8DA;EACE,sBAAA;EACA,kBAAA;AF3DF;;AE8DA;EAGE,gBAAA;EACA,sBAAA;AF7DF;;AEqEA;EACE,yBAAA;AFlEF;;AEqEA;EACE,oBC8E4B;ED7E5B,uBC6E4B;ED5E5B,cCtQS;EDuQT,gBAAA;EACA,oBAAA;AFlEF;;AEyEA;EAEE,mBAAA;EACA,gCAAA;AFvEF;;AE+EA;EAEE,qBAAA;EACA,qBC4JsC;AHzOxC;;AEmFA;EAEE,gBAAA;AFjFF;;AEyFA;EACE,UAAA;AFtFF;;AEyFA;;;;;EAKE,SAAA;EACA,oBAAA;EEhKE,kBAAA;EFkKF,oBAAA;AFtFF;;AEyFA;;EAEE,iBAAA;AFtFF;;AEyFA;;EAEE,oBAAA;AFtFF;;AE4FA;EACE,eAAA;AFzFF;;AE+FA;EACE,iBAAA;AF5FF;;AEmGA;;;;EAIE,0BAAA;AFhGF;;AEyGI;;;;EACE,eAAA;AFnGN;;AEyGA;;;;EAIE,UAAA;EACA,kBAAA;AFtGF;;AEyGA;;EAEE,sBAAA;EACA,UAAA;AFtGF;;AE0GA;EACE,cAAA;EAEA,gBAAA;AFxGF;;AE2GA;EAME,YAAA;EAEA,UAAA;EACA,SAAA;EACA,SAAA;AF9GF;;AEmHA;EACE,cAAA;EACA,WAAA;EACA,eAAA;EACA,UAAA;EACA,qBAAA;EE9OI,iBAAA;EFgPJ,oBAAA;EACA,cAAA;EACA,mBAAA;AFhHF;;AEmHA;EACE,wBAAA;AFhHF;;AEoHA;;EAEE,YAAA;AFjHF;;AEoHA;EAKE,oBAAA;EACA,wBAAA;AFrHF;;AE4HA;EACE,wBAAA;AFzHF;;AEiIA;EACE,aAAA;EACA,0BAAA;AF9HF;;AEqIA;EACE,qBAAA;AFlIF;;AEqIA;EACE,kBAAA;EACA,eAAA;AFlIF;;AEqIA;EACE,aAAA;AFlIF;;AEuIA;EACE,wBAAA;AFpIF;;AMxVA;;EAEE,qBHsS4B;EGpS5B,gBHsS4B;EGrS5B,gBHsS4B;AHoD9B;;AMtVA;EFqKM,iBAAA;AJqLN;;AMzVA;EFoKM,eAAA;AJyLN;;AM5VA;EFmKM,kBAAA;AJ6LN;;AM/VA;EFkKM,iBAAA;AJiMN;;AMlWA;EFiKM,kBAAA;AJqMN;;AMrWA;EFgKM,eAAA;AJyMN;;AMvWA;EF8JM,kBAAA;EE5JJ,gBHwS4B;AHkE9B;;AMtWA;EFwJM,eAAA;EEtJJ,gBH2R4B;EG1R5B,gBHkR4B;AHuF9B;;AMvWA;EFmJM,iBAAA;EEjJJ,gBHuR4B;EGtR5B,gBH6Q4B;AH6F9B;;AMxWA;EF8IM,iBAAA;EE5IJ,gBHmR4B;EGlR5B,gBHwQ4B;AHmG9B;;AMzWA;EFyIM,iBAAA;EEvIJ,gBH+Q4B;EG9Q5B,gBHmQ4B;AHyG9B;;AMpWA;EACE,gBHgFO;EG/EP,mBH+EO;EG9EP,SAAA;EACA,wCAAA;ANuWF;;AM/VA;;EFkGI,kBAAA;EE/FF,gBH2N4B;AHuI9B;;AM/VA;;EAEE,cHmQ4B;EGlQ5B,yBH2Q4B;AHuF9B;;AM1VA;EC/EE,eAAA;EACA,gBAAA;AP6aF;;AM1VA;ECpFE,eAAA;EACA,gBAAA;APkbF;;AM5VA;EACE,qBAAA;AN+VF;AM7VE;EACE,oBHqP0B;AH0G9B;;AMrVA;EF2DI,cAAA;EEzDF,yBAAA;ANwVF;;AMpVA;EACE,mBHuBO;EC6CH,kBAAA;AJoRN;;AMpVA;EACE,cAAA;EF+CE,kBAAA;EE7CF,cH1GS;AHicX;AMrVE;EACE,aAAA;ANuVJ;;AQ1cA;ECIE,eAAA;EAGA,YAAA;ATwcF;;AQzcA;EACE,gBLqgCkC;EKpgClC,sBLRS;EKST,yBAAA;EEEE,sBAAA;EDPF,eAAA;EAGA,YAAA;ATidF;;AQncA;EAEE,qBAAA;ARqcF;;AQlcA;EACE,qBAAA;EACA,cAAA;ARqcF;;AQlcA;EJ8HI,cAAA;EI5HF,cL3BS;AHgeX;;AW5eA;EPmKI,gBAAA;EOjKF,cRmCQ;EQlCR,qBAAA;AX+eF;AW5eE;EACE,cAAA;AX8eJ;;AWzeA;EACE,sBAAA;EPsJE,gBAAA;EOpJF,WRTS;EQUT,yBRDS;EOEP,qBAAA;AV4eJ;AWzeE;EACE,UAAA;EP8IA,eAAA;EO5IA,gBRyQ0B;AHkO9B;;AWreA;EACE,cAAA;EPqIE,gBAAA;EOnIF,cRjBS;AHyfX;AWreE;EPgIE,kBAAA;EO9HA,cAAA;EACA,kBAAA;AXueJ;;AWleA;EACE,iBRikCkC;EQhkClC,kBAAA;AXqeF;;AY7gBE;;;;;;ECDA,WAAA;EACA,mBAAA;EACA,kBAAA;EACA,kBAAA;EACA,iBAAA;AbuhBF;;AcpeI;EFzCE;IACE,gBT8Le;EHmVrB;AACF;Ac1eI;EFzCE;IACE,gBT8Le;EHwVrB;AACF;Ac/eI;EFzCE;IACE,gBT8Le;EH6VrB;AACF;AcpfI;EFzCE;IACE,iBT8Le;EHkWrB;AACF;AYrgBE;ECnCA,aAAA;EACA,eAAA;EACA,mBAAA;EACA,kBAAA;Ab2iBF;;AYrgBE;EACE,eAAA;EACA,cAAA;AZwgBJ;AYtgBI;;EAEE,gBAAA;EACA,eAAA;AZwgBN;;Ae9jBE;;;;;;EACE,kBAAA;EACA,WAAA;EACA,mBAAA;EACA,kBAAA;AfskBJ;;AehjBM;EACE,aAAA;EACA,YAAA;EACA,eAAA;AfmjBR;;AavhBE;EACE,cAAA;EACA,eAAA;Ab0hBJ;;Aa5hBE;EACE,aAAA;EACA,cAAA;Ab+hBJ;;AajiBE;EACE,wBAAA;EACA,yBAAA;AboiBJ;;AatiBE;EACE,aAAA;EACA,cAAA;AbyiBJ;;Aa3iBE;EACE,aAAA;EACA,cAAA;Ab8iBJ;;AahjBE;EACE,wBAAA;EACA,yBAAA;AbmjBJ;;AetkBM;EFCJ,cAAA;EACA,WAAA;EACA,eAAA;AbykBF;;AetkBU;EFbR,qBAAA;EAIA,sBAAA;AbolBF;;Ae3kBU;EFbR,sBAAA;EAIA,uBAAA;AbylBF;;AehlBU;EFbR,aAAA;EAIA,cAAA;Ab8lBF;;AerlBU;EFbR,sBAAA;EAIA,uBAAA;AbmmBF;;Ae1lBU;EFbR,sBAAA;EAIA,uBAAA;AbwmBF;;Ae/lBU;EFbR,aAAA;EAIA,cAAA;Ab6mBF;;AepmBU;EFbR,sBAAA;EAIA,uBAAA;AbknBF;;AezmBU;EFbR,sBAAA;EAIA,uBAAA;AbunBF;;Ae9mBU;EFbR,aAAA;EAIA,cAAA;Ab4nBF;;AennBU;EFbR,sBAAA;EAIA,uBAAA;AbioBF;;AexnBU;EFbR,sBAAA;EAIA,uBAAA;AbsoBF;;Ae7nBU;EFbR,cAAA;EAIA,eAAA;Ab2oBF;;Ae5nBM;EAAwB,SAAA;AfgoB9B;;Ae9nBM;EAAuB,SAAA;AfkoB7B;;Ae/nBQ;EAAwB,QADb;AfooBnB;;AenoBQ;EAAwB,QADb;AfwoBnB;;AevoBQ;EAAwB,QADb;Af4oBnB;;Ae3oBQ;EAAwB,QADb;AfgpBnB;;Ae/oBQ;EAAwB,QADb;AfopBnB;;AenpBQ;EAAwB,QADb;AfwpBnB;;AevpBQ;EAAwB,QADb;Af4pBnB;;Ae3pBQ;EAAwB,QADb;AfgqBnB;;Ae/pBQ;EAAwB,QADb;AfoqBnB;;AenqBQ;EAAwB,QADb;AfwqBnB;;AevqBQ;EAAwB,SADb;Af4qBnB;;Ae3qBQ;EAAwB,SADb;AfgrBnB;;Ae/qBQ;EAAwB,SADb;AforBnB;;Ae5qBY;EFhBV,wBAAA;AbgsBF;;AehrBY;EFhBV,yBAAA;AbosBF;;AeprBY;EFhBV,gBAAA;AbwsBF;;AexrBY;EFhBV,yBAAA;Ab4sBF;;Ae5rBY;EFhBV,yBAAA;AbgtBF;;AehsBY;EFhBV,gBAAA;AbotBF;;AepsBY;EFhBV,yBAAA;AbwtBF;;AexsBY;EFhBV,yBAAA;Ab4tBF;;Ae5sBY;EFhBV,gBAAA;AbguBF;;AehtBY;EFhBV,yBAAA;AbouBF;;AeptBY;EFhBV,yBAAA;AbwuBF;;AcnuBI;EC3BE;IACE,aAAA;IACA,YAAA;IACA,eAAA;EfkwBN;EatuBA;IACE,cAAA;IACA,eAAA;EbwuBF;Ea1uBA;IACE,aAAA;IACA,cAAA;Eb4uBF;Ea9uBA;IACE,wBAAA;IACA,yBAAA;EbgvBF;EalvBA;IACE,aAAA;IACA,cAAA;EbovBF;EatvBA;IACE,aAAA;IACA,cAAA;EbwvBF;Ea1vBA;IACE,wBAAA;IACA,yBAAA;Eb4vBF;Ee/wBI;IFCJ,cAAA;IACA,WAAA;IACA,eAAA;EbixBA;Ee9wBQ;IFbR,qBAAA;IAIA,sBAAA;Eb2xBA;EelxBQ;IFbR,sBAAA;IAIA,uBAAA;Eb+xBA;EetxBQ;IFbR,aAAA;IAIA,cAAA;EbmyBA;Ee1xBQ;IFbR,sBAAA;IAIA,uBAAA;EbuyBA;Ee9xBQ;IFbR,sBAAA;IAIA,uBAAA;Eb2yBA;EelyBQ;IFbR,aAAA;IAIA,cAAA;Eb+yBA;EetyBQ;IFbR,sBAAA;IAIA,uBAAA;EbmzBA;Ee1yBQ;IFbR,sBAAA;IAIA,uBAAA;EbuzBA;Ee9yBQ;IFbR,aAAA;IAIA,cAAA;Eb2zBA;EelzBQ;IFbR,sBAAA;IAIA,uBAAA;Eb+zBA;EetzBQ;IFbR,sBAAA;IAIA,uBAAA;Ebm0BA;Ee1zBQ;IFbR,cAAA;IAIA,eAAA;Ebu0BA;EexzBI;IAAwB,SAAA;Ef2zB5B;EezzBI;IAAuB,SAAA;Ef4zB3B;EezzBM;IAAwB,QADb;Ef6zBjB;Ee5zBM;IAAwB,QADb;Efg0BjB;Ee/zBM;IAAwB,QADb;Efm0BjB;Eel0BM;IAAwB,QADb;Efs0BjB;Eer0BM;IAAwB,QADb;Efy0BjB;Eex0BM;IAAwB,QADb;Ef40BjB;Ee30BM;IAAwB,QADb;Ef+0BjB;Ee90BM;IAAwB,QADb;Efk1BjB;Eej1BM;IAAwB,QADb;Efq1BjB;Eep1BM;IAAwB,QADb;Efw1BjB;Eev1BM;IAAwB,SADb;Ef21BjB;Ee11BM;IAAwB,SADb;Ef81BjB;Ee71BM;IAAwB,SADb;Efi2BjB;Eez1BU;IFhBV,cAAA;Eb42BA;Ee51BU;IFhBV,wBAAA;Eb+2BA;Ee/1BU;IFhBV,yBAAA;Ebk3BA;Eel2BU;IFhBV,gBAAA;Ebq3BA;Eer2BU;IFhBV,yBAAA;Ebw3BA;Eex2BU;IFhBV,yBAAA;Eb23BA;Ee32BU;IFhBV,gBAAA;Eb83BA;Ee92BU;IFhBV,yBAAA;Ebi4BA;Eej3BU;IFhBV,yBAAA;Ebo4BA;Eep3BU;IFhBV,gBAAA;Ebu4BA;Eev3BU;IFhBV,yBAAA;Eb04BA;Ee13BU;IFhBV,yBAAA;Eb64BA;AACF;Acz4BI;EC3BE;IACE,aAAA;IACA,YAAA;IACA,eAAA;Efu6BN;Ea34BA;IACE,cAAA;IACA,eAAA;Eb64BF;Ea/4BA;IACE,aAAA;IACA,cAAA;Ebi5BF;Ean5BA;IACE,wBAAA;IACA,yBAAA;Ebq5BF;Eav5BA;IACE,aAAA;IACA,cAAA;Eby5BF;Ea35BA;IACE,aAAA;IACA,cAAA;Eb65BF;Ea/5BA;IACE,wBAAA;IACA,yBAAA;Ebi6BF;Eep7BI;IFCJ,cAAA;IACA,WAAA;IACA,eAAA;Ebs7BA;Een7BQ;IFbR,qBAAA;IAIA,sBAAA;Ebg8BA;Eev7BQ;IFbR,sBAAA;IAIA,uBAAA;Ebo8BA;Ee37BQ;IFbR,aAAA;IAIA,cAAA;Ebw8BA;Ee/7BQ;IFbR,sBAAA;IAIA,uBAAA;Eb48BA;Een8BQ;IFbR,sBAAA;IAIA,uBAAA;Ebg9BA;Eev8BQ;IFbR,aAAA;IAIA,cAAA;Ebo9BA;Ee38BQ;IFbR,sBAAA;IAIA,uBAAA;Ebw9BA;Ee/8BQ;IFbR,sBAAA;IAIA,uBAAA;Eb49BA;Een9BQ;IFbR,aAAA;IAIA,cAAA;Ebg+BA;Eev9BQ;IFbR,sBAAA;IAIA,uBAAA;Ebo+BA;Ee39BQ;IFbR,sBAAA;IAIA,uBAAA;Ebw+BA;Ee/9BQ;IFbR,cAAA;IAIA,eAAA;Eb4+BA;Ee79BI;IAAwB,SAAA;Efg+B5B;Ee99BI;IAAuB,SAAA;Efi+B3B;Ee99BM;IAAwB,QADb;Efk+BjB;Eej+BM;IAAwB,QADb;Efq+BjB;Eep+BM;IAAwB,QADb;Efw+BjB;Eev+BM;IAAwB,QADb;Ef2+BjB;Ee1+BM;IAAwB,QADb;Ef8+BjB;Ee7+BM;IAAwB,QADb;Efi/BjB;Eeh/BM;IAAwB,QADb;Efo/BjB;Een/BM;IAAwB,QADb;Efu/BjB;Eet/BM;IAAwB,QADb;Ef0/BjB;Eez/BM;IAAwB,QADb;Ef6/BjB;Ee5/BM;IAAwB,SADb;EfggCjB;Ee//BM;IAAwB,SADb;EfmgCjB;EelgCM;IAAwB,SADb;EfsgCjB;Ee9/BU;IFhBV,cAAA;EbihCA;EejgCU;IFhBV,wBAAA;EbohCA;EepgCU;IFhBV,yBAAA;EbuhCA;EevgCU;IFhBV,gBAAA;Eb0hCA;Ee1gCU;IFhBV,yBAAA;Eb6hCA;Ee7gCU;IFhBV,yBAAA;EbgiCA;EehhCU;IFhBV,gBAAA;EbmiCA;EenhCU;IFhBV,yBAAA;EbsiCA;EethCU;IFhBV,yBAAA;EbyiCA;EezhCU;IFhBV,gBAAA;Eb4iCA;Ee5hCU;IFhBV,yBAAA;Eb+iCA;Ee/hCU;IFhBV,yBAAA;EbkjCA;AACF;Ac9iCI;EC3BE;IACE,aAAA;IACA,YAAA;IACA,eAAA;Ef4kCN;EahjCA;IACE,cAAA;IACA,eAAA;EbkjCF;EapjCA;IACE,aAAA;IACA,cAAA;EbsjCF;EaxjCA;IACE,wBAAA;IACA,yBAAA;Eb0jCF;Ea5jCA;IACE,aAAA;IACA,cAAA;Eb8jCF;EahkCA;IACE,aAAA;IACA,cAAA;EbkkCF;EapkCA;IACE,wBAAA;IACA,yBAAA;EbskCF;EezlCI;IFCJ,cAAA;IACA,WAAA;IACA,eAAA;Eb2lCA;EexlCQ;IFbR,qBAAA;IAIA,sBAAA;EbqmCA;Ee5lCQ;IFbR,sBAAA;IAIA,uBAAA;EbymCA;EehmCQ;IFbR,aAAA;IAIA,cAAA;Eb6mCA;EepmCQ;IFbR,sBAAA;IAIA,uBAAA;EbinCA;EexmCQ;IFbR,sBAAA;IAIA,uBAAA;EbqnCA;Ee5mCQ;IFbR,aAAA;IAIA,cAAA;EbynCA;EehnCQ;IFbR,sBAAA;IAIA,uBAAA;Eb6nCA;EepnCQ;IFbR,sBAAA;IAIA,uBAAA;EbioCA;EexnCQ;IFbR,aAAA;IAIA,cAAA;EbqoCA;Ee5nCQ;IFbR,sBAAA;IAIA,uBAAA;EbyoCA;EehoCQ;IFbR,sBAAA;IAIA,uBAAA;Eb6oCA;EepoCQ;IFbR,cAAA;IAIA,eAAA;EbipCA;EeloCI;IAAwB,SAAA;EfqoC5B;EenoCI;IAAuB,SAAA;EfsoC3B;EenoCM;IAAwB,QADb;EfuoCjB;EetoCM;IAAwB,QADb;Ef0oCjB;EezoCM;IAAwB,QADb;Ef6oCjB;Ee5oCM;IAAwB,QADb;EfgpCjB;Ee/oCM;IAAwB,QADb;EfmpCjB;EelpCM;IAAwB,QADb;EfspCjB;EerpCM;IAAwB,QADb;EfypCjB;EexpCM;IAAwB,QADb;Ef4pCjB;Ee3pCM;IAAwB,QADb;Ef+pCjB;Ee9pCM;IAAwB,QADb;EfkqCjB;EejqCM;IAAwB,SADb;EfqqCjB;EepqCM;IAAwB,SADb;EfwqCjB;EevqCM;IAAwB,SADb;Ef2qCjB;EenqCU;IFhBV,cAAA;EbsrCA;EetqCU;IFhBV,wBAAA;EbyrCA;EezqCU;IFhBV,yBAAA;Eb4rCA;Ee5qCU;IFhBV,gBAAA;Eb+rCA;Ee/qCU;IFhBV,yBAAA;EbksCA;EelrCU;IFhBV,yBAAA;EbqsCA;EerrCU;IFhBV,gBAAA;EbwsCA;EexrCU;IFhBV,yBAAA;Eb2sCA;Ee3rCU;IFhBV,yBAAA;Eb8sCA;Ee9rCU;IFhBV,gBAAA;EbitCA;EejsCU;IFhBV,yBAAA;EbotCA;EepsCU;IFhBV,yBAAA;EbutCA;AACF;AcntCI;EC3BE;IACE,aAAA;IACA,YAAA;IACA,eAAA;EfivCN;EartCA;IACE,cAAA;IACA,eAAA;EbutCF;EaztCA;IACE,aAAA;IACA,cAAA;Eb2tCF;Ea7tCA;IACE,wBAAA;IACA,yBAAA;Eb+tCF;EajuCA;IACE,aAAA;IACA,cAAA;EbmuCF;EaruCA;IACE,aAAA;IACA,cAAA;EbuuCF;EazuCA;IACE,wBAAA;IACA,yBAAA;Eb2uCF;Ee9vCI;IFCJ,cAAA;IACA,WAAA;IACA,eAAA;EbgwCA;Ee7vCQ;IFbR,qBAAA;IAIA,sBAAA;Eb0wCA;EejwCQ;IFbR,sBAAA;IAIA,uBAAA;Eb8wCA;EerwCQ;IFbR,aAAA;IAIA,cAAA;EbkxCA;EezwCQ;IFbR,sBAAA;IAIA,uBAAA;EbsxCA;Ee7wCQ;IFbR,sBAAA;IAIA,uBAAA;Eb0xCA;EejxCQ;IFbR,aAAA;IAIA,cAAA;Eb8xCA;EerxCQ;IFbR,sBAAA;IAIA,uBAAA;EbkyCA;EezxCQ;IFbR,sBAAA;IAIA,uBAAA;EbsyCA;Ee7xCQ;IFbR,aAAA;IAIA,cAAA;Eb0yCA;EejyCQ;IFbR,sBAAA;IAIA,uBAAA;Eb8yCA;EeryCQ;IFbR,sBAAA;IAIA,uBAAA;EbkzCA;EezyCQ;IFbR,cAAA;IAIA,eAAA;EbszCA;EevyCI;IAAwB,SAAA;Ef0yC5B;EexyCI;IAAuB,SAAA;Ef2yC3B;EexyCM;IAAwB,QADb;Ef4yCjB;Ee3yCM;IAAwB,QADb;Ef+yCjB;Ee9yCM;IAAwB,QADb;EfkzCjB;EejzCM;IAAwB,QADb;EfqzCjB;EepzCM;IAAwB,QADb;EfwzCjB;EevzCM;IAAwB,QADb;Ef2zCjB;Ee1zCM;IAAwB,QADb;Ef8zCjB;Ee7zCM;IAAwB,QADb;Efi0CjB;Eeh0CM;IAAwB,QADb;Efo0CjB;Een0CM;IAAwB,QADb;Efu0CjB;Eet0CM;IAAwB,SADb;Ef00CjB;Eez0CM;IAAwB,SADb;Ef60CjB;Ee50CM;IAAwB,SADb;Efg1CjB;Eex0CU;IFhBV,cAAA;Eb21CA;Ee30CU;IFhBV,wBAAA;Eb81CA;Ee90CU;IFhBV,yBAAA;Ebi2CA;Eej1CU;IFhBV,gBAAA;Ebo2CA;Eep1CU;IFhBV,yBAAA;Ebu2CA;Eev1CU;IFhBV,yBAAA;Eb02CA;Ee11CU;IFhBV,gBAAA;Eb62CA;Ee71CU;IFhBV,yBAAA;Ebg3CA;Eeh2CU;IFhBV,yBAAA;Ebm3CA;Een2CU;IFhBV,gBAAA;Ebs3CA;Eet2CU;IFhBV,yBAAA;Eby3CA;Eez2CU;IFhBV,yBAAA;Eb43CA;AACF;AgBh7CA;EACE,WAAA;EACA,mBbiIO;EahIP,cbSS;AHy6CX;AgB/6CE;;EAEE,gBbmV0B;EalV1B,mBAAA;EACA,6BAAA;AhBi7CJ;AgB96CE;EACE,sBAAA;EACA,gCAAA;AhBg7CJ;AgB76CE;EACE,6BAAA;AhB+6CJ;;AgBr6CE;;EAEE,eb6T0B;AH2mC9B;;AgB/5CA;EACE,yBAAA;AhBk6CF;AgBh6CE;;EAEE,yBAAA;AhBk6CJ;AgB95CI;;EAEE,wBAAA;AhBg6CN;;AgB15CE;;;;EAIE,SAAA;AhB65CJ;;AgBp5CE;EACE,qCbyR0B;AH8nC9B;;AKt9CE;EW2EI,cbvEK;EawEL,sCb8QwB;AHioC9B;;AiBj+CI;;;EAGE,yBD2F+B;AhBy4CrC;AiBh+CM;;;;EAIE,qBDmFyE;AhB+4CjF;;AKv+CE;EYiBM,yBAJe;AjB89CvB;AiBx9CQ;;EAEE,yBARa;AjBk+CvB;;AiBr/CI;;;EAGE,yBD2F+B;AhB65CrC;AiBp/CM;;;;EAIE,qBDmFyE;AhBm6CjF;;AK3/CE;EYiBM,yBAJe;AjBk/CvB;AiB5+CQ;;EAEE,yBARa;AjBs/CvB;;AiBzgDI;;;EAGE,yBD2F+B;AhBi7CrC;AiBxgDM;;;;EAIE,qBDmFyE;AhBu7CjF;;AK/gDE;EYiBM,yBAJe;AjBsgDvB;AiBhgDQ;;EAEE,yBARa;AjB0gDvB;;AiB7hDI;;;EAGE,yBD2F+B;AhBq8CrC;AiB5hDM;;;;EAIE,qBDmFyE;AhB28CjF;;AKniDE;EYiBM,yBAJe;AjB0hDvB;AiBphDQ;;EAEE,yBARa;AjB8hDvB;;AiBjjDI;;;EAGE,yBD2F+B;AhBy9CrC;AiBhjDM;;;;EAIE,qBDmFyE;AhB+9CjF;;AKvjDE;EYiBM,yBAJe;AjB8iDvB;AiBxiDQ;;EAEE,yBARa;AjBkjDvB;;AiBrkDI;;;EAGE,yBD2F+B;AhB6+CrC;AiBpkDM;;;;EAIE,qBDmFyE;AhBm/CjF;;AK3kDE;EYiBM,yBAJe;AjBkkDvB;AiB5jDQ;;EAEE,yBARa;AjBskDvB;;AiBzlDI;;;EAGE,yBD2F+B;AhBigDrC;AiBxlDM;;;;EAIE,qBDmFyE;AhBugDjF;;AK/lDE;EYiBM,yBAJe;AjBslDvB;AiBhlDQ;;EAEE,yBARa;AjB0lDvB;;AiB7mDI;;;EAGE,yBD2F+B;AhBqhDrC;AiB5mDM;;;;EAIE,qBDmFyE;AhB2hDjF;;AKnnDE;EYiBM,yBAJe;AjB0mDvB;AiBpmDQ;;EAEE,yBARa;AjB8mDvB;;AiBjoDI;;;EAGE,sCd6VwB;AHuyC9B;;AKjoDE;EYiBM,sCAJe;AjBwnDvB;AiBlnDQ;;EAEE,sCARa;AjB4nDvB;;AgBpiDI;EACE,Wb3GK;Ea4GL,yBbpGK;EaqGL,qBbiQwB;AHsyC9B;AgBliDI;EACE,cb5GK;Ea6GL,yBblHK;EamHL,qBblHK;AHspDX;;AgB/hDA;EACE,Wb3HS;Ea4HT,yBbpHS;AHspDX;AgBhiDE;;;EAGE,qBb6O0B;AHqzC9B;AgB/hDE;EACE,SAAA;AhBiiDJ;AgB7hDI;EACE,2CbiOwB;AH8zC9B;AKpqDE;EW4IM,WbjJG;EakJH,4Cb2NsB;AHg0C9B;;Ac3mDI;EEiGA;IAEI,cAAA;IACA,WAAA;IACA,gBAAA;IACA,iCAAA;EhB6gDN;EgB1gDM;IACE,SAAA;EhB4gDR;AACF;AcvnDI;EEiGA;IAEI,cAAA;IACA,WAAA;IACA,gBAAA;IACA,iCAAA;EhBwhDN;EgBrhDM;IACE,SAAA;EhBuhDR;AACF;AcloDI;EEiGA;IAEI,cAAA;IACA,WAAA;IACA,gBAAA;IACA,iCAAA;EhBmiDN;EgBhiDM;IACE,SAAA;EhBkiDR;AACF;Ac7oDI;EEiGA;IAEI,cAAA;IACA,WAAA;IACA,gBAAA;IACA,iCAAA;EhB8iDN;EgB3iDM;IACE,SAAA;EhB6iDR;AACF;AgBvjDI;EAEI,cAAA;EACA,WAAA;EACA,gBAAA;EACA,iCAAA;AhBwjDR;AgBrjDQ;EACE,SAAA;AhBujDV;;AkBpuDA;EACE,cAAA;EACA,WAAA;EACA,mCf2esC;Ee1etC,yBAAA;Ed0KI,eAAA;EcvKJ,gBfmR4B;EelR5B,gBfuR4B;EetR5B,cfDS;EeET,sBfTS;EeUT,4BAAA;EACA,yBAAA;ERAE,sBAAA;ESFE,wEDQJ;AlBkuDF;AmBtuDM;EDdN;ICeQ,gBAAA;EnByuDN;AACF;AkBpuDE;EACE,6BAAA;EACA,SAAA;AlBsuDJ;AoBtvDE;EACE,cAAA;EACA,sBjBRO;EiBSP,qBjBsdoC;EiBrdpC,UAAA;EAKE,gDjBqXwB;AH+3C9B;AkBtuDE;EACE,cfxBO;Ee0BP,UAAA;AlBuuDJ;AkB/tDE;EAEE,yBfxCO;Ee0CP,UAAA;AlB+tDJ;;AkBvtDE;;;;EACE,gBAAA;AlB6tDJ;;AkBvtDE;EACE,kBAAA;EACA,0BAAA;AlB0tDJ;AkBvtDE;EAME,cf/DO;EegEP,sBfvEO;AH2xDX;;AkB/sDA;;EAEE,cAAA;EACA,WAAA;AlBktDF;;AkBxsDA;EACE,iCAAA;EACA,oCAAA;EACA,gBAAA;EdiEE,kBAAA;Ec/DF,gBfgM4B;AH2gD9B;;AkBxsDA;EACE,+BAAA;EACA,kCAAA;Ed0EI,kBAAA;EcxEJ,gBf6H4B;AH8kD9B;;AkBxsDA;EACE,gCAAA;EACA,mCAAA;EdmEI,mBAAA;EcjEJ,gBfuH4B;AHolD9B;;AkBlsDA;EACE,cAAA;EACA,WAAA;EACA,mBAAA;EACA,gBAAA;EdoDI,eAAA;EclDJ,gBfmK4B;EelK5B,cfnHS;EeoHT,6BAAA;EACA,yBAAA;EACA,mBAAA;AlBqsDF;AkBnsDE;EAEE,gBAAA;EACA,eAAA;AlBosDJ;;AkBxrDA;EACE,kCf6VsC;Ee5VtC,uBAAA;Ed2BI,mBAAA;EczBJ,gBf+E4B;EOxN1B,qBAAA;AVq0DJ;;AkBxrDA;EACE,gCfsVsC;EerVtC,oBAAA;EdmBI,kBAAA;EcjBJ,gBfsE4B;EOvN1B,qBAAA;AV60DJ;;AkBtrDE;EAEE,YAAA;AlBwrDJ;;AkBprDA;EACE,YAAA;AlBurDF;;AkB/qDA;EACE,mBf2UsC;AHu2CxC;;AkB/qDA;EACE,cAAA;EACA,mBf4TsC;AHs3CxC;;AkB1qDA;EACE,aAAA;EACA,eAAA;EACA,kBAAA;EACA,iBAAA;AlB6qDF;AkB3qDE;;EAEE,kBAAA;EACA,iBAAA;AlB6qDJ;;AkBpqDA;EACE,kBAAA;EACA,cAAA;EACA,qBfiSsC;AHs4CxC;;AkBpqDA;EACE,kBAAA;EACA,kBf6RsC;Ee5RtC,qBAAA;AlBuqDF;AkBpqDE;EAEE,cfzNO;AH83DX;;AkBjqDA;EACE,gBAAA;AlBoqDF;;AkBjqDA;EACE,oBAAA;EACA,mBAAA;EACA,eAAA;EACA,qBf8QsC;AHs5CxC;AkBjqDE;EACE,gBAAA;EACA,aAAA;EACA,uBfyQoC;EexQpC,cAAA;AlBmqDJ;;AoBh3DE;EACE,aAAA;EACA,WAAA;EACA,mBjB2coC;ECtVpC,kBAAA;EgBnHA,cFqNqC;AlB8pDzC;;AoBh3DE;EACE,kBAAA;EACA,SAAA;EACA,OAAA;EACA,UAAA;EACA,aAAA;EACA,eAAA;EACA,uBAAA;EACA,kBAAA;EhBwHE,mBAAA;EgBtHF,gBjBuO0B;EiBtO1B,WAAA;EACA,wCAAA;EV9CA,sBAAA;AVk6DJ;AoB/2DI;EAEE,SAAA;ApBg3DN;;AoB32DI;;;;EAEE,cAAA;ApBg3DN;;AoB95DI;EAoDE,qBFkLmC;EE/KjC,+CAAA;EACA,yDAAA;EACA,4BAAA;EACA,2DAAA;EACA,gEAAA;ApB42DR;AoBz2DM;EACE,qBFuKiC;EEtKjC,gDAAA;ApB22DR;;AoB36DI;EAyEI,8BAAA;EACA,wCAAA;ApBs2DR;;AoBh7DI;EAmFI,oCjB6XgC;EiB5XhC,kFAAA;ApBi2DR;;AoBr7DI;EA2FE,qBF2ImC;EExIjC,kDAAA;EACA,wNAAA;ApB41DR;AoBz1DM;EACE,qBFmIiC;EElIjC,gDAAA;ApB21DR;;AoBp1DM;EACE,cF0HiC;AlB6tDzC;AoBp1DM;;;EAEE,cAAA;ApBu1DR;;AoBh1DM;EACE,cF6GiC;AlBsuDzC;AoBj1DQ;EACE,qBF0G+B;AlByuDzC;AoB90DQ;EACE,qBAAA;EC5JN,yBD6J2B;ApBg1D/B;AoB30DQ;EACE,gDAAA;ApB60DV;AoB10DQ;EACE,qBFyF+B;AlBmvDzC;;AoBn0DM;EACE,qBF+EiC;AlBuvDzC;AoBl0DQ;EACE,qBF0E+B;EEzE/B,gDAAA;ApBo0DV;;AoBr9DE;EACE,aAAA;EACA,WAAA;EACA,mBjB2coC;ECtVpC,kBAAA;EgBnHA,cFqNqC;AlBmwDzC;;AoBr9DE;EACE,kBAAA;EACA,SAAA;EACA,OAAA;EACA,UAAA;EACA,aAAA;EACA,eAAA;EACA,uBAAA;EACA,kBAAA;EhBwHE,mBAAA;EgBtHF,gBjBuO0B;EiBtO1B,WAAA;EACA,wCAAA;EV9CA,sBAAA;AVugEJ;AoBp9DI;EAEE,SAAA;ApBq9DN;;AoBh9DI;;;;EAEE,cAAA;ApBq9DN;;AoBngEI;EAoDE,qBFkLmC;EE/KjC,+CAAA;EACA,yDAAA;EACA,4BAAA;EACA,2DAAA;EACA,gEAAA;ApBi9DR;AoB98DM;EACE,qBFuKiC;EEtKjC,gDAAA;ApBg9DR;;AoBhhEI;EAyEI,8BAAA;EACA,wCAAA;ApB28DR;;AoBrhEI;EAmFI,oCjB6XgC;EiB5XhC,kFAAA;ApBs8DR;;AoB1hEI;EA2FE,qBF2ImC;EExIjC,kDAAA;EACA,wNAAA;ApBi8DR;AoB97DM;EACE,qBFmIiC;EElIjC,gDAAA;ApBg8DR;;AoBz7DM;EACE,cF0HiC;AlBk0DzC;AoBz7DM;;;EAEE,cAAA;ApB47DR;;AoBr7DM;EACE,cF6GiC;AlB20DzC;AoBt7DQ;EACE,qBF0G+B;AlB80DzC;AoBn7DQ;EACE,qBAAA;EC5JN,yBD6J2B;ApBq7D/B;AoBh7DQ;EACE,gDAAA;ApBk7DV;AoB/6DQ;EACE,qBFyF+B;AlBw1DzC;;AoBx6DM;EACE,qBF+EiC;AlB41DzC;AoBv6DQ;EACE,qBF0E+B;EEzE/B,gDAAA;ApBy6DV;;AkBp1DA;EACE,aAAA;EACA,mBAAA;EACA,mBAAA;AlBu1DF;AkBl1DE;EACE,WAAA;AlBo1DJ;AcnjEI;EIoOA;IACE,aAAA;IACA,mBAAA;IACA,uBAAA;IACA,gBAAA;ElBk1DJ;EkB90DE;IACE,aAAA;IACA,cAAA;IACA,mBAAA;IACA,mBAAA;IACA,gBAAA;ElBg1DJ;EkB50DE;IACE,qBAAA;IACA,WAAA;IACA,sBAAA;ElB80DJ;EkB10DE;IACE,qBAAA;ElB40DJ;EkBz0DE;;IAEE,WAAA;ElB20DJ;EkBt0DE;IACE,aAAA;IACA,mBAAA;IACA,uBAAA;IACA,WAAA;IACA,eAAA;ElBw0DJ;EkBt0DE;IACE,kBAAA;IACA,cAAA;IACA,aAAA;IACA,qBfgLkC;Ie/KlC,cAAA;ElBw0DJ;EkBr0DE;IACE,mBAAA;IACA,uBAAA;ElBu0DJ;EkBr0DE;IACE,gBAAA;ElBu0DJ;AACF;;AsBzpEA;EACE,qBAAA;EAEA,gBnBuR4B;EmBtR5B,cnBMS;EmBLT,kBAAA;EAGA,sBAAA;EACA,iBAAA;EACA,6BAAA;EACA,6BAAA;ECuFA,yBAAA;EnB4EI,eAAA;EmB1EJ,gBpB2L4B;EOnR1B,sBAAA;ESFE,qIGGJ;AtB4pEF;AmB3pEM;EGdN;IHeQ,gBAAA;EnB8pEN;AACF;AKxqEE;EiBUE,cnBNO;EmBOP,qBAAA;AtBiqEJ;AsB9pEE;EAEE,UAAA;EACA,gDnB8W0B;AHizD9B;AsB3pEE;EAEE,anBkZ0B;AH0wD9B;AsBxpEE;EACE,eAAA;AtB0pEJ;AsB5oEA;;EAEE,oBAAA;AtB8oEF;;AsBroEE;EC3DA,WAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AHgoEf;AKhsEE;EkBAE,WAAA;EFNA,yBED2D;EAS3D,qBATqG;AvB4sEzG;AuBhsEE;EAEE,WAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,gDAAA;AvB6rEN;AuBxrEE;EAEE,WAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AHgpEf;AuBlrEE;EAGE,WAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvB4tE7L;AuB7qEI;EAKI,gDAAA;AvB2qER;;AsBnqEE;EC3DA,WAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AH8pEf;AK9tEE;EkBAE,WAAA;EFNA,yBED2D;EAS3D,qBATqG;AvB0uEzG;AuB9tEE;EAEE,WAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,iDAAA;AvB2tEN;AuBttEE;EAEE,WAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AH8qEf;AuBhtEE;EAGE,WAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvB0vE7L;AuB3sEI;EAKI,iDAAA;AvBysER;;AsBjsEE;EC3DA,WAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AH4rEf;AK5vEE;EkBAE,WAAA;EFNA,yBED2D;EAS3D,qBATqG;AvBwwEzG;AuB5vEE;EAEE,WAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,+CAAA;AvByvEN;AuBpvEE;EAEE,WAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AH4sEf;AuB9uEE;EAGE,WAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvBwxE7L;AuBzuEI;EAKI,+CAAA;AvBuuER;;AsB/tEE;EC3DA,WAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AH0tEf;AK1xEE;EkBAE,WAAA;EFNA,yBED2D;EAS3D,qBATqG;AvBsyEzG;AuB1xEE;EAEE,WAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,gDAAA;AvBuxEN;AuBlxEE;EAEE,WAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AH0uEf;AuB5wEE;EAGE,WAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvBszE7L;AuBvwEI;EAKI,gDAAA;AvBqwER;;AsB7vEE;EC3DA,cAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AHwvEf;AKxzEE;EkBAE,cAAA;EFNA,yBED2D;EAS3D,qBATqG;AvBo0EzG;AuBxzEE;EAEE,cAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,gDAAA;AvBqzEN;AuBhzEE;EAEE,cAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AHwwEf;AuB1yEE;EAGE,cAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvBo1E7L;AuBryEI;EAKI,gDAAA;AvBmyER;;AsB3xEE;EC3DA,WAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AHsxEf;AKt1EE;EkBAE,WAAA;EFNA,yBED2D;EAS3D,qBATqG;AvBk2EzG;AuBt1EE;EAEE,WAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,+CAAA;AvBm1EN;AuB90EE;EAEE,WAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AHsyEf;AuBx0EE;EAGE,WAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvBk3E7L;AuBn0EI;EAKI,+CAAA;AvBi0ER;;AsBzzEE;EC3DA,cAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AHozEf;AKp3EE;EkBAE,cAAA;EFNA,yBED2D;EAS3D,qBATqG;AvBg4EzG;AuBp3EE;EAEE,cAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,iDAAA;AvBi3EN;AuB52EE;EAEE,cAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AHo0Ef;AuBt2EE;EAGE,cAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvBg5E7L;AuBj2EI;EAKI,iDAAA;AvB+1ER;;AsBv1EE;EC3DA,WAAA;EFAE,yBlBsEW;EoBpEb,qBpBoEa;AHk1Ef;AKl5EE;EkBAE,WAAA;EFNA,yBED2D;EAS3D,qBATqG;AvB85EzG;AuBl5EE;EAEE,WAAA;EFbA,yBED2D;EAgB3D,qBAhBqG;EAqBnG,8CAAA;AvB+4EN;AuB14EE;EAEE,WAAA;EACA,yBpB0CW;EoBzCX,qBpByCW;AHk2Ef;AuBp4EE;EAGE,WAAA;EACA,yBAzC+I;EA6C/I,qBA7CyL;AvB86E7L;AuB/3EI;EAKI,8CAAA;AvB63ER;;AsB/2EE;ECPA,cpBYa;EoBXb,qBpBWa;AH+2Ef;AK/6EE;EkBwDE,WALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AHo3Ef;AuBv3EE;EAEE,+CAAA;AvBw3EJ;AuBr3EE;EAEE,cpBJW;EoBKX,6BAAA;AvBs3EJ;AuBn3EE;EAGE,WAAA;EACA,yBpBZW;EoBaX,qBpBbW;AHg4Ef;AuBj3EI;EAKI,+CAAA;AvB+2ER;;AsBx4EE;ECPA,cpBYa;EoBXb,qBpBWa;AHw4Ef;AKx8EE;EkBwDE,WALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AH64Ef;AuBh5EE;EAEE,iDAAA;AvBi5EJ;AuB94EE;EAEE,cpBJW;EoBKX,6BAAA;AvB+4EJ;AuB54EE;EAGE,WAAA;EACA,yBpBZW;EoBaX,qBpBbW;AHy5Ef;AuB14EI;EAKI,iDAAA;AvBw4ER;;AsBj6EE;ECPA,cpBYa;EoBXb,qBpBWa;AHi6Ef;AKj+EE;EkBwDE,WALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AHs6Ef;AuBz6EE;EAEE,+CAAA;AvB06EJ;AuBv6EE;EAEE,cpBJW;EoBKX,6BAAA;AvBw6EJ;AuBr6EE;EAGE,WAAA;EACA,yBpBZW;EoBaX,qBpBbW;AHk7Ef;AuBn6EI;EAKI,+CAAA;AvBi6ER;;AsB17EE;ECPA,cpBYa;EoBXb,qBpBWa;AH07Ef;AK1/EE;EkBwDE,WALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AH+7Ef;AuBl8EE;EAEE,gDAAA;AvBm8EJ;AuBh8EE;EAEE,cpBJW;EoBKX,6BAAA;AvBi8EJ;AuB97EE;EAGE,WAAA;EACA,yBpBZW;EoBaX,qBpBbW;AH28Ef;AuB57EI;EAKI,gDAAA;AvB07ER;;AsBn9EE;ECPA,cpBYa;EoBXb,qBpBWa;AHm9Ef;AKnhFE;EkBwDE,cALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AHw9Ef;AuB39EE;EAEE,+CAAA;AvB49EJ;AuBz9EE;EAEE,cpBJW;EoBKX,6BAAA;AvB09EJ;AuBv9EE;EAGE,cAAA;EACA,yBpBZW;EoBaX,qBpBbW;AHo+Ef;AuBr9EI;EAKI,+CAAA;AvBm9ER;;AsB5+EE;ECPA,cpBYa;EoBXb,qBpBWa;AH4+Ef;AK5iFE;EkBwDE,WALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AHi/Ef;AuBp/EE;EAEE,+CAAA;AvBq/EJ;AuBl/EE;EAEE,cpBJW;EoBKX,6BAAA;AvBm/EJ;AuBh/EE;EAGE,WAAA;EACA,yBpBZW;EoBaX,qBpBbW;AH6/Ef;AuB9+EI;EAKI,+CAAA;AvB4+ER;;AsBrgFE;ECPA,cpBYa;EoBXb,qBpBWa;AHqgFf;AKrkFE;EkBwDE,cALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AH0gFf;AuB7gFE;EAEE,iDAAA;AvB8gFJ;AuB3gFE;EAEE,cpBJW;EoBKX,6BAAA;AvB4gFJ;AuBzgFE;EAGE,cAAA;EACA,yBpBZW;EoBaX,qBpBbW;AHshFf;AuBvgFI;EAKI,iDAAA;AvBqgFR;;AsB9hFE;ECPA,cpBYa;EoBXb,qBpBWa;AH8hFf;AK9lFE;EkBwDE,WALgD;EAMhD,yBpBOW;EoBNX,qBpBMW;AHmiFf;AuBtiFE;EAEE,8CAAA;AvBuiFJ;AuBpiFE;EAEE,cpBJW;EoBKX,6BAAA;AvBqiFJ;AuBliFE;EAGE,WAAA;EACA,yBpBZW;EoBaX,qBpBbW;AH+iFf;AuBhiFI;EAKI,8CAAA;AvB8hFR;;AsB5iFA;EACE,gBnB6M4B;EmB5M5B,cnB2FwC;EmB1FxC,qBnB2FwC;AHo9E1C;AKxnFE;EiB4EE,cnByFsC;EmBxFtC,0BnByFsC;AHs9E1C;AsB5iFE;EAEE,0BnBoFsC;AHy9E1C;AsB1iFE;EAEE,cnBtFO;EmBuFP,oBAAA;AtB2iFJ;;AsBhiFA;ECPE,oBAAA;EnB4EI,kBAAA;EmB1EJ,gBpB+H4B;EOvN1B,qBAAA;AVooFJ;;AsBniFA;ECXE,uBAAA;EnB4EI,mBAAA;EmB1EJ,gBpBgI4B;EOxN1B,qBAAA;AV2oFJ;;AsBjiFA;EACE,cAAA;EACA,WAAA;AtBoiFF;AsBjiFE;EACE,kBnBwT0B;AH2uE9B;;AsB3hFE;;;EACE,WAAA;AtBgiFJ;;AwB3qFA;ELgBM,gCKfJ;AxB8qFF;AmB3pFM;EKpBN;ILqBQ,gBAAA;EnB8pFN;AACF;AwBjrFE;EACE,UAAA;AxBmrFJ;;AwB9qFE;EACE,aAAA;AxBirFJ;;AwB7qFA;EACE,kBAAA;EACA,SAAA;EACA,gBAAA;ELDI,6BKEJ;AxBgrFF;AmB9qFM;EKNN;ILOQ,gBAAA;EnBirFN;AACF;AwBnrFE;EACE,QAAA;EACA,YAAA;ELNE,4BKOF;AxBqrFJ;AmBxrFM;EKAJ;ILCM,gBAAA;EnB2rFN;AACF;;AyBhtFA;;;;EAIE,kBAAA;AzBmtFF;;AyBhtFA;EACE,mBAAA;AzBmtFF;A0B/rFI;EACE,qBAAA;EACA,oBvB+NwB;EuB9NxB,uBvB6NwB;EuB5NxB,WAAA;EAhCJ,uBAAA;EACA,qCAAA;EACA,gBAAA;EACA,oCAAA;A1BkuFF;A0B7qFI;EACE,cAAA;A1B+qFN;;AyBztFA;EACE,kBAAA;EACA,SAAA;EACA,OAAA;EACA,atBypBkC;EsBxpBlC,aAAA;EACA,WAAA;EACA,gBtBiuBkC;EsBhuBlC,iBAAA;EACA,oBAAA;ErB2JI,eAAA;EqBzJJ,ctBXS;EsBYT,gBAAA;EACA,gBAAA;EACA,sBtBvBS;EsBwBT,4BAAA;EACA,qCAAA;EfdE,sBAAA;AV2uFJ;;AyBptFI;EACE,WAAA;EACA,OAAA;AzButFN;;AyBptFI;EACE,QAAA;EACA,UAAA;AzButFN;;Ac3sFI;EWnBA;IACE,WAAA;IACA,OAAA;EzBkuFJ;EyB/tFE;IACE,QAAA;IACA,UAAA;EzBiuFJ;AACF;ActtFI;EWnBA;IACE,WAAA;IACA,OAAA;EzB4uFJ;EyBzuFE;IACE,QAAA;IACA,UAAA;EzB2uFJ;AACF;AchuFI;EWnBA;IACE,WAAA;IACA,OAAA;EzBsvFJ;EyBnvFE;IACE,QAAA;IACA,UAAA;EzBqvFJ;AACF;Ac1uFI;EWnBA;IACE,WAAA;IACA,OAAA;EzBgwFJ;EyB7vFE;IACE,QAAA;IACA,UAAA;EzB+vFJ;AACF;AyBxvFE;EACE,SAAA;EACA,YAAA;EACA,aAAA;EACA,uBtB+rBgC;AH2jEpC;A0BzxFI;EACE,qBAAA;EACA,oBvB+NwB;EuB9NxB,uBvB6NwB;EuB5NxB,WAAA;EAzBJ,aAAA;EACA,qCAAA;EACA,0BAAA;EACA,oCAAA;A1BqzFF;A0BvwFI;EACE,cAAA;A1BywFN;;AyB9vFE;EACE,MAAA;EACA,WAAA;EACA,UAAA;EACA,aAAA;EACA,qBtBirBgC;AHglEpC;A0B9yFI;EACE,qBAAA;EACA,oBvB+NwB;EuB9NxB,uBvB6NwB;EuB5NxB,WAAA;EAlBJ,mCAAA;EACA,eAAA;EACA,sCAAA;EACA,wBAAA;A1Bm0FF;A0B5xFI;EACE,cAAA;A1B8xFN;AyBzwFI;EACE,iBAAA;AzB2wFN;;AyBrwFE;EACE,MAAA;EACA,WAAA;EACA,UAAA;EACA,aAAA;EACA,sBtBgqBgC;AHwmEpC;A0Bt0FI;EACE,qBAAA;EACA,oBvB+NwB;EuB9NxB,uBvB6NwB;EuB5NxB,WAAA;A1Bw0FN;A0B7zFM;EACE,aAAA;A1B+zFR;A0B5zFM;EACE,qBAAA;EACA,qBvB4MsB;EuB3MtB,uBvB0MsB;EuBzMtB,WAAA;EA9BN,mCAAA;EACA,yBAAA;EACA,sCAAA;A1B61FF;A0B5zFI;EACE,cAAA;A1B8zFN;AyBxxFI;EACE,iBAAA;AzB0xFN;;AyBlxFE;EAIE,WAAA;EACA,YAAA;AzBkxFJ;;AyB7wFA;EE9GE,SAAA;EACA,gBAAA;EACA,gBAAA;EACA,6BAAA;A3B+3FF;;AyB7wFA;EACE,cAAA;EACA,WAAA;EACA,uBAAA;EACA,WAAA;EACA,gBtBiK4B;EsBhK5B,ctBhHS;EsBiHT,mBAAA;EAEA,mBAAA;EACA,6BAAA;EACA,SAAA;AzB+wFF;AKp4FE;EoBoIE,ctBonBgC;EsBnnBhC,qBAAA;EJ/IA,yBlBGO;AHg5FX;AyBhwFE;EAEE,WtBpJO;EsBqJP,qBAAA;EJtJA,yBlBoP0B;AHoqF9B;AyB9vFE;EAEE,ctBtJO;EsBuJP,oBAAA;EACA,6BAAA;AzB+vFJ;;AyBvvFA;EACE,cAAA;AzB0vFF;;AyBtvFA;EACE,cAAA;EACA,sBtBimBkC;EsBhmBlC,gBAAA;ErBAI,mBAAA;EqBEJ,ctBzKS;EsB0KT,mBAAA;AzByvFF;;AyBrvFA;EACE,cAAA;EACA,uBAAA;EACA,ctB9KS;AHs6FX;;A4Bn7FA;;EAEE,kBAAA;EACA,oBAAA;EACA,sBAAA;A5Bs7FF;A4Bp7FE;;EACE,kBAAA;EACA,cAAA;A5Bu7FJ;AKt7FE;;EuBII,UAAA;A5Bs7FN;A4Bp7FI;;;;EAGE,UAAA;A5Bu7FN;;A4Bj7FA;EACE,aAAA;EACA,eAAA;EACA,2BAAA;A5Bo7FF;A4Bl7FE;EACE,WAAA;A5Bo7FJ;;A4B96FE;;EAEE,iBAAA;A5Bi7FJ;A4B76FE;;ElBXE,0BAAA;EACA,6BAAA;AV47FJ;A4B76FE;;ElBFE,yBAAA;EACA,4BAAA;AVm7FJ;;A4Bh6FA;EACE,wBAAA;EACA,uBAAA;A5Bm6FF;A4Bj6FE;EAGE,cAAA;A5Bi6FJ;A4B95FE;EACE,eAAA;A5Bg6FJ;;A4B55FA;EACE,uBAAA;EACA,sBAAA;A5B+5FF;;A4B55FA;EACE,sBAAA;EACA,qBAAA;A5B+5FF;;A4B34FA;EACE,sBAAA;EACA,uBAAA;EACA,uBAAA;A5B84FF;A4B54FE;;EAEE,WAAA;A5B84FJ;A4B34FE;;EAEE,gBAAA;A5B64FJ;A4Bz4FE;;ElBrFE,6BAAA;EACA,4BAAA;AVk+FJ;A4Bz4FE;;ElBxGE,yBAAA;EACA,0BAAA;AVq/FJ;;A4B13FE;;EAEE,gBAAA;A5B63FJ;A4B33FI;;;;EAEE,kBAAA;EACA,sBAAA;EACA,oBAAA;A5B+3FN;;A6BxhGA;EACE,kBAAA;EACA,aAAA;EACA,eAAA;EACA,oBAAA;EACA,WAAA;A7B2hGF;A6BzhGE;;;;EAIE,kBAAA;EACA,cAAA;EACA,SAAA;EACA,YAAA;EACA,gBAAA;A7B2hGJ;A6BzhGI;;;;;;;;;;;;EAGE,iBAAA;A7BoiGN;A6B/hGE;;;EAGE,UAAA;A7BiiGJ;A6B7hGE;EACE,UAAA;A7B+hGJ;A6B1hGI;;EnBIA,yBAAA;EACA,4BAAA;AV0hGJ;A6B1hGE;EACE,aAAA;EACA,mBAAA;A7B4hGJ;A6B1hGI;EnBnBA,0BAAA;EACA,6BAAA;AVgjGJ;A6B5hGI;EnBPA,yBAAA;EACA,4BAAA;AVsiGJ;A6B5hGI;;;;EnBzBA,0BAAA;EACA,6BAAA;AV2jGJ;A6B1hGI;;;;EnBlCA,0BAAA;EACA,6BAAA;AVkkGJ;;A6BjhGA;;EAEE,aAAA;A7BohGF;A6B/gGE;;EACE,kBAAA;EACA,UAAA;A7BkhGJ;A6BhhGI;;EACE,UAAA;A7BmhGN;A6B/gGE;;;;;;;;EAIE,iBAAA;A7BqhGJ;;A6BjhGA;EAAuB,kBAAA;A7BqhGvB;;A6BphGA;EAAsB,iBAAA;A7BwhGtB;;A6BhhGA;EACE,aAAA;EACA,mBAAA;EACA,yBAAA;EACA,gBAAA;EzB2DI,eAAA;EyBzDJ,gB1BqK4B;E0BpK5B,gB1ByK4B;E0BxK5B,c1B/GS;E0BgHT,kBAAA;EACA,mBAAA;EACA,yB1BvHS;E0BwHT,yBAAA;EnB/GE,sBAAA;AVmoGJ;A6BhhGE;;EAEE,aAAA;A7BkhGJ;;A6BxgGA;;EAEE,gC1BmWsC;AHwqFxC;;A6BxgGA;;;;;;EAME,oBAAA;EzBwBI,kBAAA;EyBtBJ,gB1B2E4B;EOvN1B,qBAAA;AVwpGJ;;A6BxgGA;;EAEE,kC1BiVsC;AH0rFxC;;A6BxgGA;;;;;;EAME,uBAAA;EzBOI,mBAAA;EyBLJ,gB1B2D4B;EOxN1B,qBAAA;AVyqGJ;;A6BxgGA;;EAEE,sBAAA;A7B2gGF;;A6BhgGA;;;;;;;;EnB9JI,0BAAA;EACA,6BAAA;AVyqGJ;;A6BjgGA;;;;;;EnB3JI,yBAAA;EACA,4BAAA;AVqqGJ;;A8B7sGA;EACE,kBAAA;EACA,UAAA;EACA,cAAA;EACA,kBAAA;EACA,oBAAA;EACA,yBAAA;A9BgtGF;;A8B7sGA;EACE,oBAAA;EACA,kB3ByfsC;AHutFxC;;A8B7sGA;EACE,kBAAA;EACA,OAAA;EACA,WAAA;EACA,W3BqfsC;E2BpftC,eAAA;EACA,UAAA;A9BgtGF;A8B9sGE;EACE,W3BzBO;E2B0BP,qB3ByN0B;EkBpP1B,yBlBoP0B;AHw/F9B;A8B5sGE;EAKI,gD3BgWwB;AH02F9B;A8BtsGE;EACE,qB3BsboC;AHkxFxC;A8BrsGE;EACE,W3B7CO;E2B8CP,yB3Bkf4C;E2Bjf5C,qB3Bif4C;AHstFhD;A8BhsGI;EACE,c3BjDK;AHmvGX;A8BhsGM;EACE,yB3BxDG;AH0vGX;;A8BxrGA;EACE,kBAAA;EACA,gBAAA;EAEA,mBAAA;A9B0rGF;A8BtrGE;EACE,kBAAA;EACA,YAAA;EACA,aAAA;EACA,cAAA;EACA,W3BwboC;E2BvbpC,Y3BuboC;E2BtbpC,oBAAA;EACA,WAAA;EACA,sB3BrFO;E2BsFP,yBAAA;A9BwrGJ;A8BnrGE;EACE,kBAAA;EACA,YAAA;EACA,aAAA;EACA,cAAA;EACA,W3ByaoC;E2BxapC,Y3BwaoC;E2BvapC,WAAA;EACA,iCAAA;A9BqrGJ;;A8B3qGE;EpBlGE,sBAAA;AVixGJ;A8B1qGI;EACE,yDAAA;A9B4qGN;A8BvqGI;EACE,qB3B0HwB;EkBpP1B,yBlBoP0B;AHgjG9B;A8BtqGI;EACE,yDAAA;A9BwqGN;A8BnqGI;ETpIA,wClByhB4C;AHixFhD;A8BnqGI;ETvIA,wClByhB4C;AHoxFhD;;A8B3pGE;EAEE,kB3B0Z4C;AHmwFhD;A8BzpGI;EACE,yDAAA;A9B2pGN;A8BtpGI;ET9JA,wClByhB4C;AH8xFhD;;A8B9oGA;EACE,qBAAA;A9BipGF;A8B9oGI;EACE,cAAA;EACA,c3BkY0C;E2BjY1C,mBAAA;EAEA,qB3BgY0C;AH+wFhD;A8B5oGI;EACE,wBAAA;EACA,0BAAA;EACA,uB3B2X0C;E2B1X1C,wB3B0X0C;E2BzX1C,yB3BpLK;E2BsLL,qB3BsX0C;EgBxiB1C,yIWmLA;A9B6oGN;AmB5zGM;EWuKF;IXtKI,gBAAA;EnB+zGN;AACF;A8B7oGI;EACE,sB3BlMK;E2BmML,8BAAA;A9B+oGN;A8B1oGI;ETzMA,wClByhB4C;AH6zFhD;;A8BhoGA;EACE,qBAAA;EACA,WAAA;EACA,mC3BqRsC;E2BpRtC,0CAAA;E1B5CI,eAAA;E0B+CJ,gB3B6D4B;E2B5D5B,gB3BiE4B;E2BhE5B,c3BvNS;E2BwNT,sBAAA;EACA,gGAAA;EACA,yBAAA;EpBtNE,sBAAA;EoByNF,gBAAA;A9BioGF;A8B/nGE;EACE,qB3BwPoC;E2BvPpC,UAAA;EAKE,gD3BmW8B;AH0xFpC;A8B1nGI;EAME,c3B/OK;E2BgPL,sB3BvPK;AH82GX;A8BnnGE;EAEE,YAAA;EACA,sB3B+H0B;E2B9H1B,sBAAA;A9BonGJ;A8BjnGE;EACE,c3B7PO;E2B8PP,yB3BlQO;AHq3GX;A8B/mGE;EACE,aAAA;A9BinGJ;A8B7mGE;EACE,kBAAA;EACA,0BAAA;A9B+mGJ;;A8B3mGA;EACE,kC3B0NsC;E2BzNtC,oB3BiH4B;E2BhH5B,uB3BgH4B;E2B/G5B,oB3BgH4B;EC1NxB,mBAAA;AJytGN;;A8B3mGA;EACE,gC3BmNsC;E2BlNtC,mB3B8G4B;E2B7G5B,sB3B6G4B;E2B5G5B,kB3B6G4B;EC/NxB,kBAAA;AJiuGN;;A8BtmGA;EACE,kBAAA;EACA,qBAAA;EACA,WAAA;EACA,mC3BiMsC;E2BhMtC,gBAAA;A9BymGF;;A8BtmGA;EACE,kBAAA;EACA,UAAA;EACA,WAAA;EACA,mC3ByLsC;E2BxLtC,SAAA;EACA,gBAAA;EACA,UAAA;A9BymGF;A8BvmGE;EACE,qB3BqKoC;E2BpKpC,gD3ByE0B;AHgiG9B;A8BrmGE;EAEE,yB3B/TO;AHq6GX;A8BlmGI;EACE,iB3B2Ta;AHyyFnB;A8BhmGE;EACE,0BAAA;A9BkmGJ;;A8B9lGA;EACE,kBAAA;EACA,MAAA;EACA,QAAA;EACA,OAAA;EACA,UAAA;EACA,mC3BwJsC;E2BvJtC,yBAAA;EACA,gBAAA;EAEA,gB3BhE4B;E2BiE5B,gB3B5D4B;E2B6D5B,c3BpVS;E2BqVT,sB3B5VS;E2B6VT,yBAAA;EpBlVE,sBAAA;AVm7GJ;A8B7lGE;EACE,kBAAA;EACA,MAAA;EACA,QAAA;EACA,SAAA;EACA,UAAA;EACA,cAAA;EACA,6B3BiIoC;E2BhIpC,yBAAA;EACA,gB3B5E0B;E2B6E1B,c3BpWO;E2BqWP,iBAAA;ET7WA,yBlBGO;E2B4WP,oBAAA;EpBnWA,kCAAA;AVm8GJ;;A8BrlGA;EACE,WAAA;EACA,cAAA;EACA,UAAA;EACA,6BAAA;EACA,gBAAA;A9BwlGF;A8BtlGE;EACE,UAAA;A9BwlGJ;A8BplGI;EAA0B,gE3BoOe;AHm3F7C;A8BtlGI;EAA0B,gE3BmOe;AHs3F7C;A8BxlGI;EAA0B,gE3BkOe;AHy3F7C;A8BxlGE;EACE,SAAA;A9B0lGJ;A8BvlGE;EACE,W3BoNyC;E2BnNzC,Y3BmNyC;E2BlNzC,oBAAA;ETlZA,yBlBoP0B;E2BgK1B,S3BmNyC;EO3lBzC,mBAAA;ESFE,4GW6YF;EACA,gBAAA;A9BwlGJ;AmBl+GM;EWiYJ;IXhYM,gBAAA;EnBq+GN;AACF;A8B3lGI;ET1ZA,yBlB4mByC;AH44F7C;A8BzlGE;EACE,W3B6LgC;E2B5LhC,c3B6LgC;E2B5LhC,kBAAA;EACA,e3B4LgC;E2B3LhC,yB3BhaO;E2BiaP,yBAAA;EpBzZA,mBAAA;AVq/GJ;A8BvlGE;EACE,W3ByLyC;E2BxLzC,Y3BwLyC;EkBpmBzC,yBlBoP0B;E2B0L1B,S3ByLyC;EO3lBzC,mBAAA;ESFE,4GWuaF;EACA,gBAAA;A9BwlGJ;AmB5/GM;EW4ZJ;IX3ZM,gBAAA;EnB+/GN;AACF;A8B3lGI;ETpbA,yBlB4mByC;AHs6F7C;A8BzlGE;EACE,W3BmKgC;E2BlKhC,c3BmKgC;E2BlKhC,kBAAA;EACA,e3BkKgC;E2BjKhC,yB3B1bO;E2B2bP,yBAAA;EpBnbA,mBAAA;AV+gHJ;A8BvlGE;EACE,W3B+JyC;E2B9JzC,Y3B8JyC;E2B7JzC,aAAA;EACA,oB3BrE0B;E2BsE1B,mB3BtE0B;EkBnY1B,yBlBoP0B;E2BuN1B,S3B4JyC;EO3lBzC,mBAAA;ESFE,4GWocF;EACA,gBAAA;A9BwlGJ;AmBzhHM;EWsbJ;IXrbM,gBAAA;EnB4hHN;AACF;A8B3lGI;ETjdA,yBlB4mByC;AHm8F7C;A8BzlGE;EACE,W3BsIgC;E2BrIhC,c3BsIgC;E2BrIhC,kBAAA;EACA,e3BqIgC;E2BpIhC,6BAAA;EACA,yBAAA;EACA,oBAAA;A9B2lGJ;A8BvlGE;EACE,yB3B9dO;EOQP,mBAAA;AVgjHJ;A8BtlGE;EACE,kBAAA;EACA,yB3BpeO;EOQP,mBAAA;AVqjHJ;A8BplGI;EACE,yB3BxeK;AH8jHX;A8BnlGI;EACE,eAAA;A9BqlGN;A8BllGI;EACE,yB3BhfK;AHokHX;A8BjlGI;EACE,eAAA;A9BmlGN;A8BhlGI;EACE,yB3BxfK;AH0kHX;;A8B7kGA;;;EXzfM,4GW4fJ;A9BglGF;AmBxkHM;EWqfN;;;IXpfQ,gBAAA;EnB6kHN;AACF;;A+B9lHA;EACE,aAAA;EACA,eAAA;EACA,eAAA;EACA,gBAAA;EACA,gBAAA;A/BimHF;;A+B9lHA;EACE,cAAA;EACA,oBAAA;A/BimHF;AKhmHE;E0BGE,qBAAA;A/BgmHJ;A+B5lHE;EACE,c5BXO;E4BYP,oBAAA;EACA,eAAA;A/B8lHJ;;A+BtlHA;EACE,gCAAA;A/BylHF;A+BvlHE;EACE,mBAAA;EACA,6BAAA;EACA,6BAAA;ErBbA,+BAAA;EACA,gCAAA;AVumHJ;AKnnHE;E0B6BI,kBAAA;EACA,qC5BipB8B;AHw8FpC;A+BtlHI;EACE,c5BrCK;E4BsCL,6BAAA;EACA,yBAAA;A/BwlHN;A+BplHE;;EAEE,c5B5CO;E4B6CP,sB5BpDO;E4BqDP,kC5BsoBgC;AHg9FpC;A+BnlHE;EAEE,gBAAA;ErBtCA,yBAAA;EACA,0BAAA;AV2nHJ;;A+B1kHE;EACE,gBAAA;EACA,SAAA;ErB7DA,sBAAA;AV2oHJ;A+B1kHE;;EAEE,W5B9EO;E4B+EP,yB5BoK0B;AHw6G9B;;A+BlkHE;;EAEE,cAAA;EACA,kBAAA;A/BqkHJ;;A+BhkHE;;EAEE,aAAA;EACA,YAAA;EACA,kBAAA;A/BmkHJ;;A+BzjHE;EACE,aAAA;A/B4jHJ;A+B1jHE;EACE,cAAA;A/B4jHJ;;AgCrqHA;EACE,kBAAA;EACA,aAAA;EACA,eAAA;EACA,mBAAA;EACA,8BAAA;EACA,oBAAA;AhCwqHF;AgCpqHE;;;;;;EACE,aAAA;EACA,eAAA;EACA,mBAAA;EACA,8BAAA;AhC2qHJ;AgCvpHA;EACE,qBAAA;EACA,sB7BkqBkC;E6BjqBlC,yB7BiqBkC;E6BhqBlC,kB7BgFO;EC6CH,kBAAA;E4B3HJ,oBAAA;EACA,mBAAA;AhCypHF;AKnsHE;E2B6CE,qBAAA;AhCypHJ;;AgChpHA;EACE,aAAA;EACA,sBAAA;EACA,eAAA;EACA,gBAAA;EACA,gBAAA;AhCmpHF;AgCjpHE;EACE,gBAAA;EACA,eAAA;AhCmpHJ;AgChpHE;EACE,gBAAA;EACA,WAAA;AhCkpHJ;;AgCzoHA;EACE,qBAAA;EACA,mB7BylBkC;E6BxlBlC,sB7BwlBkC;AHojGpC;;AgChoHA;EACE,gBAAA;EACA,YAAA;EAGA,mBAAA;AhCioHF;;AgC7nHA;EACE,wBAAA;E5B8DI,kBAAA;E4B5DJ,cAAA;EACA,6BAAA;EACA,6BAAA;EtBxGE,sBAAA;AVyuHJ;AK3uHE;E2B8GE,qBAAA;AhCgoHJ;;AgC1nHA;EACE,qBAAA;EACA,YAAA;EACA,aAAA;EACA,sBAAA;EACA,WAAA;EACA,mCAAA;AhC6nHF;;AgC1nHA;EACE,gB7BglBkC;E6B/kBlC,gBAAA;AhC6nHF;;AcnsHI;EkBkFI;;;;;;IACE,gBAAA;IACA,eAAA;EhC0nHR;AACF;Ac5tHI;EkB6FA;IAoBI,qBAAA;IACA,2BAAA;EhC+mHN;EgC7mHM;IACE,mBAAA;EhC+mHR;EgC7mHQ;IACE,kBAAA;EhC+mHV;EgC5mHQ;IACE,qB7ByhBwB;I6BxhBxB,oB7BwhBwB;EHslGlC;EgCzmHM;;;;;;IACE,iBAAA;EhCgnHR;EgClmHM;IACE,iBAAA;EhComHR;EgCjmHM;IACE,wBAAA;IAGA,gBAAA;EhCimHR;EgC9lHM;IACE,aAAA;EhCgmHR;AACF;AcjvHI;EkBkFI;;;;;;IACE,gBAAA;IACA,eAAA;EhCuqHR;AACF;AczwHI;EkB6FA;IAoBI,qBAAA;IACA,2BAAA;EhC4pHN;EgC1pHM;IACE,mBAAA;EhC4pHR;EgC1pHQ;IACE,kBAAA;EhC4pHV;EgCzpHQ;IACE,qB7ByhBwB;I6BxhBxB,oB7BwhBwB;EHmoGlC;EgCtpHM;;;;;;IACE,iBAAA;EhC6pHR;EgC/oHM;IACE,iBAAA;EhCipHR;EgC9oHM;IACE,wBAAA;IAGA,gBAAA;EhC8oHR;EgC3oHM;IACE,aAAA;EhC6oHR;AACF;Ac9xHI;EkBkFI;;;;;;IACE,gBAAA;IACA,eAAA;EhCotHR;AACF;ActzHI;EkB6FA;IAoBI,qBAAA;IACA,2BAAA;EhCysHN;EgCvsHM;IACE,mBAAA;EhCysHR;EgCvsHQ;IACE,kBAAA;EhCysHV;EgCtsHQ;IACE,qB7ByhBwB;I6BxhBxB,oB7BwhBwB;EHgrGlC;EgCnsHM;;;;;;IACE,iBAAA;EhC0sHR;EgC5rHM;IACE,iBAAA;EhC8rHR;EgC3rHM;IACE,wBAAA;IAGA,gBAAA;EhC2rHR;EgCxrHM;IACE,aAAA;EhC0rHR;AACF;Ac30HI;EkBkFI;;;;;;IACE,gBAAA;IACA,eAAA;EhCiwHR;AACF;Acn2HI;EkB6FA;IAoBI,qBAAA;IACA,2BAAA;EhCsvHN;EgCpvHM;IACE,mBAAA;EhCsvHR;EgCpvHQ;IACE,kBAAA;EhCsvHV;EgCnvHQ;IACE,qB7ByhBwB;I6BxhBxB,oB7BwhBwB;EH6tGlC;EgChvHM;;;;;;IACE,iBAAA;EhCuvHR;EgCzuHM;IACE,iBAAA;EhC2uHR;EgCxuHM;IACE,wBAAA;IAGA,gBAAA;EhCwuHR;EgCruHM;IACE,aAAA;EhCuuHR;AACF;AgCxyHI;EAoBI,qBAAA;EACA,2BAAA;AhCuxHR;AgC1yHQ;;;;;;EACE,gBAAA;EACA,eAAA;AhCizHV;AgC9xHQ;EACE,mBAAA;AhCgyHV;AgC9xHU;EACE,kBAAA;AhCgyHZ;AgC7xHU;EACE,qB7ByhBwB;E6BxhBxB,oB7BwhBwB;AHuwGpC;AgC1xHQ;;;;;;EACE,iBAAA;AhCiyHV;AgCnxHQ;EACE,iBAAA;AhCqxHV;AgClxHQ;EACE,wBAAA;EAGA,gBAAA;AhCkxHV;AgC/wHQ;EACE,aAAA;AhCixHV;;AgCnwHE;EACE,yB7BigBgC;AHqwGpC;AK99HE;E2B2NI,yB7B8f8B;AHwwGpC;AgCjwHI;EACE,yB7Bsf8B;AH6wGpC;AKp+HE;E2BoOM,yB7Bof4B;AH+wGpC;AgChwHM;EACE,yB7Bkf4B;AHgxGpC;AgC9vHI;;;;EAIE,yB7Bye8B;AHuxGpC;AgC5vHE;EACE,yB7BkegC;E6BjehC,gC7BsegC;AHwxGpC;AgC3vHE;EACE,yDAAA;AhC6vHJ;AgC1vHE;EACE,yB7BydgC;AHmyGpC;AgC3vHI;EACE,yB7Byd8B;AHoyGpC;AK7/HE;E2BmQM,yB7Bsd4B;AHuyGpC;;AgCrvHE;EACE,W7BrRO;AH6gIX;AKpgIE;E2B+QI,W7BxRK;AHghIX;AgCnvHI;EACE,+B7B2b8B;AH0zGpC;AK1gIE;E2BwRM,gC7Byb4B;AH4zGpC;AgClvHM;EACE,gC7Bub4B;AH6zGpC;AgChvHI;;;;EAIE,W7B7SK;AH+hIX;AgC9uHE;EACE,+B7BuagC;E6BtahC,sC7B2agC;AHq0GpC;AgC7uHE;EACE,yDAAA;AhC+uHJ;AgC5uHE;EACE,+B7B8ZgC;AHg1GpC;AgC7uHI;EACE,W7B7TK;AH4iIX;AKniIE;E2BuTM,W7BhUG;AH+iIX;;AiCljIA;EACE,kBAAA;EACA,aAAA;EACA,sBAAA;EACA,YAAA;EAEA,qBAAA;EACA,sB9BJS;E8BKT,2BAAA;EACA,sCAAA;EvBKE,sBAAA;AVgjIJ;AiCljIE;EACE,eAAA;EACA,cAAA;AjCojIJ;AiCjjIE;EACE,mBAAA;EACA,sBAAA;AjCmjIJ;AiCjjII;EACE,mBAAA;EvBCF,2CAAA;EACA,4CAAA;AVmjIJ;AiCjjII;EACE,sBAAA;EvBUF,+CAAA;EACA,8CAAA;AV0iIJ;AiC9iIE;;EAEE,aAAA;AjCgjIJ;;AiC5iIA;EAGE,cAAA;EAGA,eAAA;EACA,gB9BgxBkC;AH2xGpC;;AiCviIA;EACE,sB9B0wBkC;AHgyGpC;;AiCviIA;EACE,qBAAA;EACA,gBAAA;AjC0iIF;;AiCviIA;EACE,gBAAA;AjC0iIF;;AK/lIE;E4B0DE,qBAAA;AjCyiIJ;AiCtiIE;EACE,oB9ByvBgC;AH+yGpC;;AiChiIA;EACE,wBAAA;EACA,gBAAA;EAEA,qC9BkvBkC;E8BjvBlC,6CAAA;AjCkiIF;AiChiIE;EvBvEE,0DAAA;AV0mIJ;;AiC9hIA;EACE,wBAAA;EAEA,qC9BuuBkC;E8BtuBlC,0CAAA;AjCgiIF;AiC9hIE;EvBlFE,0DAAA;AVmnIJ;;AiCvhIA;EACE,uBAAA;EACA,uBAAA;EACA,sBAAA;EACA,gBAAA;AjC0hIF;;AiCvhIA;EACE,uBAAA;EACA,sBAAA;AjC0hIF;;AiCthIA;EACE,kBAAA;EACA,MAAA;EACA,QAAA;EACA,SAAA;EACA,OAAA;EACA,gB9B6sBkC;EO5zBhC,kCAAA;AVyoIJ;;AiCthIA;;;EAGE,cAAA;EACA,WAAA;AjCyhIF;;AiCthIA;;EvBjHI,2CAAA;EACA,4CAAA;AV4oIJ;;AiCvhIA;;EvBxGI,+CAAA;EACA,8CAAA;AVooIJ;;AiCphIE;EACE,mB9BqrBgC;AHk2GpC;ActnII;EmB6FJ;IAMI,aAAA;IACA,mBAAA;IACA,mBAAA;IACA,kBAAA;EjCuhIF;EiCrhIE;IAEE,YAAA;IACA,kB9ByqB8B;I8BxqB9B,gBAAA;IACA,iB9BuqB8B;EH+2GlC;AACF;;AiC1gIE;EACE,mB9BypBgC;AHo3GpC;AcxoII;EmBuHJ;IAQI,aAAA;IACA,mBAAA;EjC6gIF;EiC1gIE;IAEE,YAAA;IACA,gBAAA;EjC2gIJ;EiCzgII;IACE,cAAA;IACA,cAAA;EjC2gIN;EiCtgIM;IvBzKJ,0BAAA;IACA,6BAAA;EVkrIF;EiCvgIQ;;IAGE,0BAAA;EjCwgIV;EiCtgIQ;;IAGE,6BAAA;EjCugIV;EiCngIM;IvB1KJ,yBAAA;IACA,4BAAA;EVgrIF;EiCpgIQ;;IAGE,yBAAA;EjCqgIV;EiCngIQ;;IAGE,4BAAA;EjCogIV;AACF;;AiCv/HE;EACE,sB9B8kBgC;AH46GpC;AclrII;EmBsLJ;IAMI,e9B2lBgC;I8B1lBhC,mB9B2lBgC;I8B1lBhC,UAAA;IACA,SAAA;EjC0/HF;EiCx/HE;IACE,qBAAA;IACA,WAAA;EjC0/HJ;AACF;;AiCj/HA;EACE,qBAAA;AjCo/HF;AiCl/HE;EACE,gBAAA;AjCo/HJ;AiCl/HI;EACE,gBAAA;EvBvOF,6BAAA;EACA,4BAAA;AV4tIJ;AiCl/HI;EvBzPA,yBAAA;EACA,0BAAA;AV8uIJ;AiCl/HI;EvBtQA,gBAAA;EuBwQE,mBAAA;AjCo/HN;;AkC9wIA;EACE,aAAA;EACA,eAAA;EACA,qBAAA;EACA,mB/BqiCkC;E+BniClC,gBAAA;EACA,yB/BES;EOSP,sBAAA;AVswIJ;;AkC3wIE;EACE,oB/ByhCgC;AHqvGpC;AkC5wII;EACE,WAAA;EACA,qB/BqhC8B;E+BphC9B,c/BNK;E+BOL,YAAA;AlC8wIN;AkCpwIE;EACE,0BAAA;AlCswIJ;AkCnwIE;EACE,qBAAA;AlCqwIJ;AkClwIE;EACE,c/B1BO;AH8xIX;;AmC3yIA;EACE,aAAA;E5BGA,eAAA;EACA,gBAAA;EGaE,sBAAA;AVgyIJ;;AmC5yIA;EACE,kBAAA;EACA,cAAA;EACA,uBAAA;EACA,iBAAA;EACA,iBhCoxBkC;EgCnxBlC,chCmKwC;EgCjKxC,sBhCPS;EgCQT,yBAAA;AnC8yIF;AmC5yIE;EACE,UAAA;EACA,chC8JsC;EgC7JtC,qBAAA;EACA,yBhCZO;EgCaP,qBhCZO;AH0zIX;AmC3yIE;EACE,UAAA;EACA,UhC4wBgC;EgC3wBhC,gDhC+W0B;AH87H9B;;AmCvyII;EACE,cAAA;EzBaF,+BAAA;EACA,kCAAA;AV8xIJ;AmCvyII;EzBNA,gCAAA;EACA,mCAAA;AVgzIJ;AmCtyIE;EACE,UAAA;EACA,WhCxCO;EgCyCP,yBhC0M0B;EgCzM1B,qBhCyM0B;AH+lI9B;AmCryIE;EACE,chCxCO;EgCyCP,oBAAA;EAEA,YAAA;EACA,sBhClDO;EgCmDP,qBhChDO;AHs1IX;;AoC71IE;EACE,uBAAA;EhCgLE,kBAAA;EgC9KF,gBjCmO0B;AH6nI9B;AoC31IM;E1BqCF,8BAAA;EACA,iCAAA;AVyzIJ;AoC11IM;E1BkBF,+BAAA;EACA,kCAAA;AV20IJ;;AoC32IE;EACE,uBAAA;EhCgLE,mBAAA;EgC9KF,gBjCoO0B;AH0oI9B;AoCz2IM;E1BqCF,8BAAA;EACA,iCAAA;AVu0IJ;AoCx2IM;E1BkBF,+BAAA;EACA,kCAAA;AVy1IJ;;AqCv3IA;EACE,qBAAA;EACA,qBAAA;EjC6JE,cAAA;EiC3JF,gBlCwR4B;EkCvR5B,cAAA;EACA,kBAAA;EACA,mBAAA;EACA,wBAAA;E3BKE,sBAAA;ESFE,qIkBDJ;ArC03IF;AmBr3IM;EkBfN;IlBgBQ,gBAAA;EnBw3IN;AACF;AK93IE;EgCGI,qBAAA;ArC83IN;;AqCz3IE;EACE,aAAA;ArC43IJ;;AqCv3IA;EACE,kBAAA;EACA,SAAA;ArC03IF;;AqCn3IA;EACE,oBlCi4BkC;EkCh4BlC,mBlCg4BkC;EOv5BhC,oBAAA;AV84IJ;;AqC92IE;ECjDA,WAAA;EACA,yBnC0Ea;AHy1If;AKr5IE;EiCVI,WAAA;EACA,yBAAA;AtCk6IN;AsC/5II;EAEE,UAAA;EACA,+CAAA;AtCg6IN;;AqC33IE;ECjDA,WAAA;EACA,yBnC0Ea;AHs2If;AKl6IE;EiCVI,WAAA;EACA,yBAAA;AtC+6IN;AsC56II;EAEE,UAAA;EACA,iDAAA;AtC66IN;;AqCx4IE;ECjDA,WAAA;EACA,yBnC0Ea;AHm3If;AK/6IE;EiCVI,WAAA;EACA,yBAAA;AtC47IN;AsCz7II;EAEE,UAAA;EACA,+CAAA;AtC07IN;;AqCr5IE;ECjDA,WAAA;EACA,yBnC0Ea;AHg4If;AK57IE;EiCVI,WAAA;EACA,yBAAA;AtCy8IN;AsCt8II;EAEE,UAAA;EACA,gDAAA;AtCu8IN;;AqCl6IE;ECjDA,cAAA;EACA,yBnC0Ea;AH64If;AKz8IE;EiCVI,cAAA;EACA,yBAAA;AtCs9IN;AsCn9II;EAEE,UAAA;EACA,+CAAA;AtCo9IN;;AqC/6IE;ECjDA,WAAA;EACA,yBnC0Ea;AH05If;AKt9IE;EiCVI,WAAA;EACA,yBAAA;AtCm+IN;AsCh+II;EAEE,UAAA;EACA,+CAAA;AtCi+IN;;AqC57IE;ECjDA,cAAA;EACA,yBnC0Ea;AHu6If;AKn+IE;EiCVI,cAAA;EACA,yBAAA;AtCg/IN;AsC7+II;EAEE,UAAA;EACA,iDAAA;AtC8+IN;;AqCz8IE;ECjDA,WAAA;EACA,yBnC0Ea;AHo7If;AKh/IE;EiCVI,WAAA;EACA,yBAAA;AtC6/IN;AsC1/II;EAEE,UAAA;EACA,8CAAA;AtC2/IN;;AuCxgJA;EACE,kBAAA;EACA,mBpCyzBkC;EoCvzBlC,yBpCKS;EOSP,qBAAA;AV6/IJ;Acn9II;EyB5DJ;IAQI,kBAAA;EvC2gJF;AACF;;AuCxgJA;EACE,gBAAA;EACA,eAAA;E7BIE,gBAAA;AVwgJJ;;AwCthJA;EACE,kBAAA;EACA,wBAAA;EACA,mBrCy9BkC;EqCx9BlC,6BAAA;E9BUE,sBAAA;AVghJJ;;AwCrhJA;EAEE,cAAA;AxCuhJF;;AwCnhJA;EACE,gBrC6Q4B;AHywI9B;;AwC9gJA;EACE,mBAAA;AxCihJF;AwC9gJE;EACE,kBAAA;EACA,MAAA;EACA,QAAA;EACA,UAAA;EACA,wBAAA;EACA,cAAA;AxCghJJ;;AwCtgJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxC2gJvE;AyCvjJE;EACE,yBAAA;AzCyjJJ;AyCtjJE;EACE,cAAA;AzCwjJJ;;AwClhJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxCuhJvE;AyCnkJE;EACE,yBAAA;AzCqkJJ;AyClkJE;EACE,cAAA;AzCokJJ;;AwC9hJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxCmiJvE;AyC/kJE;EACE,yBAAA;AzCilJJ;AyC9kJE;EACE,cAAA;AzCglJJ;;AwC1iJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxC+iJvE;AyC3lJE;EACE,yBAAA;AzC6lJJ;AyC1lJE;EACE,cAAA;AzC4lJJ;;AwCtjJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxC2jJvE;AyCvmJE;EACE,yBAAA;AzCymJJ;AyCtmJE;EACE,cAAA;AzCwmJJ;;AwClkJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxCukJvE;AyCnnJE;EACE,yBAAA;AzCqnJJ;AyClnJE;EACE,cAAA;AzConJJ;;AwC9kJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxCmlJvE;AyC/nJE;EACE,yBAAA;AzCioJJ;AyC9nJE;EACE,cAAA;AzCgoJJ;;AwC1lJE;EC/CA,cDgDqH;EnB3CnH,yBmB2CuB;EC9CzB,qBD8CqE;AxC+lJvE;AyC3oJE;EACE,yBAAA;AzC6oJJ;AyC1oJE;EACE,cAAA;AzC4oJJ;;A0CppJE;EACE;IAAO,2BAAA;E1CwpJT;E0CvpJE;IAAK,wBAAA;E1C0pJP;AACF;A0CvpJA;EACE,aAAA;EACA,YvCk+BkC;EuCj+BlC,gBAAA;EACA,cAAA;EtCwKI,kBAAA;EsCtKJ,yBvCLS;EOSP,sBAAA;AVspJJ;;A0CrpJA;EACE,aAAA;EACA,sBAAA;EACA,uBAAA;EACA,gBAAA;EACA,WvCjBS;EuCkBT,kBAAA;EACA,mBAAA;EACA,yBvCu9BkC;EgBl+B9B,2BuBYJ;A1CwpJF;AmBhqJM;EuBDN;IvBEQ,gBAAA;EnBmqJN;AACF;;A0C1pJA;ErBYE,qMAAA;EqBVA,0BAAA;A1C6pJF;;A0CzpJE;EACE,kDAAA;A1C4pJJ;A0CzpJM;EAJJ;IAKM,eAAA;E1C4pJN;AACF;;A2CvsJA;EACE,aAAA;EACA,uBAAA;A3C0sJF;;A2CvsJA;EACE,OAAA;A3C0sJF;;A4C5sJA;EACE,aAAA;EACA,sBAAA;EAGA,eAAA;EACA,gBAAA;ElCQE,sBAAA;AVssJJ;;A4CpsJA;EACE,WAAA;EACA,czCRS;EyCST,mBAAA;A5CusJF;AK9sJE;EuCWE,UAAA;EACA,czCdO;EyCeP,qBAAA;EACA,yBzCtBO;AH4tJX;A4CnsJE;EACE,czClBO;EyCmBP,yBzC1BO;AH+tJX;;A4C5rJA;EACE,kBAAA;EACA,cAAA;EACA,wBAAA;EAGA,sBzC3CS;EyC4CT,sCAAA;A5C6rJF;A4C3rJE;ElC1BE,+BAAA;EACA,gCAAA;AVwtJJ;A4C3rJE;ElChBE,mCAAA;EACA,kCAAA;AV8sJJ;A4C3rJE;EAEE,czClDO;EyCmDP,oBAAA;EACA,sBzC1DO;AHsvJX;A4CxrJE;EACE,UAAA;EACA,WzChEO;EyCiEP,yBzCkL0B;EyCjL1B,qBzCiL0B;AHygJ9B;A4CvrJE;EACE,mBAAA;A5CyrJJ;A4CvrJI;EACE,gBAAA;EACA,qBzC2JwB;AH8hJ9B;;A4C3qJI;EACE,mBAAA;A5C8qJN;A4C3qJQ;ElC1BJ,kCAAA;EAZA,0BAAA;AVqtJJ;A4C1qJQ;ElC3CJ,gCAAA;EAYA,4BAAA;AV6sJJ;A4CzqJQ;EACE,aAAA;A5C2qJV;A4CxqJQ;EACE,qBzC0HoB;EyCzHpB,oBAAA;A5C0qJV;A4CxqJU;EACE,iBAAA;EACA,sBzCqHkB;AHqjJ9B;;AcruJI;E8BmCA;IACE,mBAAA;E5CssJJ;E4CnsJM;IlC1BJ,kCAAA;IAZA,0BAAA;EV6uJF;E4ClsJM;IlC3CJ,gCAAA;IAYA,4BAAA;EVquJF;E4CjsJM;IACE,aAAA;E5CmsJR;E4ChsJM;IACE,qBzC0HoB;IyCzHpB,oBAAA;E5CksJR;E4ChsJQ;IACE,iBAAA;IACA,sBzCqHkB;EH6kJ5B;AACF;Ac9vJI;E8BmCA;IACE,mBAAA;E5C8tJJ;E4C3tJM;IlC1BJ,kCAAA;IAZA,0BAAA;EVqwJF;E4C1tJM;IlC3CJ,gCAAA;IAYA,4BAAA;EV6vJF;E4CztJM;IACE,aAAA;E5C2tJR;E4CxtJM;IACE,qBzC0HoB;IyCzHpB,oBAAA;E5C0tJR;E4CxtJQ;IACE,iBAAA;IACA,sBzCqHkB;EHqmJ5B;AACF;ActxJI;E8BmCA;IACE,mBAAA;E5CsvJJ;E4CnvJM;IlC1BJ,kCAAA;IAZA,0BAAA;EV6xJF;E4ClvJM;IlC3CJ,gCAAA;IAYA,4BAAA;EVqxJF;E4CjvJM;IACE,aAAA;E5CmvJR;E4ChvJM;IACE,qBzC0HoB;IyCzHpB,oBAAA;E5CkvJR;E4ChvJQ;IACE,iBAAA;IACA,sBzCqHkB;EH6nJ5B;AACF;Ac9yJI;E8BmCA;IACE,mBAAA;E5C8wJJ;E4C3wJM;IlC1BJ,kCAAA;IAZA,0BAAA;EVqzJF;E4C1wJM;IlC3CJ,gCAAA;IAYA,4BAAA;EV6yJF;E4CzwJM;IACE,aAAA;E5C2wJR;E4CxwJM;IACE,qBzC0HoB;IyCzHpB,oBAAA;E5C0wJR;E4CxwJQ;IACE,iBAAA;IACA,sBzCqHkB;EHqpJ5B;AACF;A4C7vJA;ElCnHI,gBAAA;AVm3JJ;A4C7vJE;EACE,qBAAA;A5C+vJJ;A4C7vJI;EACE,sBAAA;A5C+vJN;;A6Cx4JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5CwvJ3C;AKh4JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7C04JR;A6Cv4JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5CiwJ1E;;A6Ct5JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5CswJ3C;AK94JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7Cw5JR;A6Cr5JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5C+wJ1E;;A6Cp6JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5CoxJ3C;AK55JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7Cs6JR;A6Cn6JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5C6xJ1E;;A6Cl7JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5CkyJ3C;AK16JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7Co7JR;A6Cj7JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5C2yJ1E;;A6Ch8JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5CgzJ3C;AKx7JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7Ck8JR;A6C/7JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5CyzJ1E;;A6C98JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5C8zJ3C;AKt8JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7Cg9JR;A6C78JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5Cu0J1E;;A6C59JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5C40J3C;AKp9JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7C89JR;A6C39JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5Cq1J1E;;A6C1+JE;EACE,cDoJsE;ECnJtE,yBDmJuC;A5C01J3C;AKl+JE;EwCPM,cD+IkE;EC9IlE,yBAAA;A7C4+JR;A6Cz+JM;EACE,W1CPG;E0CQH,yBDyIkE;ECxIlE,qBDwIkE;A5Cm2J1E;;A8C3/JA;EACE,YAAA;E1CmLI,iBAAA;E0CjLJ,gB3C8R4B;E2C7R5B,cAAA;EACA,W3CYS;E2CXT,yB3CylCkC;E2CxlClC,YAAA;A9C8/JF;AKz/JE;EyCDE,W3CMO;E2CLP,qBAAA;A9C6/JJ;AKz/JE;EyCCI,aAAA;A9C2/JN;;A8Ch/JA;EACE,UAAA;EACA,6BAAA;EACA,SAAA;A9Cm/JF;;A8C7+JA;EACE,oBAAA;A9Cg/JF;;A+CthKA;EAGE,iB5C24BkC;E4C14BlC,gB5C04BkC;EC1tB9B,mBAAA;E2C7KJ,2C5C44BkC;E4C34BlC,4BAAA;EACA,oCAAA;EACA,gD5C64BkC;E4C54BlC,UAAA;ErCOE,sBAAA;AVghKJ;A+CphKE;EACE,sB5Cg4BgC;AHspIpC;A+CnhKE;EACE,UAAA;A/CqhKJ;A+ClhKE;EACE,cAAA;EACA,UAAA;A/CohKJ;A+CjhKE;EACE,aAAA;A/CmhKJ;;A+C/gKA;EACE,aAAA;EACA,mBAAA;EACA,wBAAA;EACA,c5CvBS;E4CwBT,2C5Cq3BkC;E4Cp3BlC,4BAAA;EACA,4CAAA;ErCZE,2CAAA;EACA,4CAAA;AV+hKJ;;A+ChhKA;EACE,gB5Cm2BkC;AHgrIpC;;AgDzjKA;EAEE,gBAAA;AhD2jKF;AgDzjKE;EACE,kBAAA;EACA,gBAAA;AhD2jKJ;;AgDtjKA;EACE,eAAA;EACA,MAAA;EACA,OAAA;EACA,a7C4pBkC;E6C3pBlC,aAAA;EACA,WAAA;EACA,YAAA;EACA,gBAAA;EAGA,UAAA;AhDujKF;;AgDhjKA;EACE,kBAAA;EACA,WAAA;EACA,c7Ci5BkC;E6C/4BlC,oBAAA;AhDkjKF;AgD/iKE;E7B3BI,mC6B4BF;EACA,8B7Cu6BgC;AH0oIpC;AmB1kKM;E6BuBJ;I7BtBM,gBAAA;EnB6kKN;AACF;AgDpjKE;EACE,e7Cq6BgC;AHipIpC;AgDljKE;EACE,sB7Ck6BgC;AHkpIpC;;AgDhjKA;EACE,aAAA;EACA,6BAAA;AhDmjKF;AgDjjKE;EACE,8BAAA;EACA,gBAAA;AhDmjKJ;AgDhjKE;;EAEE,cAAA;AhDkjKJ;AgD/iKE;EACE,gBAAA;AhDijKJ;;AgD7iKA;EACE,aAAA;EACA,mBAAA;EACA,6BAAA;AhDgjKF;AgD7iKE;EACE,cAAA;EACA,0BAAA;EACA,mBAAA;EACA,WAAA;AhD+iKJ;AgD3iKE;EACE,sBAAA;EACA,uBAAA;EACA,YAAA;AhD6iKJ;AgD3iKI;EACE,gBAAA;AhD6iKN;AgD1iKI;EACE,aAAA;AhD4iKN;;AgDtiKA;EACE,kBAAA;EACA,aAAA;EACA,sBAAA;EACA,WAAA;EAGA,oBAAA;EACA,sB7C3GS;E6C4GT,4BAAA;EACA,oCAAA;EtClGE,qBAAA;EsCsGF,UAAA;AhDqiKF;;AgDjiKA;EACE,eAAA;EACA,MAAA;EACA,OAAA;EACA,a7CgjBkC;E6C/iBlC,YAAA;EACA,aAAA;EACA,sB7ClHS;AHspKX;AgDjiKE;EAAS,UAAA;AhDoiKX;AgDniKE;EAAS,Y7C+zByB;AHuuIpC;;AgDjiKA;EACE,aAAA;EACA,uBAAA;EACA,8BAAA;EACA,kB7C6zBkC;E6C5zBlC,gCAAA;EtCtHE,0CAAA;EACA,2CAAA;AV2pKJ;AgDniKE;EACE,kB7CwzBgC;E6CtzBhC,8BAAA;AhDoiKJ;;AgD/hKA;EACE,gBAAA;EACA,gB7CuI4B;AH25J9B;;AgD7hKA;EACE,kBAAA;EAGA,cAAA;EACA,a7C0wBkC;AHoxIpC;;AgD1hKA;EACE,aAAA;EACA,eAAA;EACA,mBAAA;EACA,yBAAA;EACA,gBAAA;EACA,6BAAA;EtCzIE,8CAAA;EACA,6CAAA;AVuqKJ;AgDzhKE;EACE,eAAA;AhD2hKJ;;AgDthKA;EACE,kBAAA;EACA,YAAA;EACA,WAAA;EACA,YAAA;EACA,gBAAA;AhDyhKF;;AchqKI;EkC6IF;IACE,gB7CuwBgC;I6CtwBhC,oBAAA;EhDuhKF;EgDphKA;IACE,+BAAA;EhDshKF;EgDphKE;IACE,gCAAA;EhDshKJ;EgDlhKA;IACE,+BAAA;EhDohKF;EgDlhKE;IACE,4BAAA;IACA,mBAAA;EhDohKJ;EgD5gKA;IAAY,gB7C+uBsB;EHgyIlC;AACF;AcvrKI;EkC2KF;;IAEE,gB7CuuBgC;EHwyIlC;AACF;Ac7rKI;EkCkLF;IAAY,iB7CiuBsB;EH8yIlC;AACF;AiD7vKA;EACE,kBAAA;EACA,a9CgrBkC;E8C/qBlC,cAAA;EACA,S9C61BkC;E+Cj2BlC,qN/CoR4B;E+ClR5B,kBAAA;EACA,gB/C4R4B;E+C3R5B,gB/CgS4B;E+C/R5B,gBAAA;EACA,iBAAA;EACA,qBAAA;EACA,iBAAA;EACA,oBAAA;EACA,sBAAA;EACA,kBAAA;EACA,mBAAA;EACA,oBAAA;EACA,gBAAA;E9CqKI,mBAAA;E6CzKJ,qBAAA;EACA,UAAA;AjDywKF;AiDvwKE;EAAS,Y9Ci1ByB;AHy7IpC;AiDxwKE;EACE,kBAAA;EACA,cAAA;EACA,a9Ci1BgC;E8Ch1BhC,c9Ci1BgC;AHy7IpC;AiDxwKI;EACE,kBAAA;EACA,WAAA;EACA,yBAAA;EACA,mBAAA;AjD0wKN;;AiDrwKA;EACE,iBAAA;AjDwwKF;AiDtwKE;EACE,SAAA;AjDwwKJ;AiDtwKI;EACE,MAAA;EACA,6BAAA;EACA,sB9CvBK;AH+xKX;;AiDnwKA;EACE,iBAAA;AjDswKF;AiDpwKE;EACE,OAAA;EACA,a9CmzBgC;E8ClzBhC,c9CizBgC;AHq9IpC;AiDpwKI;EACE,QAAA;EACA,oCAAA;EACA,wB9CvCK;AH6yKX;;AiDjwKA;EACE,iBAAA;AjDowKF;AiDlwKE;EACE,MAAA;AjDowKJ;AiDlwKI;EACE,SAAA;EACA,6BAAA;EACA,yB9CrDK;AHyzKX;;AiD/vKA;EACE,iBAAA;AjDkwKF;AiDhwKE;EACE,QAAA;EACA,a9CqxBgC;E8CpxBhC,c9CmxBgC;AH++IpC;AiDhwKI;EACE,OAAA;EACA,oCAAA;EACA,uB9CrEK;AHu0KX;;AiD7uKA;EACE,gB9C+uBkC;E8C9uBlC,uBAAA;EACA,W9CvGS;E8CwGT,kBAAA;EACA,sB9C/FS;EOCP,sBAAA;AV+0KJ;;AmDj2KA;EACE,kBAAA;EACA,MAAA;EACA,OAAA;EACA,ahD8qBkC;EgD7qBlC,cAAA;EACA,gBhD+2BkC;E+Cp3BlC,qN/CoR4B;E+ClR5B,kBAAA;EACA,gB/C4R4B;E+C3R5B,gB/CgS4B;E+C/R5B,gBAAA;EACA,iBAAA;EACA,qBAAA;EACA,iBAAA;EACA,oBAAA;EACA,sBAAA;EACA,kBAAA;EACA,mBAAA;EACA,oBAAA;EACA,gBAAA;E9CqKI,mBAAA;E+CxKJ,qBAAA;EACA,sBhDNS;EgDOT,4BAAA;EACA,oCAAA;EzCGE,qBAAA;AV42KJ;AmD32KE;EACE,kBAAA;EACA,cAAA;EACA,WhD+2BgC;EgD92BhC,chD+2BgC;EgD92BhC,gBAAA;AnD62KJ;AmD32KI;EAEE,kBAAA;EACA,cAAA;EACA,WAAA;EACA,yBAAA;EACA,mBAAA;AnD42KN;;AmDv2KA;EACE,qBhDg2BkC;AH0gJpC;AmDx2KE;EACE,2BAAA;AnD02KJ;AmDx2KI;EACE,SAAA;EACA,6BAAA;EACA,qChD21B8B;AH+gJpC;AmDv2KI;EACE,WhD0LwB;EgDzLxB,6BAAA;EACA,sBhD7CK;AHs5KX;;AmDp2KA;EACE,mBhD40BkC;AH2hJpC;AmDr2KE;EACE,yBAAA;EACA,ahDw0BgC;EgDv0BhC,YhDs0BgC;EgDr0BhC,gBAAA;AnDu2KJ;AmDr2KI;EACE,OAAA;EACA,oCAAA;EACA,uChDo0B8B;AHmiJpC;AmDp2KI;EACE,ShDmKwB;EgDlKxB,oCAAA;EACA,wBhDpEK;AH06KX;;AmDj2KA;EACE,kBhDqzBkC;AH+iJpC;AmDl2KE;EACE,wBAAA;AnDo2KJ;AmDl2KI;EACE,MAAA;EACA,oCAAA;EACA,wChDgzB8B;AHojJpC;AmDj2KI;EACE,QhD+IwB;EgD9IxB,oCAAA;EACA,yBhDxFK;AH27KX;AmD91KE;EACE,kBAAA;EACA,MAAA;EACA,SAAA;EACA,cAAA;EACA,WhD4xBgC;EgD3xBhC,oBAAA;EACA,WAAA;EACA,gCAAA;AnDg2KJ;;AmD51KA;EACE,oBhDqxBkC;AH0kJpC;AmD71KE;EACE,0BAAA;EACA,ahDixBgC;EgDhxBhC,YhD+wBgC;EgD9wBhC,gBAAA;AnD+1KJ;AmD71KI;EACE,QAAA;EACA,oCAAA;EACA,sChD6wB8B;AHklJpC;AmD51KI;EACE,UhD4GwB;EgD3GxB,oCAAA;EACA,uBhD3HK;AHy9KX;;AmDx0KA;EACE,uBAAA;EACA,gBAAA;E/C0BI,eAAA;E+CvBJ,yBhD+tBkC;EgD9tBlC,gCAAA;EzCnIE,0CAAA;EACA,2CAAA;AV88KJ;AmDz0KE;EACE,aAAA;AnD20KJ;;AmDv0KA;EACE,uBAAA;EACA,chDxJS;AHk+KX;;AoDr+KA;EACE,kBAAA;ApDw+KF;;AoDr+KA;EACE,mBAAA;ApDw+KF;;AoDr+KA;EACE,kBAAA;EACA,WAAA;EACA,gBAAA;ApDw+KF;AqD//KE;EACE,cAAA;EACA,WAAA;EACA,WAAA;ArDigLJ;;AoDz+KA;EACE,kBAAA;EACA,aAAA;EACA,WAAA;EACA,WAAA;EACA,mBAAA;EACA,2BAAA;EjClBI,sCiCmBJ;ApD4+KF;AmB3/KM;EiCQN;IjCPQ,gBAAA;EnB8/KN;AACF;;AoD9+KA;;;EAGE,cAAA;ApDi/KF;;AoD9+KA;;EAEE,2BAAA;ApDi/KF;;AoD9+KA;;EAEE,4BAAA;ApDi/KF;;AoDx+KE;EACE,UAAA;EACA,4BAAA;EACA,eAAA;ApD2+KJ;AoDx+KE;;;EAGE,UAAA;EACA,UAAA;ApD0+KJ;AoDv+KE;;EAEE,UAAA;EACA,UAAA;EjC5DE,2BiC6DF;ApDy+KJ;AmBliLM;EiCqDJ;;IjCpDM,gBAAA;EnBsiLN;AACF;;AoDt+KA;;EAEE,kBAAA;EACA,MAAA;EACA,SAAA;EACA,UAAA;EAEA,aAAA;EACA,mBAAA;EACA,uBAAA;EACA,UjDs9BmC;EiDr9BnC,UAAA;EACA,WjD3FS;EiD4FT,kBAAA;EACA,gBAAA;EACA,SAAA;EACA,YjDi9BmC;EgBviC/B,8BiCuFJ;ApDw+KF;AmB3jLM;EiCkEN;;IjCjEQ,gBAAA;EnB+jLN;AACF;AKrkLE;;;E+C2FE,WjDpGO;EiDqGP,qBAAA;EACA,UAAA;EACA,YjD08BiC;AHqiJrC;;AoD5+KA;EACE,OAAA;ApD++KF;;AoD1+KA;EACE,QAAA;ApD6+KF;;AoDt+KA;;EAEE,qBAAA;EACA,WjDm8BmC;EiDl8BnC,YjDk8BmC;EiDj8BnC,mCAAA;ApDy+KF;;AoDv+KA;EACE,yDAAA;ApD0+KF;;AoDx+KA;EACE,yDAAA;ApD2+KF;;AoDl+KA;EACE,kBAAA;EACA,QAAA;EACA,SAAA;EACA,OAAA;EACA,WAAA;EACA,aAAA;EACA,uBAAA;EACA,eAAA;EAEA,iBjDy5BmC;EiDx5BnC,gBjDw5BmC;EiDv5BnC,gBAAA;ApDo+KF;AoDl+KE;EACE,uBAAA;EACA,cAAA;EACA,WjDu5BiC;EiDt5BjC,WjDu5BiC;EiDt5BjC,iBjDw5BiC;EiDv5BjC,gBjDu5BiC;EiDt5BjC,mBAAA;EACA,eAAA;EACA,sBjDnKO;EiDoKP,4BAAA;EAEA,kCAAA;EACA,qCAAA;EACA,YAAA;EjC/JE,6BiCgKF;ApDm+KJ;AmB/nLM;EiC6IJ;IjC5IM,gBAAA;EnBkoLN;AACF;AoDr+KE;EACE,UAAA;ApDu+KJ;;AoD99KA;EACE,kBAAA;EACA,UAAA;EACA,YAAA;EACA,SAAA;EACA,WAAA;EACA,iBAAA;EACA,oBAAA;EACA,WjD9LS;EiD+LT,kBAAA;ApDi+KF;;AsDnqLA;EACE;IAAK,yBAAA;EtDuqLL;AACF;AsDrqLA;EACE,qBAAA;EACA,WnDskCwB;EmDrkCxB,YnDqkCwB;EmDpkCxB,wBnDskCwB;EmDrkCxB,iCAAA;EACA,+BAAA;EAEA,kBAAA;EACA,+CAAA;AtDsqLF;;AsDnqLA;EACE,WnDgkCwB;EmD/jCxB,YnD+jCwB;EmD9jCxB,mBnDgkCwB;AHsmJ1B;;AsD/pLA;EACE;IACE,mBAAA;EtDkqLF;EsDhqLA;IACE,UAAA;IACA,eAAA;EtDkqLF;AACF;AsD/pLA;EACE,qBAAA;EACA,WnDsiCwB;EmDriCxB,YnDqiCwB;EmDpiCxB,wBnDsiCwB;EmDriCxB,8BAAA;EAEA,kBAAA;EACA,UAAA;EACA,6CAAA;AtDgqLF;;AsD7pLA;EACE,WnDgiCwB;EmD/hCxB,YnD+hCwB;AHioJ1B;;AsD5pLE;EACE;;IAEE,wBAAA;EtD+pLJ;AACF;AuD3tLA;EAAqB,mCAAA;AvD8tLrB;;AuD7tLA;EAAqB,8BAAA;AvDiuLrB;;AuDhuLA;EAAqB,iCAAA;AvDouLrB;;AuDnuLA;EAAqB,iCAAA;AvDuuLrB;;AuDtuLA;EAAqB,sCAAA;AvD0uLrB;;AuDzuLA;EAAqB,mCAAA;AvD6uLrB;;AwD/uLE;EACE,oCAAA;AxDkvLJ;;AKxuLE;;;EmDLI,oCAAA;AxDmvLN;;AwDzvLE;EACE,oCAAA;AxD4vLJ;;AKlvLE;;;EmDLI,oCAAA;AxD6vLN;;AwDnwLE;EACE,oCAAA;AxDswLJ;;AK5vLE;;;EmDLI,oCAAA;AxDuwLN;;AwD7wLE;EACE,oCAAA;AxDgxLJ;;AKtwLE;;;EmDLI,oCAAA;AxDixLN;;AwDvxLE;EACE,oCAAA;AxD0xLJ;;AKhxLE;;;EmDLI,oCAAA;AxD2xLN;;AwDjyLE;EACE,oCAAA;AxDoyLJ;;AK1xLE;;;EmDLI,oCAAA;AxDqyLN;;AwD3yLE;EACE,oCAAA;AxD8yLJ;;AKpyLE;;;EmDLI,oCAAA;AxD+yLN;;AwDrzLE;EACE,oCAAA;AxDwzLJ;;AK9yLE;;;EmDLI,oCAAA;AxDyzLN;;AyDxzLA;EACE,iCAAA;AzD2zLF;;AyDxzLA;EACE,wCAAA;AzD2zLF;;A0Dt0LA;EAAkB,oCAAA;A1D00LlB;;A0Dz0LA;EAAkB,wCAAA;A1D60LlB;;A0D50LA;EAAkB,0CAAA;A1Dg1LlB;;A0D/0LA;EAAkB,2CAAA;A1Dm1LlB;;A0Dl1LA;EAAkB,yCAAA;A1Ds1LlB;;A0Dp1LA;EAAmB,oBAAA;A1Dw1LnB;;A0Dv1LA;EAAmB,wBAAA;A1D21LnB;;A0D11LA;EAAmB,0BAAA;A1D81LnB;;A0D71LA;EAAmB,2BAAA;A1Di2LnB;;A0Dh2LA;EAAmB,yBAAA;A1Do2LnB;;A0Dj2LE;EACE,gCAAA;A1Do2LJ;;A0Dr2LE;EACE,gCAAA;A1Dw2LJ;;A0Dz2LE;EACE,gCAAA;A1D42LJ;;A0D72LE;EACE,gCAAA;A1Dg3LJ;;A0Dj3LE;EACE,gCAAA;A1Do3LJ;;A0Dr3LE;EACE,gCAAA;A1Dw3LJ;;A0Dz3LE;EACE,gCAAA;A1D43LJ;;A0D73LE;EACE,gCAAA;A1Dg4LJ;;A0D53LA;EACE,6BAAA;A1D+3LF;;A0Dx3LA;EACE,gCAAA;A1D23LF;;A0Dx3LA;EACE,iCAAA;A1D23LF;;A0Dx3LA;EACE,0CAAA;EACA,2CAAA;A1D23LF;;A0Dx3LA;EACE,2CAAA;EACA,8CAAA;A1D23LF;;A0Dx3LA;EACE,8CAAA;EACA,6CAAA;A1D23LF;;A0Dx3LA;EACE,0CAAA;EACA,6CAAA;A1D23LF;;A0Dx3LA;EACE,gCAAA;A1D23LF;;A0Dx3LA;EACE,6BAAA;A1D23LF;;A0Dx3LA;EACE,+BAAA;A1D23LF;;A0Dx3LA;EACE,2BAAA;A1D23LF;;AqDn8LE;EACE,cAAA;EACA,WAAA;EACA,WAAA;ArDs8LJ;;A2D/7LM;EAAwB,wBAAA;A3Dm8L9B;;A2Dn8LM;EAAwB,0BAAA;A3Du8L9B;;A2Dv8LM;EAAwB,gCAAA;A3D28L9B;;A2D38LM;EAAwB,yBAAA;A3D+8L9B;;A2D/8LM;EAAwB,yBAAA;A3Dm9L9B;;A2Dn9LM;EAAwB,6BAAA;A3Du9L9B;;A2Dv9LM;EAAwB,8BAAA;A3D29L9B;;A2D39LM;EAAwB,wBAAA;A3D+9L9B;;A2D/9LM;EAAwB,+BAAA;A3Dm+L9B;;Acl7LI;E6CjDE;IAAwB,wBAAA;E3Dw+L5B;E2Dx+LI;IAAwB,0BAAA;E3D2+L5B;E2D3+LI;IAAwB,gCAAA;E3D8+L5B;E2D9+LI;IAAwB,yBAAA;E3Di/L5B;E2Dj/LI;IAAwB,yBAAA;E3Do/L5B;E2Dp/LI;IAAwB,6BAAA;E3Du/L5B;E2Dv/LI;IAAwB,8BAAA;E3D0/L5B;E2D1/LI;IAAwB,wBAAA;E3D6/L5B;E2D7/LI;IAAwB,+BAAA;E3DggM5B;AACF;Ach9LI;E6CjDE;IAAwB,wBAAA;E3DqgM5B;E2DrgMI;IAAwB,0BAAA;E3DwgM5B;E2DxgMI;IAAwB,gCAAA;E3D2gM5B;E2D3gMI;IAAwB,yBAAA;E3D8gM5B;E2D9gMI;IAAwB,yBAAA;E3DihM5B;E2DjhMI;IAAwB,6BAAA;E3DohM5B;E2DphMI;IAAwB,8BAAA;E3DuhM5B;E2DvhMI;IAAwB,wBAAA;E3D0hM5B;E2D1hMI;IAAwB,+BAAA;E3D6hM5B;AACF;Ac7+LI;E6CjDE;IAAwB,wBAAA;E3DkiM5B;E2DliMI;IAAwB,0BAAA;E3DqiM5B;E2DriMI;IAAwB,gCAAA;E3DwiM5B;E2DxiMI;IAAwB,yBAAA;E3D2iM5B;E2D3iMI;IAAwB,yBAAA;E3D8iM5B;E2D9iMI;IAAwB,6BAAA;E3DijM5B;E2DjjMI;IAAwB,8BAAA;E3DojM5B;E2DpjMI;IAAwB,wBAAA;E3DujM5B;E2DvjMI;IAAwB,+BAAA;E3D0jM5B;AACF;Ac1gMI;E6CjDE;IAAwB,wBAAA;E3D+jM5B;E2D/jMI;IAAwB,0BAAA;E3DkkM5B;E2DlkMI;IAAwB,gCAAA;E3DqkM5B;E2DrkMI;IAAwB,yBAAA;E3DwkM5B;E2DxkMI;IAAwB,yBAAA;E3D2kM5B;E2D3kMI;IAAwB,6BAAA;E3D8kM5B;E2D9kMI;IAAwB,8BAAA;E3DilM5B;E2DjlMI;IAAwB,wBAAA;E3DolM5B;E2DplMI;IAAwB,+BAAA;E3DulM5B;AACF;A2D9kMA;EAEI;IAAqB,wBAAA;E3DglMvB;E2DhlME;IAAqB,0BAAA;E3DmlMvB;E2DnlME;IAAqB,gCAAA;E3DslMvB;E2DtlME;IAAqB,yBAAA;E3DylMvB;E2DzlME;IAAqB,yBAAA;E3D4lMvB;E2D5lME;IAAqB,6BAAA;E3D+lMvB;E2D/lME;IAAqB,8BAAA;E3DkmMvB;E2DlmME;IAAqB,wBAAA;E3DqmMvB;E2DrmME;IAAqB,+BAAA;E3DwmMvB;AACF;A4D9nMA;EACE,kBAAA;EACA,cAAA;EACA,WAAA;EACA,UAAA;EACA,gBAAA;A5DgoMF;A4D9nME;EACE,cAAA;EACA,WAAA;A5DgoMJ;A4D7nME;;;;;EAKE,kBAAA;EACA,MAAA;EACA,SAAA;EACA,OAAA;EACA,WAAA;EACA,YAAA;EACA,SAAA;A5D+nMJ;;A4DtnMI;EACE,yBAAA;A5DynMN;;A4D1nMI;EACE,mBAAA;A5D6nMN;;A4D9nMI;EACE,gBAAA;A5DioMN;;A4DloMI;EACE,iBAAA;A5DqoMN;;A6D9pMI;EAAgC,8BAAA;A7DkqMpC;;A6DjqMI;EAAgC,iCAAA;A7DqqMpC;;A6DpqMI;EAAgC,sCAAA;A7DwqMpC;;A6DvqMI;EAAgC,yCAAA;A7D2qMpC;;A6DzqMI;EAA8B,0BAAA;A7D6qMlC;;A6D5qMI;EAA8B,4BAAA;A7DgrMlC;;A6D/qMI;EAA8B,kCAAA;A7DmrMlC;;A6DlrMI;EAA8B,yBAAA;A7DsrMlC;;A6DrrMI;EAA8B,uBAAA;A7DyrMlC;;A6DxrMI;EAA8B,uBAAA;A7D4rMlC;;A6D3rMI;EAA8B,yBAAA;A7D+rMlC;;A6D9rMI;EAA8B,yBAAA;A7DksMlC;;A6DhsMI;EAAoC,sCAAA;A7DosMxC;;A6DnsMI;EAAoC,oCAAA;A7DusMxC;;A6DtsMI;EAAoC,kCAAA;A7D0sMxC;;A6DzsMI;EAAoC,yCAAA;A7D6sMxC;;A6D5sMI;EAAoC,wCAAA;A7DgtMxC;;A6D9sMI;EAAiC,kCAAA;A7DktMrC;;A6DjtMI;EAAiC,gCAAA;A7DqtMrC;;A6DptMI;EAAiC,8BAAA;A7DwtMrC;;A6DvtMI;EAAiC,gCAAA;A7D2tMrC;;A6D1tMI;EAAiC,+BAAA;A7D8tMrC;;A6D5tMI;EAAkC,oCAAA;A7DguMtC;;A6D/tMI;EAAkC,kCAAA;A7DmuMtC;;A6DluMI;EAAkC,gCAAA;A7DsuMtC;;A6DruMI;EAAkC,uCAAA;A7DyuMtC;;A6DxuMI;EAAkC,sCAAA;A7D4uMtC;;A6D3uMI;EAAkC,iCAAA;A7D+uMtC;;A6D7uMI;EAAgC,2BAAA;A7DivMpC;;A6DhvMI;EAAgC,iCAAA;A7DovMpC;;A6DnvMI;EAAgC,+BAAA;A7DuvMpC;;A6DtvMI;EAAgC,6BAAA;A7D0vMpC;;A6DzvMI;EAAgC,+BAAA;A7D6vMpC;;A6D5vMI;EAAgC,8BAAA;A7DgwMpC;;AcpvMI;E+ClDA;IAAgC,8BAAA;E7D2yMlC;E6D1yME;IAAgC,iCAAA;E7D6yMlC;E6D5yME;IAAgC,sCAAA;E7D+yMlC;E6D9yME;IAAgC,yCAAA;E7DizMlC;E6D/yME;IAA8B,0BAAA;E7DkzMhC;E6DjzME;IAA8B,4BAAA;E7DozMhC;E6DnzME;IAA8B,kCAAA;E7DszMhC;E6DrzME;IAA8B,yBAAA;E7DwzMhC;E6DvzME;IAA8B,uBAAA;E7D0zMhC;E6DzzME;IAA8B,uBAAA;E7D4zMhC;E6D3zME;IAA8B,yBAAA;E7D8zMhC;E6D7zME;IAA8B,yBAAA;E7Dg0MhC;E6D9zME;IAAoC,sCAAA;E7Di0MtC;E6Dh0ME;IAAoC,oCAAA;E7Dm0MtC;E6Dl0ME;IAAoC,kCAAA;E7Dq0MtC;E6Dp0ME;IAAoC,yCAAA;E7Du0MtC;E6Dt0ME;IAAoC,wCAAA;E7Dy0MtC;E6Dv0ME;IAAiC,kCAAA;E7D00MnC;E6Dz0ME;IAAiC,gCAAA;E7D40MnC;E6D30ME;IAAiC,8BAAA;E7D80MnC;E6D70ME;IAAiC,gCAAA;E7Dg1MnC;E6D/0ME;IAAiC,+BAAA;E7Dk1MnC;E6Dh1ME;IAAkC,oCAAA;E7Dm1MpC;E6Dl1ME;IAAkC,kCAAA;E7Dq1MpC;E6Dp1ME;IAAkC,gCAAA;E7Du1MpC;E6Dt1ME;IAAkC,uCAAA;E7Dy1MpC;E6Dx1ME;IAAkC,sCAAA;E7D21MpC;E6D11ME;IAAkC,iCAAA;E7D61MpC;E6D31ME;IAAgC,2BAAA;E7D81MlC;E6D71ME;IAAgC,iCAAA;E7Dg2MlC;E6D/1ME;IAAgC,+BAAA;E7Dk2MlC;E6Dj2ME;IAAgC,6BAAA;E7Do2MlC;E6Dn2ME;IAAgC,+BAAA;E7Ds2MlC;E6Dr2ME;IAAgC,8BAAA;E7Dw2MlC;AACF;Ac71MI;E+ClDA;IAAgC,8BAAA;E7Dm5MlC;E6Dl5ME;IAAgC,iCAAA;E7Dq5MlC;E6Dp5ME;IAAgC,sCAAA;E7Du5MlC;E6Dt5ME;IAAgC,yCAAA;E7Dy5MlC;E6Dv5ME;IAA8B,0BAAA;E7D05MhC;E6Dz5ME;IAA8B,4BAAA;E7D45MhC;E6D35ME;IAA8B,kCAAA;E7D85MhC;E6D75ME;IAA8B,yBAAA;E7Dg6MhC;E6D/5ME;IAA8B,uBAAA;E7Dk6MhC;E6Dj6ME;IAA8B,uBAAA;E7Do6MhC;E6Dn6ME;IAA8B,yBAAA;E7Ds6MhC;E6Dr6ME;IAA8B,yBAAA;E7Dw6MhC;E6Dt6ME;IAAoC,sCAAA;E7Dy6MtC;E6Dx6ME;IAAoC,oCAAA;E7D26MtC;E6D16ME;IAAoC,kCAAA;E7D66MtC;E6D56ME;IAAoC,yCAAA;E7D+6MtC;E6D96ME;IAAoC,wCAAA;E7Di7MtC;E6D/6ME;IAAiC,kCAAA;E7Dk7MnC;E6Dj7ME;IAAiC,gCAAA;E7Do7MnC;E6Dn7ME;IAAiC,8BAAA;E7Ds7MnC;E6Dr7ME;IAAiC,gCAAA;E7Dw7MnC;E6Dv7ME;IAAiC,+BAAA;E7D07MnC;E6Dx7ME;IAAkC,oCAAA;E7D27MpC;E6D17ME;IAAkC,kCAAA;E7D67MpC;E6D57ME;IAAkC,gCAAA;E7D+7MpC;E6D97ME;IAAkC,uCAAA;E7Di8MpC;E6Dh8ME;IAAkC,sCAAA;E7Dm8MpC;E6Dl8ME;IAAkC,iCAAA;E7Dq8MpC;E6Dn8ME;IAAgC,2BAAA;E7Ds8MlC;E6Dr8ME;IAAgC,iCAAA;E7Dw8MlC;E6Dv8ME;IAAgC,+BAAA;E7D08MlC;E6Dz8ME;IAAgC,6BAAA;E7D48MlC;E6D38ME;IAAgC,+BAAA;E7D88MlC;E6D78ME;IAAgC,8BAAA;E7Dg9MlC;AACF;Acr8MI;E+ClDA;IAAgC,8BAAA;E7D2/MlC;E6D1/ME;IAAgC,iCAAA;E7D6/MlC;E6D5/ME;IAAgC,sCAAA;E7D+/MlC;E6D9/ME;IAAgC,yCAAA;E7DigNlC;E6D//ME;IAA8B,0BAAA;E7DkgNhC;E6DjgNE;IAA8B,4BAAA;E7DogNhC;E6DngNE;IAA8B,kCAAA;E7DsgNhC;E6DrgNE;IAA8B,yBAAA;E7DwgNhC;E6DvgNE;IAA8B,uBAAA;E7D0gNhC;E6DzgNE;IAA8B,uBAAA;E7D4gNhC;E6D3gNE;IAA8B,yBAAA;E7D8gNhC;E6D7gNE;IAA8B,yBAAA;E7DghNhC;E6D9gNE;IAAoC,sCAAA;E7DihNtC;E6DhhNE;IAAoC,oCAAA;E7DmhNtC;E6DlhNE;IAAoC,kCAAA;E7DqhNtC;E6DphNE;IAAoC,yCAAA;E7DuhNtC;E6DthNE;IAAoC,wCAAA;E7DyhNtC;E6DvhNE;IAAiC,kCAAA;E7D0hNnC;E6DzhNE;IAAiC,gCAAA;E7D4hNnC;E6D3hNE;IAAiC,8BAAA;E7D8hNnC;E6D7hNE;IAAiC,gCAAA;E7DgiNnC;E6D/hNE;IAAiC,+BAAA;E7DkiNnC;E6DhiNE;IAAkC,oCAAA;E7DmiNpC;E6DliNE;IAAkC,kCAAA;E7DqiNpC;E6DpiNE;IAAkC,gCAAA;E7DuiNpC;E6DtiNE;IAAkC,uCAAA;E7DyiNpC;E6DxiNE;IAAkC,sCAAA;E7D2iNpC;E6D1iNE;IAAkC,iCAAA;E7D6iNpC;E6D3iNE;IAAgC,2BAAA;E7D8iNlC;E6D7iNE;IAAgC,iCAAA;E7DgjNlC;E6D/iNE;IAAgC,+BAAA;E7DkjNlC;E6DjjNE;IAAgC,6BAAA;E7DojNlC;E6DnjNE;IAAgC,+BAAA;E7DsjNlC;E6DrjNE;IAAgC,8BAAA;E7DwjNlC;AACF;Ac7iNI;E+ClDA;IAAgC,8BAAA;E7DmmNlC;E6DlmNE;IAAgC,iCAAA;E7DqmNlC;E6DpmNE;IAAgC,sCAAA;E7DumNlC;E6DtmNE;IAAgC,yCAAA;E7DymNlC;E6DvmNE;IAA8B,0BAAA;E7D0mNhC;E6DzmNE;IAA8B,4BAAA;E7D4mNhC;E6D3mNE;IAA8B,kCAAA;E7D8mNhC;E6D7mNE;IAA8B,yBAAA;E7DgnNhC;E6D/mNE;IAA8B,uBAAA;E7DknNhC;E6DjnNE;IAA8B,uBAAA;E7DonNhC;E6DnnNE;IAA8B,yBAAA;E7DsnNhC;E6DrnNE;IAA8B,yBAAA;E7DwnNhC;E6DtnNE;IAAoC,sCAAA;E7DynNtC;E6DxnNE;IAAoC,oCAAA;E7D2nNtC;E6D1nNE;IAAoC,kCAAA;E7D6nNtC;E6D5nNE;IAAoC,yCAAA;E7D+nNtC;E6D9nNE;IAAoC,wCAAA;E7DioNtC;E6D/nNE;IAAiC,kCAAA;E7DkoNnC;E6DjoNE;IAAiC,gCAAA;E7DooNnC;E6DnoNE;IAAiC,8BAAA;E7DsoNnC;E6DroNE;IAAiC,gCAAA;E7DwoNnC;E6DvoNE;IAAiC,+BAAA;E7D0oNnC;E6DxoNE;IAAkC,oCAAA;E7D2oNpC;E6D1oNE;IAAkC,kCAAA;E7D6oNpC;E6D5oNE;IAAkC,gCAAA;E7D+oNpC;E6D9oNE;IAAkC,uCAAA;E7DipNpC;E6DhpNE;IAAkC,sCAAA;E7DmpNpC;E6DlpNE;IAAkC,iCAAA;E7DqpNpC;E6DnpNE;IAAgC,2BAAA;E7DspNlC;E6DrpNE;IAAgC,iCAAA;E7DwpNlC;E6DvpNE;IAAgC,+BAAA;E7D0pNlC;E6DzpNE;IAAgC,6BAAA;E7D4pNlC;E6D3pNE;IAAgC,+BAAA;E7D8pNlC;E6D7pNE;IAAgC,8BAAA;E7DgqNlC;AACF;A8D3sNI;EAAwB,sBAAA;A9D8sN5B;;A8D7sNI;EAAwB,uBAAA;A9DitN5B;;A8DhtNI;EAAwB,sBAAA;A9DotN5B;;AchqNI;EgDtDA;IAAwB,sBAAA;E9D2tN1B;E8D1tNE;IAAwB,uBAAA;E9D6tN1B;E8D5tNE;IAAwB,sBAAA;E9D+tN1B;AACF;Ac5qNI;EgDtDA;IAAwB,sBAAA;E9DsuN1B;E8DruNE;IAAwB,uBAAA;E9DwuN1B;E8DvuNE;IAAwB,sBAAA;E9D0uN1B;AACF;AcvrNI;EgDtDA;IAAwB,sBAAA;E9DivN1B;E8DhvNE;IAAwB,uBAAA;E9DmvN1B;E8DlvNE;IAAwB,sBAAA;E9DqvN1B;AACF;AclsNI;EgDtDA;IAAwB,sBAAA;E9D4vN1B;E8D3vNE;IAAwB,uBAAA;E9D8vN1B;E8D7vNE;IAAwB,sBAAA;E9DgwN1B;AACF;A+DtwNE;EAAyB,2BAAA;A/DywN3B;;A+DzwNE;EAAyB,4BAAA;A/D6wN3B;;A+D7wNE;EAAyB,4BAAA;A/DixN3B;;AgEjxNE;EAAsB,yBAAA;AhEqxNxB;;AgErxNE;EAAsB,2BAAA;AhEyxNxB;;AiExxNE;EAAyB,2BAAA;AjE4xN3B;;AiE5xNE;EAAyB,6BAAA;AjEgyN3B;;AiEhyNE;EAAyB,6BAAA;AjEoyN3B;;AiEpyNE;EAAyB,0BAAA;AjEwyN3B;;AiExyNE;EAAyB,2BAAA;AjE4yN3B;;AiEvyNA;EACE,eAAA;EACA,MAAA;EACA,QAAA;EACA,OAAA;EACA,a9DiqBkC;AHyoMpC;;AiEvyNA;EACE,eAAA;EACA,QAAA;EACA,SAAA;EACA,OAAA;EACA,a9DypBkC;AHipMpC;;AiEtyNE;EADF;IAEI,gBAAA;IACA,MAAA;IACA,a9DipBgC;EHypMlC;AACF;;AkEp0NA;ECEE,kBAAA;EACA,UAAA;EACA,WAAA;EACA,UAAA;EACA,YAAA;EACA,gBAAA;EACA,sBAAA;EACA,mBAAA;EACA,SAAA;AnEs0NF;;AmE5zNE;EAEE,gBAAA;EACA,WAAA;EACA,YAAA;EACA,iBAAA;EACA,UAAA;EACA,mBAAA;AnE8zNJ;;AoE31NA;EAAa,8DAAA;ApE+1Nb;;AoE91NA;EAAU,wDAAA;ApEk2NV;;AoEj2NA;EAAa,uDAAA;ApEq2Nb;;AoEp2NA;EAAe,2BAAA;ApEw2Nf;;AqEv2NI;EAAuB,qBAAA;ArE22N3B;;AqE32NI;EAAuB,qBAAA;ArE+2N3B;;AqE/2NI;EAAuB,qBAAA;ArEm3N3B;;AqEn3NI;EAAuB,sBAAA;ArEu3N3B;;AqEv3NI;EAAuB,sBAAA;ArE23N3B;;AqE33NI;EAAuB,sBAAA;ArE+3N3B;;AqE/3NI;EAAuB,sBAAA;ArEm4N3B;;AqEn4NI;EAAuB,sBAAA;ArEu4N3B;;AqEv4NI;EAAuB,uBAAA;ArE24N3B;;AqE34NI;EAAuB,uBAAA;ArE+4N3B;;AqE34NA;EAAU,0BAAA;ArE+4NV;;AqE94NA;EAAU,2BAAA;ArEk5NV;;AqE94NA;EAAc,2BAAA;ArEk5Nd;;AqEj5NA;EAAc,4BAAA;ArEq5Nd;;AqEn5NA;EAAU,uBAAA;ArEu5NV;;AqEt5NA;EAAU,wBAAA;ArE05NV;;AsEn6NQ;EAAgC,oBAAA;AtEu6NxC;;AsEt6NQ;;EAEE,wBAAA;AtEy6NV;;AsEv6NQ;;EAEE,0BAAA;AtE06NV;;AsEx6NQ;;EAEE,2BAAA;AtE26NV;;AsEz6NQ;;EAEE,yBAAA;AtE46NV;;AsE37NQ;EAAgC,0BAAA;AtE+7NxC;;AsE97NQ;;EAEE,8BAAA;AtEi8NV;;AsE/7NQ;;EAEE,gCAAA;AtEk8NV;;AsEh8NQ;;EAEE,iCAAA;AtEm8NV;;AsEj8NQ;;EAEE,+BAAA;AtEo8NV;;AsEn9NQ;EAAgC,yBAAA;AtEu9NxC;;AsEt9NQ;;EAEE,6BAAA;AtEy9NV;;AsEv9NQ;;EAEE,+BAAA;AtE09NV;;AsEx9NQ;;EAEE,gCAAA;AtE29NV;;AsEz9NQ;;EAEE,8BAAA;AtE49NV;;AsE3+NQ;EAAgC,uBAAA;AtE++NxC;;AsE9+NQ;;EAEE,2BAAA;AtEi/NV;;AsE/+NQ;;EAEE,6BAAA;AtEk/NV;;AsEh/NQ;;EAEE,8BAAA;AtEm/NV;;AsEj/NQ;;EAEE,4BAAA;AtEo/NV;;AsEngOQ;EAAgC,yBAAA;AtEugOxC;;AsEtgOQ;;EAEE,6BAAA;AtEygOV;;AsEvgOQ;;EAEE,+BAAA;AtE0gOV;;AsExgOQ;;EAEE,gCAAA;AtE2gOV;;AsEzgOQ;;EAEE,8BAAA;AtE4gOV;;AsE3hOQ;EAAgC,uBAAA;AtE+hOxC;;AsE9hOQ;;EAEE,2BAAA;AtEiiOV;;AsE/hOQ;;EAEE,6BAAA;AtEkiOV;;AsEhiOQ;;EAEE,8BAAA;AtEmiOV;;AsEjiOQ;;EAEE,4BAAA;AtEoiOV;;AsEnjOQ;EAAgC,qBAAA;AtEujOxC;;AsEtjOQ;;EAEE,yBAAA;AtEyjOV;;AsEvjOQ;;EAEE,2BAAA;AtE0jOV;;AsExjOQ;;EAEE,4BAAA;AtE2jOV;;AsEzjOQ;;EAEE,0BAAA;AtE4jOV;;AsE3kOQ;EAAgC,2BAAA;AtE+kOxC;;AsE9kOQ;;EAEE,+BAAA;AtEilOV;;AsE/kOQ;;EAEE,iCAAA;AtEklOV;;AsEhlOQ;;EAEE,kCAAA;AtEmlOV;;AsEjlOQ;;EAEE,gCAAA;AtEolOV;;AsEnmOQ;EAAgC,0BAAA;AtEumOxC;;AsEtmOQ;;EAEE,8BAAA;AtEymOV;;AsEvmOQ;;EAEE,gCAAA;AtE0mOV;;AsExmOQ;;EAEE,iCAAA;AtE2mOV;;AsEzmOQ;;EAEE,+BAAA;AtE4mOV;;AsE3nOQ;EAAgC,wBAAA;AtE+nOxC;;AsE9nOQ;;EAEE,4BAAA;AtEioOV;;AsE/nOQ;;EAEE,8BAAA;AtEkoOV;;AsEhoOQ;;EAEE,+BAAA;AtEmoOV;;AsEjoOQ;;EAEE,6BAAA;AtEooOV;;AsEnpOQ;EAAgC,0BAAA;AtEupOxC;;AsEtpOQ;;EAEE,8BAAA;AtEypOV;;AsEvpOQ;;EAEE,gCAAA;AtE0pOV;;AsExpOQ;;EAEE,iCAAA;AtE2pOV;;AsEzpOQ;;EAEE,+BAAA;AtE4pOV;;AsE3qOQ;EAAgC,wBAAA;AtE+qOxC;;AsE9qOQ;;EAEE,4BAAA;AtEirOV;;AsE/qOQ;;EAEE,8BAAA;AtEkrOV;;AsEhrOQ;;EAEE,+BAAA;AtEmrOV;;AsEjrOQ;;EAEE,6BAAA;AtEorOV;;AsE5qOQ;EAAwB,2BAAA;AtEgrOhC;;AsE/qOQ;;EAEE,+BAAA;AtEkrOV;;AsEhrOQ;;EAEE,iCAAA;AtEmrOV;;AsEjrOQ;;EAEE,kCAAA;AtEorOV;;AsElrOQ;;EAEE,gCAAA;AtEqrOV;;AsEpsOQ;EAAwB,0BAAA;AtEwsOhC;;AsEvsOQ;;EAEE,8BAAA;AtE0sOV;;AsExsOQ;;EAEE,gCAAA;AtE2sOV;;AsEzsOQ;;EAEE,iCAAA;AtE4sOV;;AsE1sOQ;;EAEE,+BAAA;AtE6sOV;;AsE5tOQ;EAAwB,wBAAA;AtEguOhC;;AsE/tOQ;;EAEE,4BAAA;AtEkuOV;;AsEhuOQ;;EAEE,8BAAA;AtEmuOV;;AsEjuOQ;;EAEE,+BAAA;AtEouOV;;AsEluOQ;;EAEE,6BAAA;AtEquOV;;AsEpvOQ;EAAwB,0BAAA;AtEwvOhC;;AsEvvOQ;;EAEE,8BAAA;AtE0vOV;;AsExvOQ;;EAEE,gCAAA;AtE2vOV;;AsEzvOQ;;EAEE,iCAAA;AtE4vOV;;AsE1vOQ;;EAEE,+BAAA;AtE6vOV;;AsE5wOQ;EAAwB,wBAAA;AtEgxOhC;;AsE/wOQ;;EAEE,4BAAA;AtEkxOV;;AsEhxOQ;;EAEE,8BAAA;AtEmxOV;;AsEjxOQ;;EAEE,+BAAA;AtEoxOV;;AsElxOQ;;EAEE,6BAAA;AtEqxOV;;AsE/wOI;EAAmB,uBAAA;AtEmxOvB;;AsElxOI;;EAEE,2BAAA;AtEqxON;;AsEnxOI;;EAEE,6BAAA;AtEsxON;;AsEpxOI;;EAEE,8BAAA;AtEuxON;;AsErxOI;;EAEE,4BAAA;AtEwxON;;AcjyOI;EwDlDI;IAAgC,oBAAA;EtEw1OtC;EsEv1OM;;IAEE,wBAAA;EtEy1OR;EsEv1OM;;IAEE,0BAAA;EtEy1OR;EsEv1OM;;IAEE,2BAAA;EtEy1OR;EsEv1OM;;IAEE,yBAAA;EtEy1OR;EsEx2OM;IAAgC,0BAAA;EtE22OtC;EsE12OM;;IAEE,8BAAA;EtE42OR;EsE12OM;;IAEE,gCAAA;EtE42OR;EsE12OM;;IAEE,iCAAA;EtE42OR;EsE12OM;;IAEE,+BAAA;EtE42OR;EsE33OM;IAAgC,yBAAA;EtE83OtC;EsE73OM;;IAEE,6BAAA;EtE+3OR;EsE73OM;;IAEE,+BAAA;EtE+3OR;EsE73OM;;IAEE,gCAAA;EtE+3OR;EsE73OM;;IAEE,8BAAA;EtE+3OR;EsE94OM;IAAgC,uBAAA;EtEi5OtC;EsEh5OM;;IAEE,2BAAA;EtEk5OR;EsEh5OM;;IAEE,6BAAA;EtEk5OR;EsEh5OM;;IAEE,8BAAA;EtEk5OR;EsEh5OM;;IAEE,4BAAA;EtEk5OR;EsEj6OM;IAAgC,yBAAA;EtEo6OtC;EsEn6OM;;IAEE,6BAAA;EtEq6OR;EsEn6OM;;IAEE,+BAAA;EtEq6OR;EsEn6OM;;IAEE,gCAAA;EtEq6OR;EsEn6OM;;IAEE,8BAAA;EtEq6OR;EsEp7OM;IAAgC,uBAAA;EtEu7OtC;EsEt7OM;;IAEE,2BAAA;EtEw7OR;EsEt7OM;;IAEE,6BAAA;EtEw7OR;EsEt7OM;;IAEE,8BAAA;EtEw7OR;EsEt7OM;;IAEE,4BAAA;EtEw7OR;EsEv8OM;IAAgC,qBAAA;EtE08OtC;EsEz8OM;;IAEE,yBAAA;EtE28OR;EsEz8OM;;IAEE,2BAAA;EtE28OR;EsEz8OM;;IAEE,4BAAA;EtE28OR;EsEz8OM;;IAEE,0BAAA;EtE28OR;EsE19OM;IAAgC,2BAAA;EtE69OtC;EsE59OM;;IAEE,+BAAA;EtE89OR;EsE59OM;;IAEE,iCAAA;EtE89OR;EsE59OM;;IAEE,kCAAA;EtE89OR;EsE59OM;;IAEE,gCAAA;EtE89OR;EsE7+OM;IAAgC,0BAAA;EtEg/OtC;EsE/+OM;;IAEE,8BAAA;EtEi/OR;EsE/+OM;;IAEE,gCAAA;EtEi/OR;EsE/+OM;;IAEE,iCAAA;EtEi/OR;EsE/+OM;;IAEE,+BAAA;EtEi/OR;EsEhgPM;IAAgC,wBAAA;EtEmgPtC;EsElgPM;;IAEE,4BAAA;EtEogPR;EsElgPM;;IAEE,8BAAA;EtEogPR;EsElgPM;;IAEE,+BAAA;EtEogPR;EsElgPM;;IAEE,6BAAA;EtEogPR;EsEnhPM;IAAgC,0BAAA;EtEshPtC;EsErhPM;;IAEE,8BAAA;EtEuhPR;EsErhPM;;IAEE,gCAAA;EtEuhPR;EsErhPM;;IAEE,iCAAA;EtEuhPR;EsErhPM;;IAEE,+BAAA;EtEuhPR;EsEtiPM;IAAgC,wBAAA;EtEyiPtC;EsExiPM;;IAEE,4BAAA;EtE0iPR;EsExiPM;;IAEE,8BAAA;EtE0iPR;EsExiPM;;IAEE,+BAAA;EtE0iPR;EsExiPM;;IAEE,6BAAA;EtE0iPR;EsEliPM;IAAwB,2BAAA;EtEqiP9B;EsEpiPM;;IAEE,+BAAA;EtEsiPR;EsEpiPM;;IAEE,iCAAA;EtEsiPR;EsEpiPM;;IAEE,kCAAA;EtEsiPR;EsEpiPM;;IAEE,gCAAA;EtEsiPR;EsErjPM;IAAwB,0BAAA;EtEwjP9B;EsEvjPM;;IAEE,8BAAA;EtEyjPR;EsEvjPM;;IAEE,gCAAA;EtEyjPR;EsEvjPM;;IAEE,iCAAA;EtEyjPR;EsEvjPM;;IAEE,+BAAA;EtEyjPR;EsExkPM;IAAwB,wBAAA;EtE2kP9B;EsE1kPM;;IAEE,4BAAA;EtE4kPR;EsE1kPM;;IAEE,8BAAA;EtE4kPR;EsE1kPM;;IAEE,+BAAA;EtE4kPR;EsE1kPM;;IAEE,6BAAA;EtE4kPR;EsE3lPM;IAAwB,0BAAA;EtE8lP9B;EsE7lPM;;IAEE,8BAAA;EtE+lPR;EsE7lPM;;IAEE,gCAAA;EtE+lPR;EsE7lPM;;IAEE,iCAAA;EtE+lPR;EsE7lPM;;IAEE,+BAAA;EtE+lPR;EsE9mPM;IAAwB,wBAAA;EtEinP9B;EsEhnPM;;IAEE,4BAAA;EtEknPR;EsEhnPM;;IAEE,8BAAA;EtEknPR;EsEhnPM;;IAEE,+BAAA;EtEknPR;EsEhnPM;;IAEE,6BAAA;EtEknPR;EsE5mPE;IAAmB,uBAAA;EtE+mPrB;EsE9mPE;;IAEE,2BAAA;EtEgnPJ;EsE9mPE;;IAEE,6BAAA;EtEgnPJ;EsE9mPE;;IAEE,8BAAA;EtEgnPJ;EsE9mPE;;IAEE,4BAAA;EtEgnPJ;AACF;Ac1nPI;EwDlDI;IAAgC,oBAAA;EtEgrPtC;EsE/qPM;;IAEE,wBAAA;EtEirPR;EsE/qPM;;IAEE,0BAAA;EtEirPR;EsE/qPM;;IAEE,2BAAA;EtEirPR;EsE/qPM;;IAEE,yBAAA;EtEirPR;EsEhsPM;IAAgC,0BAAA;EtEmsPtC;EsElsPM;;IAEE,8BAAA;EtEosPR;EsElsPM;;IAEE,gCAAA;EtEosPR;EsElsPM;;IAEE,iCAAA;EtEosPR;EsElsPM;;IAEE,+BAAA;EtEosPR;EsEntPM;IAAgC,yBAAA;EtEstPtC;EsErtPM;;IAEE,6BAAA;EtEutPR;EsErtPM;;IAEE,+BAAA;EtEutPR;EsErtPM;;IAEE,gCAAA;EtEutPR;EsErtPM;;IAEE,8BAAA;EtEutPR;EsEtuPM;IAAgC,uBAAA;EtEyuPtC;EsExuPM;;IAEE,2BAAA;EtE0uPR;EsExuPM;;IAEE,6BAAA;EtE0uPR;EsExuPM;;IAEE,8BAAA;EtE0uPR;EsExuPM;;IAEE,4BAAA;EtE0uPR;EsEzvPM;IAAgC,yBAAA;EtE4vPtC;EsE3vPM;;IAEE,6BAAA;EtE6vPR;EsE3vPM;;IAEE,+BAAA;EtE6vPR;EsE3vPM;;IAEE,gCAAA;EtE6vPR;EsE3vPM;;IAEE,8BAAA;EtE6vPR;EsE5wPM;IAAgC,uBAAA;EtE+wPtC;EsE9wPM;;IAEE,2BAAA;EtEgxPR;EsE9wPM;;IAEE,6BAAA;EtEgxPR;EsE9wPM;;IAEE,8BAAA;EtEgxPR;EsE9wPM;;IAEE,4BAAA;EtEgxPR;EsE/xPM;IAAgC,qBAAA;EtEkyPtC;EsEjyPM;;IAEE,yBAAA;EtEmyPR;EsEjyPM;;IAEE,2BAAA;EtEmyPR;EsEjyPM;;IAEE,4BAAA;EtEmyPR;EsEjyPM;;IAEE,0BAAA;EtEmyPR;EsElzPM;IAAgC,2BAAA;EtEqzPtC;EsEpzPM;;IAEE,+BAAA;EtEszPR;EsEpzPM;;IAEE,iCAAA;EtEszPR;EsEpzPM;;IAEE,kCAAA;EtEszPR;EsEpzPM;;IAEE,gCAAA;EtEszPR;EsEr0PM;IAAgC,0BAAA;EtEw0PtC;EsEv0PM;;IAEE,8BAAA;EtEy0PR;EsEv0PM;;IAEE,gCAAA;EtEy0PR;EsEv0PM;;IAEE,iCAAA;EtEy0PR;EsEv0PM;;IAEE,+BAAA;EtEy0PR;EsEx1PM;IAAgC,wBAAA;EtE21PtC;EsE11PM;;IAEE,4BAAA;EtE41PR;EsE11PM;;IAEE,8BAAA;EtE41PR;EsE11PM;;IAEE,+BAAA;EtE41PR;EsE11PM;;IAEE,6BAAA;EtE41PR;EsE32PM;IAAgC,0BAAA;EtE82PtC;EsE72PM;;IAEE,8BAAA;EtE+2PR;EsE72PM;;IAEE,gCAAA;EtE+2PR;EsE72PM;;IAEE,iCAAA;EtE+2PR;EsE72PM;;IAEE,+BAAA;EtE+2PR;EsE93PM;IAAgC,wBAAA;EtEi4PtC;EsEh4PM;;IAEE,4BAAA;EtEk4PR;EsEh4PM;;IAEE,8BAAA;EtEk4PR;EsEh4PM;;IAEE,+BAAA;EtEk4PR;EsEh4PM;;IAEE,6BAAA;EtEk4PR;EsE13PM;IAAwB,2BAAA;EtE63P9B;EsE53PM;;IAEE,+BAAA;EtE83PR;EsE53PM;;IAEE,iCAAA;EtE83PR;EsE53PM;;IAEE,kCAAA;EtE83PR;EsE53PM;;IAEE,gCAAA;EtE83PR;EsE74PM;IAAwB,0BAAA;EtEg5P9B;EsE/4PM;;IAEE,8BAAA;EtEi5PR;EsE/4PM;;IAEE,gCAAA;EtEi5PR;EsE/4PM;;IAEE,iCAAA;EtEi5PR;EsE/4PM;;IAEE,+BAAA;EtEi5PR;EsEh6PM;IAAwB,wBAAA;EtEm6P9B;EsEl6PM;;IAEE,4BAAA;EtEo6PR;EsEl6PM;;IAEE,8BAAA;EtEo6PR;EsEl6PM;;IAEE,+BAAA;EtEo6PR;EsEl6PM;;IAEE,6BAAA;EtEo6PR;EsEn7PM;IAAwB,0BAAA;EtEs7P9B;EsEr7PM;;IAEE,8BAAA;EtEu7PR;EsEr7PM;;IAEE,gCAAA;EtEu7PR;EsEr7PM;;IAEE,iCAAA;EtEu7PR;EsEr7PM;;IAEE,+BAAA;EtEu7PR;EsEt8PM;IAAwB,wBAAA;EtEy8P9B;EsEx8PM;;IAEE,4BAAA;EtE08PR;EsEx8PM;;IAEE,8BAAA;EtE08PR;EsEx8PM;;IAEE,+BAAA;EtE08PR;EsEx8PM;;IAEE,6BAAA;EtE08PR;EsEp8PE;IAAmB,uBAAA;EtEu8PrB;EsEt8PE;;IAEE,2BAAA;EtEw8PJ;EsEt8PE;;IAEE,6BAAA;EtEw8PJ;EsEt8PE;;IAEE,8BAAA;EtEw8PJ;EsEt8PE;;IAEE,4BAAA;EtEw8PJ;AACF;Acl9PI;EwDlDI;IAAgC,oBAAA;EtEwgQtC;EsEvgQM;;IAEE,wBAAA;EtEygQR;EsEvgQM;;IAEE,0BAAA;EtEygQR;EsEvgQM;;IAEE,2BAAA;EtEygQR;EsEvgQM;;IAEE,yBAAA;EtEygQR;EsExhQM;IAAgC,0BAAA;EtE2hQtC;EsE1hQM;;IAEE,8BAAA;EtE4hQR;EsE1hQM;;IAEE,gCAAA;EtE4hQR;EsE1hQM;;IAEE,iCAAA;EtE4hQR;EsE1hQM;;IAEE,+BAAA;EtE4hQR;EsE3iQM;IAAgC,yBAAA;EtE8iQtC;EsE7iQM;;IAEE,6BAAA;EtE+iQR;EsE7iQM;;IAEE,+BAAA;EtE+iQR;EsE7iQM;;IAEE,gCAAA;EtE+iQR;EsE7iQM;;IAEE,8BAAA;EtE+iQR;EsE9jQM;IAAgC,uBAAA;EtEikQtC;EsEhkQM;;IAEE,2BAAA;EtEkkQR;EsEhkQM;;IAEE,6BAAA;EtEkkQR;EsEhkQM;;IAEE,8BAAA;EtEkkQR;EsEhkQM;;IAEE,4BAAA;EtEkkQR;EsEjlQM;IAAgC,yBAAA;EtEolQtC;EsEnlQM;;IAEE,6BAAA;EtEqlQR;EsEnlQM;;IAEE,+BAAA;EtEqlQR;EsEnlQM;;IAEE,gCAAA;EtEqlQR;EsEnlQM;;IAEE,8BAAA;EtEqlQR;EsEpmQM;IAAgC,uBAAA;EtEumQtC;EsEtmQM;;IAEE,2BAAA;EtEwmQR;EsEtmQM;;IAEE,6BAAA;EtEwmQR;EsEtmQM;;IAEE,8BAAA;EtEwmQR;EsEtmQM;;IAEE,4BAAA;EtEwmQR;EsEvnQM;IAAgC,qBAAA;EtE0nQtC;EsEznQM;;IAEE,yBAAA;EtE2nQR;EsEznQM;;IAEE,2BAAA;EtE2nQR;EsEznQM;;IAEE,4BAAA;EtE2nQR;EsEznQM;;IAEE,0BAAA;EtE2nQR;EsE1oQM;IAAgC,2BAAA;EtE6oQtC;EsE5oQM;;IAEE,+BAAA;EtE8oQR;EsE5oQM;;IAEE,iCAAA;EtE8oQR;EsE5oQM;;IAEE,kCAAA;EtE8oQR;EsE5oQM;;IAEE,gCAAA;EtE8oQR;EsE7pQM;IAAgC,0BAAA;EtEgqQtC;EsE/pQM;;IAEE,8BAAA;EtEiqQR;EsE/pQM;;IAEE,gCAAA;EtEiqQR;EsE/pQM;;IAEE,iCAAA;EtEiqQR;EsE/pQM;;IAEE,+BAAA;EtEiqQR;EsEhrQM;IAAgC,wBAAA;EtEmrQtC;EsElrQM;;IAEE,4BAAA;EtEorQR;EsElrQM;;IAEE,8BAAA;EtEorQR;EsElrQM;;IAEE,+BAAA;EtEorQR;EsElrQM;;IAEE,6BAAA;EtEorQR;EsEnsQM;IAAgC,0BAAA;EtEssQtC;EsErsQM;;IAEE,8BAAA;EtEusQR;EsErsQM;;IAEE,gCAAA;EtEusQR;EsErsQM;;IAEE,iCAAA;EtEusQR;EsErsQM;;IAEE,+BAAA;EtEusQR;EsEttQM;IAAgC,wBAAA;EtEytQtC;EsExtQM;;IAEE,4BAAA;EtE0tQR;EsExtQM;;IAEE,8BAAA;EtE0tQR;EsExtQM;;IAEE,+BAAA;EtE0tQR;EsExtQM;;IAEE,6BAAA;EtE0tQR;EsEltQM;IAAwB,2BAAA;EtEqtQ9B;EsEptQM;;IAEE,+BAAA;EtEstQR;EsEptQM;;IAEE,iCAAA;EtEstQR;EsEptQM;;IAEE,kCAAA;EtEstQR;EsEptQM;;IAEE,gCAAA;EtEstQR;EsEruQM;IAAwB,0BAAA;EtEwuQ9B;EsEvuQM;;IAEE,8BAAA;EtEyuQR;EsEvuQM;;IAEE,gCAAA;EtEyuQR;EsEvuQM;;IAEE,iCAAA;EtEyuQR;EsEvuQM;;IAEE,+BAAA;EtEyuQR;EsExvQM;IAAwB,wBAAA;EtE2vQ9B;EsE1vQM;;IAEE,4BAAA;EtE4vQR;EsE1vQM;;IAEE,8BAAA;EtE4vQR;EsE1vQM;;IAEE,+BAAA;EtE4vQR;EsE1vQM;;IAEE,6BAAA;EtE4vQR;EsE3wQM;IAAwB,0BAAA;EtE8wQ9B;EsE7wQM;;IAEE,8BAAA;EtE+wQR;EsE7wQM;;IAEE,gCAAA;EtE+wQR;EsE7wQM;;IAEE,iCAAA;EtE+wQR;EsE7wQM;;IAEE,+BAAA;EtE+wQR;EsE9xQM;IAAwB,wBAAA;EtEiyQ9B;EsEhyQM;;IAEE,4BAAA;EtEkyQR;EsEhyQM;;IAEE,8BAAA;EtEkyQR;EsEhyQM;;IAEE,+BAAA;EtEkyQR;EsEhyQM;;IAEE,6BAAA;EtEkyQR;EsE5xQE;IAAmB,uBAAA;EtE+xQrB;EsE9xQE;;IAEE,2BAAA;EtEgyQJ;EsE9xQE;;IAEE,6BAAA;EtEgyQJ;EsE9xQE;;IAEE,8BAAA;EtEgyQJ;EsE9xQE;;IAEE,4BAAA;EtEgyQJ;AACF;Ac1yQI;EwDlDI;IAAgC,oBAAA;EtEg2QtC;EsE/1QM;;IAEE,wBAAA;EtEi2QR;EsE/1QM;;IAEE,0BAAA;EtEi2QR;EsE/1QM;;IAEE,2BAAA;EtEi2QR;EsE/1QM;;IAEE,yBAAA;EtEi2QR;EsEh3QM;IAAgC,0BAAA;EtEm3QtC;EsEl3QM;;IAEE,8BAAA;EtEo3QR;EsEl3QM;;IAEE,gCAAA;EtEo3QR;EsEl3QM;;IAEE,iCAAA;EtEo3QR;EsEl3QM;;IAEE,+BAAA;EtEo3QR;EsEn4QM;IAAgC,yBAAA;EtEs4QtC;EsEr4QM;;IAEE,6BAAA;EtEu4QR;EsEr4QM;;IAEE,+BAAA;EtEu4QR;EsEr4QM;;IAEE,gCAAA;EtEu4QR;EsEr4QM;;IAEE,8BAAA;EtEu4QR;EsEt5QM;IAAgC,uBAAA;EtEy5QtC;EsEx5QM;;IAEE,2BAAA;EtE05QR;EsEx5QM;;IAEE,6BAAA;EtE05QR;EsEx5QM;;IAEE,8BAAA;EtE05QR;EsEx5QM;;IAEE,4BAAA;EtE05QR;EsEz6QM;IAAgC,yBAAA;EtE46QtC;EsE36QM;;IAEE,6BAAA;EtE66QR;EsE36QM;;IAEE,+BAAA;EtE66QR;EsE36QM;;IAEE,gCAAA;EtE66QR;EsE36QM;;IAEE,8BAAA;EtE66QR;EsE57QM;IAAgC,uBAAA;EtE+7QtC;EsE97QM;;IAEE,2BAAA;EtEg8QR;EsE97QM;;IAEE,6BAAA;EtEg8QR;EsE97QM;;IAEE,8BAAA;EtEg8QR;EsE97QM;;IAEE,4BAAA;EtEg8QR;EsE/8QM;IAAgC,qBAAA;EtEk9QtC;EsEj9QM;;IAEE,yBAAA;EtEm9QR;EsEj9QM;;IAEE,2BAAA;EtEm9QR;EsEj9QM;;IAEE,4BAAA;EtEm9QR;EsEj9QM;;IAEE,0BAAA;EtEm9QR;EsEl+QM;IAAgC,2BAAA;EtEq+QtC;EsEp+QM;;IAEE,+BAAA;EtEs+QR;EsEp+QM;;IAEE,iCAAA;EtEs+QR;EsEp+QM;;IAEE,kCAAA;EtEs+QR;EsEp+QM;;IAEE,gCAAA;EtEs+QR;EsEr/QM;IAAgC,0BAAA;EtEw/QtC;EsEv/QM;;IAEE,8BAAA;EtEy/QR;EsEv/QM;;IAEE,gCAAA;EtEy/QR;EsEv/QM;;IAEE,iCAAA;EtEy/QR;EsEv/QM;;IAEE,+BAAA;EtEy/QR;EsExgRM;IAAgC,wBAAA;EtE2gRtC;EsE1gRM;;IAEE,4BAAA;EtE4gRR;EsE1gRM;;IAEE,8BAAA;EtE4gRR;EsE1gRM;;IAEE,+BAAA;EtE4gRR;EsE1gRM;;IAEE,6BAAA;EtE4gRR;EsE3hRM;IAAgC,0BAAA;EtE8hRtC;EsE7hRM;;IAEE,8BAAA;EtE+hRR;EsE7hRM;;IAEE,gCAAA;EtE+hRR;EsE7hRM;;IAEE,iCAAA;EtE+hRR;EsE7hRM;;IAEE,+BAAA;EtE+hRR;EsE9iRM;IAAgC,wBAAA;EtEijRtC;EsEhjRM;;IAEE,4BAAA;EtEkjRR;EsEhjRM;;IAEE,8BAAA;EtEkjRR;EsEhjRM;;IAEE,+BAAA;EtEkjRR;EsEhjRM;;IAEE,6BAAA;EtEkjRR;EsE1iRM;IAAwB,2BAAA;EtE6iR9B;EsE5iRM;;IAEE,+BAAA;EtE8iRR;EsE5iRM;;IAEE,iCAAA;EtE8iRR;EsE5iRM;;IAEE,kCAAA;EtE8iRR;EsE5iRM;;IAEE,gCAAA;EtE8iRR;EsE7jRM;IAAwB,0BAAA;EtEgkR9B;EsE/jRM;;IAEE,8BAAA;EtEikRR;EsE/jRM;;IAEE,gCAAA;EtEikRR;EsE/jRM;;IAEE,iCAAA;EtEikRR;EsE/jRM;;IAEE,+BAAA;EtEikRR;EsEhlRM;IAAwB,wBAAA;EtEmlR9B;EsEllRM;;IAEE,4BAAA;EtEolRR;EsEllRM;;IAEE,8BAAA;EtEolRR;EsEllRM;;IAEE,+BAAA;EtEolRR;EsEllRM;;IAEE,6BAAA;EtEolRR;EsEnmRM;IAAwB,0BAAA;EtEsmR9B;EsErmRM;;IAEE,8BAAA;EtEumRR;EsErmRM;;IAEE,gCAAA;EtEumRR;EsErmRM;;IAEE,iCAAA;EtEumRR;EsErmRM;;IAEE,+BAAA;EtEumRR;EsEtnRM;IAAwB,wBAAA;EtEynR9B;EsExnRM;;IAEE,4BAAA;EtE0nRR;EsExnRM;;IAEE,8BAAA;EtE0nRR;EsExnRM;;IAEE,+BAAA;EtE0nRR;EsExnRM;;IAEE,6BAAA;EtE0nRR;EsEpnRE;IAAmB,uBAAA;EtEunRrB;EsEtnRE;;IAEE,2BAAA;EtEwnRJ;EsEtnRE;;IAEE,6BAAA;EtEwnRJ;EsEtnRE;;IAEE,8BAAA;EtEwnRJ;EsEtnRE;;IAEE,4BAAA;EtEwnRJ;AACF;AuEzrRE;EACE,kBAAA;EACA,MAAA;EACA,QAAA;EACA,SAAA;EACA,OAAA;EACA,UAAA;EAEA,oBAAA;EACA,WAAA;EAEA,kCAAA;AvEyrRJ;;AwEnsRA;EAAkB,4GAAA;AxEusRlB;;AwEnsRA;EAAiB,8BAAA;AxEusRjB;;AwEtsRA;EAAiB,8BAAA;AxE0sRjB;;AwEzsRA;EAAiB,8BAAA;AxE6sRjB;;AwE5sRA;ECTE,gBAAA;EACA,uBAAA;EACA,mBAAA;AzEytRF;;AwE1sRI;EAAwB,2BAAA;AxE8sR5B;;AwE7sRI;EAAwB,4BAAA;AxEitR5B;;AwEhtRI;EAAwB,6BAAA;AxEotR5B;;Ac/qRI;E0DvCA;IAAwB,2BAAA;ExE2tR1B;EwE1tRE;IAAwB,4BAAA;ExE6tR1B;EwE5tRE;IAAwB,6BAAA;ExE+tR1B;AACF;Ac3rRI;E0DvCA;IAAwB,2BAAA;ExEsuR1B;EwEruRE;IAAwB,4BAAA;ExEwuR1B;EwEvuRE;IAAwB,6BAAA;ExE0uR1B;AACF;ActsRI;E0DvCA;IAAwB,2BAAA;ExEivR1B;EwEhvRE;IAAwB,4BAAA;ExEmvR1B;EwElvRE;IAAwB,6BAAA;ExEqvR1B;AACF;AcjtRI;E0DvCA;IAAwB,2BAAA;ExE4vR1B;EwE3vRE;IAAwB,4BAAA;ExE8vR1B;EwE7vRE;IAAwB,6BAAA;ExEgwR1B;AACF;AwE3vRA;EAAmB,oCAAA;AxE8vRnB;;AwE7vRA;EAAmB,oCAAA;AxEiwRnB;;AwEhwRA;EAAmB,qCAAA;AxEowRnB;;AwEhwRA;EAAuB,2BAAA;AxEowRvB;;AwEnwRA;EAAuB,+BAAA;AxEuwRvB;;AwEtwRA;EAAuB,2BAAA;AxE0wRvB;;AwEzwRA;EAAuB,2BAAA;AxE6wRvB;;AwE5wRA;EAAuB,8BAAA;AxEgxRvB;;AwE/wRA;EAAuB,6BAAA;AxEmxRvB;;AwE/wRA;EAAc,sBAAA;AxEmxRd;;A0E1zRE;EACE,yBAAA;A1E6zRJ;;AKnzRE;EqELM,yBAAA;A1E4zRR;;A0El0RE;EACE,yBAAA;A1Eq0RJ;;AK3zRE;EqELM,yBAAA;A1Eo0RR;;A0E10RE;EACE,yBAAA;A1E60RJ;;AKn0RE;EqELM,yBAAA;A1E40RR;;A0El1RE;EACE,yBAAA;A1Eq1RJ;;AK30RE;EqELM,yBAAA;A1Eo1RR;;A0E11RE;EACE,yBAAA;A1E61RJ;;AKn1RE;EqELM,yBAAA;A1E41RR;;A0El2RE;EACE,yBAAA;A1Eq2RJ;;AK31RE;EqELM,yBAAA;A1Eo2RR;;A0E12RE;EACE,yBAAA;A1E62RJ;;AKn2RE;EqELM,yBAAA;A1E42RR;;A0El3RE;EACE,yBAAA;A1Eq3RJ;;AK32RE;EqELM,yBAAA;A1Eo3RR;;AwE70RA;EAAa,yBAAA;AxEi1Rb;;AwEh1RA;EAAc,yBAAA;AxEo1Rd;;AwEl1RA;EAAiB,oCAAA;AxEs1RjB;;AwEr1RA;EAAiB,0CAAA;AxEy1RjB;;AwEr1RA;EGvDE,WAAA;EACA,kBAAA;EACA,iBAAA;EACA,6BAAA;EACA,SAAA;A3Eg5RF;;AwEz1RA;EAAwB,gCAAA;AxE61RxB;;AwE31RA;EACE,iCAAA;EACA,gCAAA;AxE81RF;;AwEz1RA;EAAc,yBAAA;AxE61Rd;;A4E95RA;EACE,8BAAA;A5Ei6RF;;A4E95RA;EACE,6BAAA;A5Ei6RF;;A6Ej6RE;EACE;;;IAKE,4BAAA;IAEA,2BAAA;E7Ei6RJ;E6E75RI;IACE,0BAAA;E7E+5RN;E6Et5RE;IACE,6BAAA;E7Ew5RJ;E6E14RE;IACE,gCAAA;E7E44RJ;E6E14RE;;IAEE,yBAAA;IACA,wBAAA;E7E44RJ;E6Ez4RE;;IAEE,wBAAA;E7E24RJ;E6Ex4RE;;;IAGE,UAAA;IACA,SAAA;E7E04RJ;E6Ev4RE;;IAEE,uBAAA;E7Ey4RJ;E6Ej4RE;IACE,Q1E2iC8B;EHw1PlC;E6Ej4RE;IACE,2BAAA;E7Em4RJ;E6Ej4RE;IACE,2BAAA;E7Em4RJ;E6E/3RE;IACE,aAAA;E7Ei4RJ;E6E/3RE;IACE,sBAAA;E7Ei4RJ;E6E93RE;IACE,oCAAA;E7Eg4RJ;E6E93RI;;IAEE,iCAAA;E7Eg4RN;E6E33RI;;IAEE,oCAAA;E7E63RN;E6Ez3RE;IACE,cAAA;E7E23RJ;E6Ez3RI;;;;IAIE,qB1E9GG;EHy+RT;E6Ev3RE;IACE,cAAA;IACA,qB1EpHK;EH6+RT;AACF","sourcesContent":["/*!\n * Bootstrap v4.6.2 (https://getbootstrap.com/)\n * Copyright 2011-2022 The Bootstrap Authors\n * Copyright 2011-2022 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n */\n\n@import \"functions\";\n@import \"variables\";\n@import \"mixins\";\n@import \"root\";\n@import \"reboot\";\n@import \"type\";\n@import \"images\";\n@import \"code\";\n@import \"grid\";\n@import \"tables\";\n@import \"forms\";\n@import \"buttons\";\n@import \"transitions\";\n@import \"dropdown\";\n@import \"button-group\";\n@import \"input-group\";\n@import \"custom-forms\";\n@import \"nav\";\n@import \"navbar\";\n@import \"card\";\n@import \"breadcrumb\";\n@import \"pagination\";\n@import \"badge\";\n@import \"jumbotron\";\n@import \"alert\";\n@import \"progress\";\n@import \"media\";\n@import \"list-group\";\n@import \"close\";\n@import \"toasts\";\n@import \"modal\";\n@import \"tooltip\";\n@import \"popover\";\n@import \"carousel\";\n@import \"spinners\";\n@import \"utilities\";\n@import \"print\";\n",":root {\n // Custom variable values only support SassScript inside `#{}`.\n @each $color, $value in $colors {\n --#{$color}: #{$value};\n }\n\n @each $color, $value in $theme-colors {\n --#{$color}: #{$value};\n }\n\n @each $bp, $value in $grid-breakpoints {\n --breakpoint-#{$bp}: #{$value};\n }\n\n // Use `inspect` for lists so that quoted items keep the quotes.\n // See https://github.com/sass/sass/issues/2383#issuecomment-336349172\n --font-family-sans-serif: #{inspect($font-family-sans-serif)};\n --font-family-monospace: #{inspect($font-family-monospace)};\n}\n","// stylelint-disable declaration-no-important, selector-no-qualifying-type, property-no-vendor-prefix\n\n// Reboot\n//\n// Normalization of HTML elements, manually forked from Normalize.css to remove\n// styles targeting irrelevant browsers while applying new styles.\n//\n// Normalize is licensed MIT. https://github.com/necolas/normalize.css\n\n\n// Document\n//\n// 1. Change from `box-sizing: content-box` so that `width` is not affected by `padding` or `border`.\n// 2. Change the default font family in all browsers.\n// 3. Correct the line height in all browsers.\n// 4. Prevent adjustments of font size after orientation changes in IE on Windows Phone and in iOS.\n// 5. Change the default tap highlight to be completely transparent in iOS.\n\n*,\n*::before,\n*::after {\n box-sizing: border-box; // 1\n}\n\nhtml {\n font-family: sans-serif; // 2\n line-height: 1.15; // 3\n -webkit-text-size-adjust: 100%; // 4\n -webkit-tap-highlight-color: rgba($black, 0); // 5\n}\n\n// Shim for \"new\" HTML5 structural elements to display correctly (IE10, older browsers)\n// TODO: remove in v5\n// stylelint-disable-next-line selector-list-comma-newline-after\narticle, aside, figcaption, figure, footer, header, hgroup, main, nav, section {\n display: block;\n}\n\n// Body\n//\n// 1. Remove the margin in all browsers.\n// 2. As a best practice, apply a default `background-color`.\n// 3. Set an explicit initial text-align value so that we can later use\n// the `inherit` value on things like `` elements.\n\nbody {\n margin: 0; // 1\n font-family: $font-family-base;\n @include font-size($font-size-base);\n font-weight: $font-weight-base;\n line-height: $line-height-base;\n color: $body-color;\n text-align: left; // 3\n background-color: $body-bg; // 2\n}\n\n// Future-proof rule: in browsers that support :focus-visible, suppress the focus outline\n// on elements that programmatically receive focus but wouldn't normally show a visible\n// focus outline. In general, this would mean that the outline is only applied if the\n// interaction that led to the element receiving programmatic focus was a keyboard interaction,\n// or the browser has somehow determined that the user is primarily a keyboard user and/or\n// wants focus outlines to always be presented.\n//\n// See https://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible\n// and https://developer.paciellogroup.com/blog/2018/03/focus-visible-and-backwards-compatibility/\n[tabindex=\"-1\"]:focus:not(:focus-visible) {\n outline: 0 !important;\n}\n\n\n// Content grouping\n//\n// 1. Add the correct box sizing in Firefox.\n// 2. Show the overflow in Edge and IE.\n\nhr {\n box-sizing: content-box; // 1\n height: 0; // 1\n overflow: visible; // 2\n}\n\n\n//\n// Typography\n//\n\n// Remove top margins from headings\n//\n// By default, `

`-`

` all receive top and bottom margins. We nuke the top\n// margin for easier control within type scales as it avoids margin collapsing.\n// stylelint-disable-next-line selector-list-comma-newline-after\nh1, h2, h3, h4, h5, h6 {\n margin-top: 0;\n margin-bottom: $headings-margin-bottom;\n}\n\n// Reset margins on paragraphs\n//\n// Similarly, the top margin on `

`s get reset. However, we also reset the\n// bottom margin to use `rem` units instead of `em`.\np {\n margin-top: 0;\n margin-bottom: $paragraph-margin-bottom;\n}\n\n// Abbreviations\n//\n// 1. Duplicate behavior to the data-* attribute for our tooltip plugin\n// 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.\n// 3. Add explicit cursor to indicate changed behavior.\n// 4. Remove the bottom border in Firefox 39-.\n// 5. Prevent the text-decoration to be skipped.\n\nabbr[title],\nabbr[data-original-title] { // 1\n text-decoration: underline; // 2\n text-decoration: underline dotted; // 2\n cursor: help; // 3\n border-bottom: 0; // 4\n text-decoration-skip-ink: none; // 5\n}\n\naddress {\n margin-bottom: 1rem;\n font-style: normal;\n line-height: inherit;\n}\n\nol,\nul,\ndl {\n margin-top: 0;\n margin-bottom: 1rem;\n}\n\nol ol,\nul ul,\nol ul,\nul ol {\n margin-bottom: 0;\n}\n\ndt {\n font-weight: $dt-font-weight;\n}\n\ndd {\n margin-bottom: .5rem;\n margin-left: 0; // Undo browser default\n}\n\nblockquote {\n margin: 0 0 1rem;\n}\n\nb,\nstrong {\n font-weight: $font-weight-bolder; // Add the correct font weight in Chrome, Edge, and Safari\n}\n\nsmall {\n @include font-size(80%); // Add the correct font size in all browsers\n}\n\n//\n// Prevent `sub` and `sup` elements from affecting the line height in\n// all browsers.\n//\n\nsub,\nsup {\n position: relative;\n @include font-size(75%);\n line-height: 0;\n vertical-align: baseline;\n}\n\nsub { bottom: -.25em; }\nsup { top: -.5em; }\n\n\n//\n// Links\n//\n\na {\n color: $link-color;\n text-decoration: $link-decoration;\n background-color: transparent; // Remove the gray background on active links in IE 10.\n\n @include hover() {\n color: $link-hover-color;\n text-decoration: $link-hover-decoration;\n }\n}\n\n// And undo these styles for placeholder links/named anchors (without href).\n// It would be more straightforward to just use a[href] in previous block, but that\n// causes specificity issues in many other styles that are too complex to fix.\n// See https://github.com/twbs/bootstrap/issues/19402\n\na:not([href]):not([class]) {\n color: inherit;\n text-decoration: none;\n\n @include hover() {\n color: inherit;\n text-decoration: none;\n }\n}\n\n\n//\n// Code\n//\n\npre,\ncode,\nkbd,\nsamp {\n font-family: $font-family-monospace;\n @include font-size(1em); // Correct the odd `em` font sizing in all browsers.\n}\n\npre {\n // Remove browser default top margin\n margin-top: 0;\n // Reset browser default of `1em` to use `rem`s\n margin-bottom: 1rem;\n // Don't allow content to break outside\n overflow: auto;\n // Disable auto-hiding scrollbar in IE & legacy Edge to avoid overlap,\n // making it impossible to interact with the content\n -ms-overflow-style: scrollbar;\n}\n\n\n//\n// Figures\n//\n\nfigure {\n // Apply a consistent margin strategy (matches our type styles).\n margin: 0 0 1rem;\n}\n\n\n//\n// Images and content\n//\n\nimg {\n vertical-align: middle;\n border-style: none; // Remove the border on images inside links in IE 10-.\n}\n\nsvg {\n // Workaround for the SVG overflow bug in IE10/11 is still required.\n // See https://github.com/twbs/bootstrap/issues/26878\n overflow: hidden;\n vertical-align: middle;\n}\n\n\n//\n// Tables\n//\n\ntable {\n border-collapse: collapse; // Prevent double borders\n}\n\ncaption {\n padding-top: $table-cell-padding;\n padding-bottom: $table-cell-padding;\n color: $table-caption-color;\n text-align: left;\n caption-side: bottom;\n}\n\n// 1. Removes font-weight bold by inheriting\n// 2. Matches default `` alignment by inheriting `text-align`.\n// 3. Fix alignment for Safari\n\nth {\n font-weight: $table-th-font-weight; // 1\n text-align: inherit; // 2\n text-align: -webkit-match-parent; // 3\n}\n\n\n//\n// Forms\n//\n\nlabel {\n // Allow labels to use `margin` for spacing.\n display: inline-block;\n margin-bottom: $label-margin-bottom;\n}\n\n// Remove the default `border-radius` that macOS Chrome adds.\n//\n// Details at https://github.com/twbs/bootstrap/issues/24093\nbutton {\n // stylelint-disable-next-line property-disallowed-list\n border-radius: 0;\n}\n\n// Explicitly remove focus outline in Chromium when it shouldn't be\n// visible (e.g. as result of mouse click or touch tap). It already\n// should be doing this automatically, but seems to currently be\n// confused and applies its very visible two-tone outline anyway.\n\nbutton:focus:not(:focus-visible) {\n outline: 0;\n}\n\ninput,\nbutton,\nselect,\noptgroup,\ntextarea {\n margin: 0; // Remove the margin in Firefox and Safari\n font-family: inherit;\n @include font-size(inherit);\n line-height: inherit;\n}\n\nbutton,\ninput {\n overflow: visible; // Show the overflow in Edge\n}\n\nbutton,\nselect {\n text-transform: none; // Remove the inheritance of text transform in Firefox\n}\n\n// Set the cursor for non-`