完成世界书、骰子、apiconfig页面处理

frontend/node_modules/d3-array/src/constant.js

@@ -0,0 +1,3 @@
+export default function constant(x) {
+  return () => x;
+}

frontend/node_modules/d3-array/src/cumsum.js

@@ -0,0 +1,6 @@
+export default function cumsum(values, valueof) {
+  var sum = 0, index = 0;
+  return Float64Array.from(values, valueof === undefined
+    ? v => (sum += +v || 0)
+    : v => (sum += +valueof(v, index++, values) || 0));
+}

frontend/node_modules/d3-array/src/filter.js

@@ -0,0 +1,11 @@
+export default function filter(values, test) {
+  if (typeof test !== "function") throw new TypeError("test is not a function");
+  const array = [];
+  let index = -1;
+  for (const value of values) {
+    if (test(value, ++index, values)) {
+      array.push(value);
+    }
+  }
+  return array;
+}

frontend/node_modules/d3-array/src/fsum.js

@@ -0,0 +1,69 @@
+// https://github.com/python/cpython/blob/a74eea238f5baba15797e2e8b570d153bc8690a7/Modules/mathmodule.c#L1423
+export class Adder {
+  constructor() {
+    this._partials = new Float64Array(32);
+    this._n = 0;
+  }
+  add(x) {
+    const p = this._partials;
+    let i = 0;
+    for (let j = 0; j < this._n && j < 32; j++) {
+      const y = p[j],
+        hi = x + y,
+        lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x);
+      if (lo) p[i++] = lo;
+      x = hi;
+    }
+    p[i] = x;
+    this._n = i + 1;
+    return this;
+  }
+  valueOf() {
+    const p = this._partials;
+    let n = this._n, x, y, lo, hi = 0;
+    if (n > 0) {
+      hi = p[--n];
+      while (n > 0) {
+        x = hi;
+        y = p[--n];
+        hi = x + y;
+        lo = y - (hi - x);
+        if (lo) break;
+      }
+      if (n > 0 && ((lo < 0 && p[n - 1] < 0) || (lo > 0 && p[n - 1] > 0))) {
+        y = lo * 2;
+        x = hi + y;
+        if (y == x - hi) hi = x;
+      }
+    }
+    return hi;
+  }
+}
+
+export function fsum(values, valueof) {
+  const adder = new Adder();
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value = +value) {
+        adder.add(value);
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if (value = +valueof(value, ++index, values)) {
+        adder.add(value);
+      }
+    }
+  }
+  return +adder;
+}
+
+export function fcumsum(values, valueof) {
+  const adder = new Adder();
+  let index = -1;
+  return Float64Array.from(values, valueof === undefined
+      ? v => adder.add(+v || 0)
+      : v => adder.add(+valueof(v, ++index, values) || 0)
+  );
+}

frontend/node_modules/d3-array/src/index.js

@@ -0,0 +1,57 @@
+export {default as bisect, bisectRight, bisectLeft, bisectCenter} from "./bisect.js";
+export {default as ascending} from "./ascending.js";
+export {default as bisector} from "./bisector.js";
+export {blur, blur2, blurImage} from "./blur.js";
+export {default as count} from "./count.js";
+export {default as cross} from "./cross.js";
+export {default as cumsum} from "./cumsum.js";
+export {default as descending} from "./descending.js";
+export {default as deviation} from "./deviation.js";
+export {default as extent} from "./extent.js";
+export {Adder, fsum, fcumsum} from "./fsum.js";
+export {default as group, flatGroup, flatRollup, groups, index, indexes, rollup, rollups} from "./group.js";
+export {default as groupSort} from "./groupSort.js";
+export {default as bin, default as histogram} from "./bin.js"; // Deprecated; use bin.
+export {default as thresholdFreedmanDiaconis} from "./threshold/freedmanDiaconis.js";
+export {default as thresholdScott} from "./threshold/scott.js";
+export {default as thresholdSturges} from "./threshold/sturges.js";
+export {default as max} from "./max.js";
+export {default as maxIndex} from "./maxIndex.js";
+export {default as mean} from "./mean.js";
+export {default as median, medianIndex} from "./median.js";
+export {default as merge} from "./merge.js";
+export {default as min} from "./min.js";
+export {default as minIndex} from "./minIndex.js";
+export {default as mode} from "./mode.js";
+export {default as nice} from "./nice.js";
+export {default as pairs} from "./pairs.js";
+export {default as permute} from "./permute.js";
+export {default as quantile, quantileIndex, quantileSorted} from "./quantile.js";
+export {default as quickselect} from "./quickselect.js";
+export {default as range} from "./range.js";
+export {default as rank} from "./rank.js";
+export {default as least} from "./least.js";
+export {default as leastIndex} from "./leastIndex.js";
+export {default as greatest} from "./greatest.js";
+export {default as greatestIndex} from "./greatestIndex.js";
+export {default as scan} from "./scan.js"; // Deprecated; use leastIndex.
+export {default as shuffle, shuffler} from "./shuffle.js";
+export {default as sum} from "./sum.js";
+export {default as ticks, tickIncrement, tickStep} from "./ticks.js";
+export {default as transpose} from "./transpose.js";
+export {default as variance} from "./variance.js";
+export {default as zip} from "./zip.js";
+export {default as every} from "./every.js";
+export {default as some} from "./some.js";
+export {default as filter} from "./filter.js";
+export {default as map} from "./map.js";
+export {default as reduce} from "./reduce.js";
+export {default as reverse} from "./reverse.js";
+export {default as sort} from "./sort.js";
+export {default as difference} from "./difference.js";
+export {default as disjoint} from "./disjoint.js";
+export {default as intersection} from "./intersection.js";
+export {default as subset} from "./subset.js";
+export {default as superset} from "./superset.js";
+export {default as union} from "./union.js";
+export {InternMap, InternSet} from "internmap";

