Updated 40 files, added 37 files, deleted 1103 files and renamed 3905 files (automated)

1 files changed, 294 insertions, 0 deletions

diff --git a/includes/external/school/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js b/includes/external/school/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js
new file mode 100644
index 0000000..03cc17b
--- /dev/null
+++ b/includes/external/school/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js
@@ -0,0 +1,294 @@
+/**
+ * @name ranges-apply
+ * @fileoverview Take an array of string index ranges, delete/replace the string according to them
+ * @version 5.1.0
+ * @author Roy Revelt, Codsen Ltd
+ * @license MIT
+ * {@link https://codsen.com/os/ranges-apply/}
+ */
+
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.rangesApply = {}));
+}(this, (function (exports) { 'use strict';
+
+/**
+ * @name ranges-sort
+ * @fileoverview Sort string index ranges
+ * @version 4.1.0
+ * @author Roy Revelt, Codsen Ltd
+ * @license MIT
+ * {@link https://codsen.com/os/ranges-sort/}
+ */
+const defaults$1 = {
+  strictlyTwoElementsInRangeArrays: false,
+  progressFn: null
+};
+function rSort(arrOfRanges, originalOptions) {
+  if (!Array.isArray(arrOfRanges) || !arrOfRanges.length) {
+    return arrOfRanges;
+  }
+  const opts = { ...defaults$1,
+    ...originalOptions
+  };
+  let culpritsIndex;
+  let culpritsLen;
+  if (opts.strictlyTwoElementsInRangeArrays && !arrOfRanges.filter(range => range).every((rangeArr, indx) => {
+    if (rangeArr.length !== 2) {
+      culpritsIndex = indx;
+      culpritsLen = rangeArr.length;
+      return false;
+    }
+    return true;
+  })) {
+    throw new TypeError(`ranges-sort: [THROW_ID_03] The first argument should be an array and must consist of arrays which are natural number indexes representing TWO string index ranges. However, ${culpritsIndex}th range (${JSON.stringify(arrOfRanges[culpritsIndex], null, 4)}) has not two but ${culpritsLen} elements!`);
+  }
+  if (!arrOfRanges.filter(range => range).every((rangeArr, indx) => {
+    if (!Number.isInteger(rangeArr[0]) || rangeArr[0] < 0 || !Number.isInteger(rangeArr[1]) || rangeArr[1] < 0) {
+      culpritsIndex = indx;
+      return false;
+    }
+    return true;
+  })) {
+    throw new TypeError(`ranges-sort: [THROW_ID_04] The first argument should be an array and must consist of arrays which are natural number indexes representing string index ranges. However, ${culpritsIndex}th range (${JSON.stringify(arrOfRanges[culpritsIndex], null, 4)}) does not consist of only natural numbers!`);
+  }
+  const maxPossibleIterations = arrOfRanges.filter(range => range).length ** 2;
+  let counter = 0;
+  return Array.from(arrOfRanges).filter(range => range).sort((range1, range2) => {
+    if (opts.progressFn) {
+      counter += 1;
+      opts.progressFn(Math.floor(counter * 100 / maxPossibleIterations));
+    }
+    if (range1[0] === range2[0]) {
+      if (range1[1] < range2[1]) {
+        return -1;
+      }
+      if (range1[1] > range2[1]) {
+        return 1;
+      }
+      return 0;
+    }
+    if (range1[0] < range2[0]) {
+      return -1;
+    }
+    return 1;
+  });
+}
+
+/**
+ * @name ranges-merge
+ * @fileoverview Merge and sort string index ranges
+ * @version 7.1.0
+ * @author Roy Revelt, Codsen Ltd
+ * @license MIT
+ * {@link https://codsen.com/os/ranges-merge/}
+ */
+const defaults = {
+  mergeType: 1,
+  progressFn: null,
+  joinRangesThatTouchEdges: true
+};
+function rMerge(arrOfRanges, originalOpts) {
+  function isObj(something) {
+    return something && typeof something === "object" && !Array.isArray(something);
+  }
+  if (!Array.isArray(arrOfRanges) || !arrOfRanges.length) {
+    return null;
+  }
+  let opts;
+  if (originalOpts) {
+    if (isObj(originalOpts)) {
+      opts = { ...defaults,
+        ...originalOpts
+      };
+      if (opts.progressFn && isObj(opts.progressFn) && !Object.keys(opts.progressFn).length) {
+        opts.progressFn = null;
+      } else if (opts.progressFn && typeof opts.progressFn !== "function") {
+        throw new Error(`ranges-merge: [THROW_ID_01] opts.progressFn must be a function! It was given of a type: "${typeof opts.progressFn}", equal to ${JSON.stringify(opts.progressFn, null, 4)}`);
+      }
+      if (opts.mergeType && +opts.mergeType !== 1 && +opts.mergeType !== 2) {
+        throw new Error(`ranges-merge: [THROW_ID_02] opts.mergeType was customised to a wrong thing! It was given of a type: "${typeof opts.mergeType}", equal to ${JSON.stringify(opts.mergeType, null, 4)}`);
+      }
+      if (typeof opts.joinRangesThatTouchEdges !== "boolean") {
+        throw new Error(`ranges-merge: [THROW_ID_04] opts.joinRangesThatTouchEdges was customised to a wrong thing! It was given of a type: "${typeof opts.joinRangesThatTouchEdges}", equal to ${JSON.stringify(opts.joinRangesThatTouchEdges, null, 4)}`);
+      }
+    } else {
+      throw new Error(`emlint: [THROW_ID_03] the second input argument must be a plain object. It was given as:\n${JSON.stringify(originalOpts, null, 4)} (type ${typeof originalOpts})`);
+    }
+  } else {
+    opts = { ...defaults
+    };
+  }
+  const filtered = arrOfRanges
+  .filter(range => range).map(subarr => [...subarr]).filter(
+  rangeArr => rangeArr[2] !== undefined || rangeArr[0] !== rangeArr[1]);
+  let sortedRanges;
+  let lastPercentageDone;
+  let percentageDone;
+  if (opts.progressFn) {
+    sortedRanges = rSort(filtered, {
+      progressFn: percentage => {
+        percentageDone = Math.floor(percentage / 5);
+        if (percentageDone !== lastPercentageDone) {
+          lastPercentageDone = percentageDone;
+          opts.progressFn(percentageDone);
+        }
+      }
+    });
+  } else {
+    sortedRanges = rSort(filtered);
+  }
+  if (!sortedRanges) {
+    return null;
+  }
+  const len = sortedRanges.length - 1;
+  for (let i = len; i > 0; i--) {
+    if (opts.progressFn) {
+      percentageDone = Math.floor((1 - i / len) * 78) + 21;
+      if (percentageDone !== lastPercentageDone && percentageDone > lastPercentageDone) {
+        lastPercentageDone = percentageDone;
+        opts.progressFn(percentageDone);
+      }
+    }
+    if (sortedRanges[i][0] <= sortedRanges[i - 1][0] || !opts.joinRangesThatTouchEdges && sortedRanges[i][0] < sortedRanges[i - 1][1] || opts.joinRangesThatTouchEdges && sortedRanges[i][0] <= sortedRanges[i - 1][1]) {
+      sortedRanges[i - 1][0] = Math.min(sortedRanges[i][0], sortedRanges[i - 1][0]);
+      sortedRanges[i - 1][1] = Math.max(sortedRanges[i][1], sortedRanges[i - 1][1]);
+      if (sortedRanges[i][2] !== undefined && (sortedRanges[i - 1][0] >= sortedRanges[i][0] || sortedRanges[i - 1][1] <= sortedRanges[i][1])) {
+        if (sortedRanges[i - 1][2] !== null) {
+          if (sortedRanges[i][2] === null && sortedRanges[i - 1][2] !== null) {
+            sortedRanges[i - 1][2] = null;
+          } else if (sortedRanges[i - 1][2] != null) {
+            if (+opts.mergeType === 2 && sortedRanges[i - 1][0] === sortedRanges[i][0]) {
+              sortedRanges[i - 1][2] = sortedRanges[i][2];
+            } else {
+              sortedRanges[i - 1][2] += sortedRanges[i][2];
+            }
+          } else {
+            sortedRanges[i - 1][2] = sortedRanges[i][2];
+          }
+        }
+      }
+      sortedRanges.splice(i, 1);
+      i = sortedRanges.length;
+    }
+  }
+  return sortedRanges.length ? sortedRanges : null;
+}
+
+var version$1 = "5.1.0";
+
+const version = version$1;
+function rApply(str, originalRangesArr, progressFn) {
+    let percentageDone = 0;
+    let lastPercentageDone = 0;
+    if (arguments.length === 0) {
+        throw new Error("ranges-apply: [THROW_ID_01] inputs missing!");
+    }
+    if (typeof str !== "string") {
+        throw new TypeError(`ranges-apply: [THROW_ID_02] first input argument must be a string! Currently it's: ${typeof str}, equal to: ${JSON.stringify(str, null, 4)}`);
+    }
+    if (originalRangesArr && !Array.isArray(originalRangesArr)) {
+        throw new TypeError(`ranges-apply: [THROW_ID_03] second input argument must be an array (or null)! Currently it's: ${typeof originalRangesArr}, equal to: ${JSON.stringify(originalRangesArr, null, 4)}`);
+    }
+    if (progressFn && typeof progressFn !== "function") {
+        throw new TypeError(`ranges-apply: [THROW_ID_04] the third input argument must be a function (or falsey)! Currently it's: ${typeof progressFn}, equal to: ${JSON.stringify(progressFn, null, 4)}`);
+    }
+    if (!originalRangesArr ||
+        !originalRangesArr.filter((range) => range).length) {
+        // quick ending - no ranges passed
+        return str;
+    }
+    let rangesArr;
+    if (Array.isArray(originalRangesArr) &&
+        Number.isInteger(originalRangesArr[0]) &&
+        Number.isInteger(originalRangesArr[1])) {
+        // if single array was passed, wrap it into an array
+        rangesArr = [Array.from(originalRangesArr)];
+    }
+    else {
+        rangesArr = Array.from(originalRangesArr);
+    }
+    // allocate first 10% of progress to this stage
+    const len = rangesArr.length;
+    let counter = 0;
+    rangesArr
+        .filter((range) => range)
+        .forEach((el, i) => {
+        if (progressFn) {
+            percentageDone = Math.floor((counter / len) * 10);
+            /* istanbul ignore else */
+            if (percentageDone !== lastPercentageDone) {
+                lastPercentageDone = percentageDone;
+                progressFn(percentageDone);
+            }
+        }
+        if (!Array.isArray(el)) {
+            throw new TypeError(`ranges-apply: [THROW_ID_05] ranges array, second input arg., has ${i}th element not an array: ${JSON.stringify(el, null, 4)}, which is ${typeof el}`);
+        }
+        if (!Number.isInteger(el[0])) {
+            if (!Number.isInteger(+el[0]) || +el[0] < 0) {
+                throw new TypeError(`ranges-apply: [THROW_ID_06] ranges array, second input arg. has ${i}th element, array ${JSON.stringify(el, null, 0)}. Its first element is not an integer, string index, but ${typeof el[0]}, equal to: ${JSON.stringify(el[0], null, 4)}.`);
+            }
+            else {
+                rangesArr[i][0] = +rangesArr[i][0];
+            }
+        }
+        if (!Number.isInteger(el[1])) {
+            if (!Number.isInteger(+el[1]) || +el[1] < 0) {
+                throw new TypeError(`ranges-apply: [THROW_ID_07] ranges array, second input arg. has ${i}th element, array ${JSON.stringify(el, null, 0)}. Its second element is not an integer, string index, but ${typeof el[1]}, equal to: ${JSON.stringify(el[1], null, 4)}.`);
+            }
+            else {
+                rangesArr[i][1] = +rangesArr[i][1];
+            }
+        }
+        counter += 1;
+    });
+    // allocate another 10% of the progress indicator length to the rangesMerge step:
+    const workingRanges = rMerge(rangesArr, {
+        progressFn: (perc) => {
+            if (progressFn) {
+                // since "perc" is already from zero to hundred, we just divide by 10 and
+                // get the range from zero to ten:
+                percentageDone = 10 + Math.floor(perc / 10);
+                /* istanbul ignore else */
+                if (percentageDone !== lastPercentageDone) {
+                    lastPercentageDone = percentageDone;
+                    progressFn(percentageDone);
+                }
+            }
+        },
+    });
+    // allocate the rest 80% to the actual string assembly:
+    const len2 = Array.isArray(workingRanges) ? workingRanges.length : 0;
+    /* istanbul ignore else */
+    if (len2 > 0) {
+        const tails = str.slice(workingRanges[len2 - 1][1]);
+        // eslint-disable-next-line no-param-reassign
+        str = workingRanges.reduce((acc, _val, i, arr) => {
+            if (progressFn) {
+                // since "perc" is already from zero to hundred, we just divide by 10 and
+                // get the range from zero to ten:
+                percentageDone = 20 + Math.floor((i / len2) * 80);
+                /* istanbul ignore else */
+                if (percentageDone !== lastPercentageDone) {
+                    lastPercentageDone = percentageDone;
+                    progressFn(percentageDone);
+                }
+            }
+            const beginning = i === 0 ? 0 : arr[i - 1][1];
+            const ending = arr[i][0];
+            return acc + str.slice(beginning, ending) + (arr[i][2] || "");
+        }, "");
+        // eslint-disable-next-line no-param-reassign
+        str += tails;
+    }
+    return str;
+}
+
+exports.rApply = rApply;
+exports.version = version;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));