@fecp/designer 5.6.6 → 5.6.8

package/lib/node_modules/d3-shape/src/link/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const array = require("../array.js");
+const constant = require("../constant.js");
+const point = require("../point.js");
+const path = require("../../node_modules/d3-path/src/path.js");
+function linkSource(d) {
+  return d.source;
+}
+function linkTarget(d) {
+  return d.target;
+}
+function link(curve) {
+  var source = linkSource, target = linkTarget, x = point.x, y = point.y, context = null;
+  function link2() {
+    var buffer, argv = array.slice.call(arguments), s = source.apply(this, argv), t = target.apply(this, argv);
+    if (!context) context = buffer = path.default();
+    curve(context, +x.apply(this, (argv[0] = s, argv)), +y.apply(this, argv), +x.apply(this, (argv[0] = t, argv)), +y.apply(this, argv));
+    if (buffer) return context = null, buffer + "" || null;
+  }
+  link2.source = function(_) {
+    return arguments.length ? (source = _, link2) : source;
+  };
+  link2.target = function(_) {
+    return arguments.length ? (target = _, link2) : target;
+  };
+  link2.x = function(_) {
+    return arguments.length ? (x = typeof _ === "function" ? _ : constant.default(+_), link2) : x;
+  };
+  link2.y = function(_) {
+    return arguments.length ? (y = typeof _ === "function" ? _ : constant.default(+_), link2) : y;
+  };
+  link2.context = function(_) {
+    return arguments.length ? (context = _ == null ? null : _, link2) : context;
+  };
+  return link2;
+}
+function curveHorizontal(context, x0, y0, x1, y1) {
+  context.moveTo(x0, y0);
+  context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1);
+}
+function linkHorizontal() {
+  return link(curveHorizontal);
+}
+exports.linkHorizontal = linkHorizontal;

package/lib/node_modules/d3-shape/src/point.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function x(p) {
+  return p[0];
+}
+function y(p) {
+  return p[1];
+}
+exports.x = x;
+exports.y = y;

package/lib/node_modules/d3-time/src/day.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const duration = require("./duration.js");
+const timeDay = interval.timeInterval(
+  (date) => date.setHours(0, 0, 0, 0),
+  (date, step) => date.setDate(date.getDate() + step),
+  (start, end) => (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * duration.durationMinute) / duration.durationDay,
+  (date) => date.getDate() - 1
+);
+timeDay.range;
+const utcDay = interval.timeInterval((date) => {
+  date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setUTCDate(date.getUTCDate() + step);
+}, (start, end) => {
+  return (end - start) / duration.durationDay;
+}, (date) => {
+  return date.getUTCDate() - 1;
+});
+utcDay.range;
+const unixDay = interval.timeInterval((date) => {
+  date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setUTCDate(date.getUTCDate() + step);
+}, (start, end) => {
+  return (end - start) / duration.durationDay;
+}, (date) => {
+  return Math.floor(date / duration.durationDay);
+});
+unixDay.range;
+exports.timeDay = timeDay;
+exports.unixDay = unixDay;
+exports.utcDay = utcDay;

package/lib/node_modules/d3-time/src/duration.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const durationSecond = 1e3;
+const durationMinute = durationSecond * 60;
+const durationHour = durationMinute * 60;
+const durationDay = durationHour * 24;
+const durationWeek = durationDay * 7;
+const durationMonth = durationDay * 30;
+const durationYear = durationDay * 365;
+exports.durationDay = durationDay;
+exports.durationHour = durationHour;
+exports.durationMinute = durationMinute;
+exports.durationMonth = durationMonth;
+exports.durationSecond = durationSecond;
+exports.durationWeek = durationWeek;
+exports.durationYear = durationYear;