frontend/node_modules/d3-array/src/leastIndex.js

@@ -0,0 +1,19 @@
+import ascending from "./ascending.js";
+import minIndex from "./minIndex.js";
+
+export default function leastIndex(values, compare = ascending) {
+  if (compare.length === 1) return minIndex(values, compare);
+  let minValue;
+  let min = -1;
+  let index = -1;
+  for (const value of values) {
+    ++index;
+    if (min < 0
+        ? compare(value, value) === 0
+        : compare(value, minValue) < 0) {
+      minValue = value;
+      min = index;
+    }
+  }
+  return min;
+}

frontend/node_modules/d3-array/src/map.js

@@ -0,0 +1,5 @@
+export default function map(values, mapper) {
+  if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
+  if (typeof mapper !== "function") throw new TypeError("mapper is not a function");
+  return Array.from(values, (value, index) => mapper(value, index, values));
+}

frontend/node_modules/d3-array/src/number.js

@@ -0,0 +1,20 @@
+export default function number(x) {
+  return x === null ? NaN : +x;
+}
+
+export function* numbers(values, valueof) {
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value != null && (value = +value) >= value) {
+        yield value;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+        yield value;
+      }
+    }
+  }
+}

frontend/node_modules/d3-array/src/pairs.js

@@ -0,0 +1,15 @@
+export default function pairs(values, pairof = pair) {
+  const pairs = [];
+  let previous;
+  let first = false;
+  for (const value of values) {
+    if (first) pairs.push(pairof(previous, value));
+    previous = value;
+    first = true;
+  }
+  return pairs;
+}
+
+export function pair(a, b) {
+  return [a, b];
+}

frontend/node_modules/d3-array/src/scan.js

@@ -0,0 +1,6 @@
+import leastIndex from "./leastIndex.js";
+
+export default function scan(values, compare) {
+  const index = leastIndex(values, compare);
+  return index < 0 ? undefined : index;
+}

frontend/node_modules/d3-array/src/some.js

@@ -0,0 +1,10 @@
+export default function some(values, test) {
+  if (typeof test !== "function") throw new TypeError("test is not a function");
+  let index = -1;
+  for (const value of values) {
+    if (test(value, ++index, values)) {
+      return true;
+    }
+  }
+  return false;
+}

frontend/node_modules/d3-array/src/subset.js

@@ -0,0 +1,5 @@
+import superset from "./superset.js";
+
+export default function subset(values, other) {
+  return superset(other, values);
+}

frontend/node_modules/d3-array/src/threshold/freedmanDiaconis.js

@@ -0,0 +1,7 @@
+import count from "../count.js";
+import quantile from "../quantile.js";
+
+export default function thresholdFreedmanDiaconis(values, min, max) {
+  const c = count(values), d = quantile(values, 0.75) - quantile(values, 0.25);
+  return c && d ? Math.ceil((max - min) / (2 * d * Math.pow(c, -1 / 3))) : 1;
+}

frontend/node_modules/d3-array/src/threshold/sturges.js

@@ -0,0 +1,5 @@
+import count from "../count.js";
+
+export default function thresholdSturges(values) {
+  return Math.max(1, Math.ceil(Math.log(count(values)) / Math.LN2) + 1);
+}

frontend/node_modules/d3-array/src/variance.js

@@ -0,0 +1,25 @@
+export default function variance(values, valueof) {
+  let count = 0;
+  let delta;
+  let mean = 0;
+  let sum = 0;
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value != null && (value = +value) >= value) {
+        delta = value - mean;
+        mean += delta / ++count;
+        sum += delta * (value - mean);
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+        delta = value - mean;
+        mean += delta / ++count;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+  if (count > 1) return sum / (count - 1);
+}

frontend/node_modules/d3-array/src/zip.js

@@ -0,0 +1,5 @@
+import transpose from "./transpose.js";
+
+export default function zip() {
+  return transpose(arguments);
+}