package/lib/node_modules/d3-time/src/hour.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const duration = require("./duration.js");
+const timeHour = interval.timeInterval((date) => {
+  date.setTime(date - date.getMilliseconds() - date.getSeconds() * duration.durationSecond - date.getMinutes() * duration.durationMinute);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationHour);
+}, (start, end) => {
+  return (end - start) / duration.durationHour;
+}, (date) => {
+  return date.getHours();
+});
+timeHour.range;
+const utcHour = interval.timeInterval((date) => {
+  date.setUTCMinutes(0, 0, 0);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationHour);
+}, (start, end) => {
+  return (end - start) / duration.durationHour;
+}, (date) => {
+  return date.getUTCHours();
+});
+utcHour.range;
+exports.timeHour = timeHour;
+exports.utcHour = utcHour;

package/lib/node_modules/d3-time/src/interval.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const t0 = /* @__PURE__ */ new Date(), t1 = /* @__PURE__ */ new Date();
+function timeInterval(floori, offseti, count, field) {
+  function interval(date) {
+    return floori(date = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+date)), date;
+  }
+  interval.floor = (date) => {
+    return floori(date = /* @__PURE__ */ new Date(+date)), date;
+  };
+  interval.ceil = (date) => {
+    return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
+  };
+  interval.round = (date) => {
+    const d0 = interval(date), d1 = interval.ceil(date);
+    return date - d0 < d1 - date ? d0 : d1;
+  };
+  interval.offset = (date, step) => {
+    return offseti(date = /* @__PURE__ */ new Date(+date), step == null ? 1 : Math.floor(step)), date;
+  };
+  interval.range = (start, stop, step) => {
+    const range = [];
+    start = interval.ceil(start);
+    step = step == null ? 1 : Math.floor(step);
+    if (!(start < stop) || !(step > 0)) return range;
+    let previous;
+    do
+      range.push(previous = /* @__PURE__ */ new Date(+start)), offseti(start, step), floori(start);
+    while (previous < start && start < stop);
+    return range;
+  };
+  interval.filter = (test) => {
+    return timeInterval((date) => {
+      if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
+    }, (date, step) => {
+      if (date >= date) {
+        if (step < 0) while (++step <= 0) {
+          while (offseti(date, -1), !test(date)) {
+          }
+        }
+        else while (--step >= 0) {
+          while (offseti(date, 1), !test(date)) {
+          }
+        }
+      }
+    });
+  };
+  if (count) {
+    interval.count = (start, end) => {
+      t0.setTime(+start), t1.setTime(+end);
+      floori(t0), floori(t1);
+      return Math.floor(count(t0, t1));
+    };
+    interval.every = (step) => {
+      step = Math.floor(step);
+      return !isFinite(step) || !(step > 0) ? null : !(step > 1) ? interval : interval.filter(field ? (d) => field(d) % step === 0 : (d) => interval.count(0, d) % step === 0);
+    };
+  }
+  return interval;
+}
+exports.timeInterval = timeInterval;

package/lib/node_modules/d3-time/src/millisecond.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const millisecond = interval.timeInterval(() => {
+}, (date, step) => {
+  date.setTime(+date + step);
+}, (start, end) => {
+  return end - start;
+});
+millisecond.every = (k) => {
+  k = Math.floor(k);
+  if (!isFinite(k) || !(k > 0)) return null;
+  if (!(k > 1)) return millisecond;
+  return interval.timeInterval((date) => {
+    date.setTime(Math.floor(date / k) * k);
+  }, (date, step) => {
+    date.setTime(+date + step * k);
+  }, (start, end) => {
+    return (end - start) / k;
+  });
+};
+millisecond.range;
+exports.millisecond = millisecond;

package/lib/node_modules/d3-time/src/minute.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const duration = require("./duration.js");
+const timeMinute = interval.timeInterval((date) => {
+  date.setTime(date - date.getMilliseconds() - date.getSeconds() * duration.durationSecond);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationMinute);
+}, (start, end) => {
+  return (end - start) / duration.durationMinute;
+}, (date) => {
+  return date.getMinutes();
+});
+timeMinute.range;
+const utcMinute = interval.timeInterval((date) => {
+  date.setUTCSeconds(0, 0);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationMinute);
+}, (start, end) => {
+  return (end - start) / duration.durationMinute;
+}, (date) => {
+  return date.getUTCMinutes();
+});
+utcMinute.range;
+exports.timeMinute = timeMinute;
+exports.utcMinute = utcMinute;

package/lib/node_modules/d3-time/src/month.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const timeMonth = interval.timeInterval((date) => {
+  date.setDate(1);
+  date.setHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setMonth(date.getMonth() + step);
+}, (start, end) => {
+  return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+}, (date) => {
+  return date.getMonth();
+});
+timeMonth.range;
+const utcMonth = interval.timeInterval((date) => {
+  date.setUTCDate(1);
+  date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setUTCMonth(date.getUTCMonth() + step);
+}, (start, end) => {
+  return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+}, (date) => {
+  return date.getUTCMonth();
+});
+utcMonth.range;
+exports.timeMonth = timeMonth;
+exports.utcMonth = utcMonth;

package/lib/node_modules/d3-time/src/second.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const duration = require("./duration.js");
+const second = interval.timeInterval((date) => {
+  date.setTime(date - date.getMilliseconds());
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationSecond);
+}, (start, end) => {
+  return (end - start) / duration.durationSecond;
+}, (date) => {
+  return date.getUTCSeconds();
+});
+second.range;
+exports.second = second;

package/lib/node_modules/d3-time/src/ticks.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const duration = require("./duration.js");
+const millisecond = require("./millisecond.js");
+const second = require("./second.js");
+const minute = require("./minute.js");
+const hour = require("./hour.js");
+const day = require("./day.js");
+const week = require("./week.js");
+const month = require("./month.js");
+const year = require("./year.js");
+const bisector = require("../../d3-array/src/bisector.js");
+const ticks = require("../../d3-array/src/ticks.js");
+function ticker(year2, month2, week2, day2, hour2, minute2) {
+  const tickIntervals = [
+    [second.second, 1, duration.durationSecond],
+    [second.second, 5, 5 * duration.durationSecond],
+    [second.second, 15, 15 * duration.durationSecond],
+    [second.second, 30, 30 * duration.durationSecond],
+    [minute2, 1, duration.durationMinute],
+    [minute2, 5, 5 * duration.durationMinute],
+    [minute2, 15, 15 * duration.durationMinute],
+    [minute2, 30, 30 * duration.durationMinute],
+    [hour2, 1, duration.durationHour],
+    [hour2, 3, 3 * duration.durationHour],
+    [hour2, 6, 6 * duration.durationHour],
+    [hour2, 12, 12 * duration.durationHour],
+    [day2, 1, duration.durationDay],
+    [day2, 2, 2 * duration.durationDay],
+    [week2, 1, duration.durationWeek],
+    [month2, 1, duration.durationMonth],
+    [month2, 3, 3 * duration.durationMonth],
+    [year2, 1, duration.durationYear]
+  ];
+  function ticks$1(start, stop, count) {
+    const reverse = stop < start;
+    if (reverse) [start, stop] = [stop, start];
+    const interval = count && typeof count.range === "function" ? count : tickInterval(start, stop, count);
+    const ticks2 = interval ? interval.range(start, +stop + 1) : [];
+    return reverse ? ticks2.reverse() : ticks2;
+  }
+  function tickInterval(start, stop, count) {
+    const target = Math.abs(stop - start) / count;
+    const i = bisector.default(([, , step2]) => step2).right(tickIntervals, target);
+    if (i === tickIntervals.length) return year2.every(ticks.tickStep(start / duration.durationYear, stop / duration.durationYear, count));
+    if (i === 0) return millisecond.millisecond.every(Math.max(ticks.tickStep(start, stop, count), 1));
+    const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
+    return t.every(step);
+  }
+  return [ticks$1, tickInterval];
+}
+const [timeTicks, timeTickInterval] = ticker(year.timeYear, month.timeMonth, week.timeSunday, day.timeDay, hour.timeHour, minute.timeMinute);
+exports.timeTickInterval = timeTickInterval;
+exports.timeTicks = timeTicks;

package/lib/node_modules/d3-time/src/week.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const duration = require("./duration.js");
+function timeWeekday(i) {
+  return interval.timeInterval((date) => {
+    date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
+    date.setHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setDate(date.getDate() + step * 7);
+  }, (start, end) => {
+    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * duration.durationMinute) / duration.durationWeek;
+  });
+}
+const timeSunday = timeWeekday(0);
+const timeMonday = timeWeekday(1);
+const timeTuesday = timeWeekday(2);
+const timeWednesday = timeWeekday(3);
+const timeThursday = timeWeekday(4);
+const timeFriday = timeWeekday(5);
+const timeSaturday = timeWeekday(6);
+timeSunday.range;
+timeMonday.range;
+timeTuesday.range;
+timeWednesday.range;
+timeThursday.range;
+timeFriday.range;
+timeSaturday.range;
+function utcWeekday(i) {
+  return interval.timeInterval((date) => {
+    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
+    date.setUTCHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setUTCDate(date.getUTCDate() + step * 7);
+  }, (start, end) => {
+    return (end - start) / duration.durationWeek;
+  });
+}
+const utcSunday = utcWeekday(0);
+const utcMonday = utcWeekday(1);
+const utcTuesday = utcWeekday(2);
+const utcWednesday = utcWeekday(3);
+const utcThursday = utcWeekday(4);
+const utcFriday = utcWeekday(5);
+const utcSaturday = utcWeekday(6);
+utcSunday.range;
+utcMonday.range;
+utcTuesday.range;
+utcWednesday.range;
+utcThursday.range;
+utcFriday.range;
+utcSaturday.range;
+exports.timeFriday = timeFriday;
+exports.timeMonday = timeMonday;
+exports.timeSaturday = timeSaturday;
+exports.timeSunday = timeSunday;
+exports.timeThursday = timeThursday;
+exports.timeTuesday = timeTuesday;
+exports.timeWednesday = timeWednesday;
+exports.utcFriday = utcFriday;
+exports.utcMonday = utcMonday;
+exports.utcSaturday = utcSaturday;
+exports.utcSunday = utcSunday;
+exports.utcThursday = utcThursday;
+exports.utcTuesday = utcTuesday;
+exports.utcWednesday = utcWednesday;

package/lib/node_modules/d3-time/src/year.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interval = require("./interval.js");
+const timeYear = interval.timeInterval((date) => {
+  date.setMonth(0, 1);
+  date.setHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setFullYear(date.getFullYear() + step);
+}, (start, end) => {
+  return end.getFullYear() - start.getFullYear();
+}, (date) => {
+  return date.getFullYear();
+});
+timeYear.every = (k) => {
+  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : interval.timeInterval((date) => {
+    date.setFullYear(Math.floor(date.getFullYear() / k) * k);
+    date.setMonth(0, 1);
+    date.setHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setFullYear(date.getFullYear() + step * k);
+  });
+};
+timeYear.range;
+const utcYear = interval.timeInterval((date) => {
+  date.setUTCMonth(0, 1);
+  date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setUTCFullYear(date.getUTCFullYear() + step);
+}, (start, end) => {
+  return end.getUTCFullYear() - start.getUTCFullYear();
+}, (date) => {
+  return date.getUTCFullYear();
+});
+utcYear.every = (k) => {
+  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : interval.timeInterval((date) => {
+    date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);
+    date.setUTCMonth(0, 1);
+    date.setUTCHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setUTCFullYear(date.getUTCFullYear() + step * k);
+  });
+};
+utcYear.range;
+exports.timeYear = timeYear;
+exports.utcYear = utcYear;

package/lib/node_modules/d3-time-format/src/defaultLocale.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const locale$1 = require("./locale.js");
+var locale;
+exports.timeFormat = void 0;
+defaultLocale({
+  dateTime: "%x, %X",
+  date: "%-m/%-d/%Y",
+  time: "%-I:%M:%S %p",
+  periods: ["AM", "PM"],
+  days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+  shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+  shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+});
+function defaultLocale(definition) {
+  locale = locale$1.default(definition);
+  exports.timeFormat = locale.format;
+  locale.parse;
+  locale.utcFormat;
+  locale.utcParse;
+  return locale;
+}
+exports.default = defaultLocale;