feelin 4.3.0 → 7.0.1

data/lib/feelin/js/node_modules/luxon/src/errors.js

@@ -1,61 +0,0 @@
-// these aren't really private, but nor are they really useful to document
-
-/**
- * @private
- */
-class LuxonError extends Error {}
-
-/**
- * @private
- */
-export class InvalidDateTimeError extends LuxonError {
-  constructor(reason) {
-    super(`Invalid DateTime: ${reason.toMessage()}`);
-  }
-}
-
-/**
- * @private
- */
-export class InvalidIntervalError extends LuxonError {
-  constructor(reason) {
-    super(`Invalid Interval: ${reason.toMessage()}`);
-  }
-}
-
-/**
- * @private
- */
-export class InvalidDurationError extends LuxonError {
-  constructor(reason) {
-    super(`Invalid Duration: ${reason.toMessage()}`);
-  }
-}
-
-/**
- * @private
- */
-export class ConflictingSpecificationError extends LuxonError {}
-
-/**
- * @private
- */
-export class InvalidUnitError extends LuxonError {
-  constructor(unit) {
-    super(`Invalid unit ${unit}`);
-  }
-}
-
-/**
- * @private
- */
-export class InvalidArgumentError extends LuxonError {}
-
-/**
- * @private
- */
-export class ZoneIsAbstractError extends LuxonError {
-  constructor() {
-    super("Zone is an abstract class");
-  }
-}

data/lib/feelin/js/node_modules/luxon/src/impl/conversions.js

@@ -1,206 +0,0 @@
-import {
-  integerBetween,
-  isLeapYear,
-  timeObject,
-  daysInYear,
-  daysInMonth,
-  weeksInWeekYear,
-  isInteger,
-  isUndefined,
-} from "./util.js";
-import Invalid from "./invalid.js";
-import { ConflictingSpecificationError } from "../errors.js";
-
-const nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
-  leapLadder = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
-
-function unitOutOfRange(unit, value) {
-  return new Invalid(
-    "unit out of range",
-    `you specified ${value} (of type ${typeof value}) as a ${unit}, which is invalid`
-  );
-}
-
-export function dayOfWeek(year, month, day) {
-  const d = new Date(Date.UTC(year, month - 1, day));
-
-  if (year < 100 && year >= 0) {
-    d.setUTCFullYear(d.getUTCFullYear() - 1900);
-  }
-
-  const js = d.getUTCDay();
-
-  return js === 0 ? 7 : js;
-}
-
-function computeOrdinal(year, month, day) {
-  return day + (isLeapYear(year) ? leapLadder : nonLeapLadder)[month - 1];
-}
-
-function uncomputeOrdinal(year, ordinal) {
-  const table = isLeapYear(year) ? leapLadder : nonLeapLadder,
-    month0 = table.findIndex((i) => i < ordinal),
-    day = ordinal - table[month0];
-  return { month: month0 + 1, day };
-}
-
-export function isoWeekdayToLocal(isoWeekday, startOfWeek) {
-  return ((isoWeekday - startOfWeek + 7) % 7) + 1;
-}
-
-/**
- * @private
- */
-
-export function gregorianToWeek(gregObj, minDaysInFirstWeek = 4, startOfWeek = 1) {
-  const { year, month, day } = gregObj,
-    ordinal = computeOrdinal(year, month, day),
-    weekday = isoWeekdayToLocal(dayOfWeek(year, month, day), startOfWeek);
-
-  let weekNumber = Math.floor((ordinal - weekday + 14 - minDaysInFirstWeek) / 7),
-    weekYear;
-
-  if (weekNumber < 1) {
-    weekYear = year - 1;
-    weekNumber = weeksInWeekYear(weekYear, minDaysInFirstWeek, startOfWeek);
-  } else if (weekNumber > weeksInWeekYear(year, minDaysInFirstWeek, startOfWeek)) {
-    weekYear = year + 1;
-    weekNumber = 1;
-  } else {
-    weekYear = year;
-  }
-
-  return { weekYear, weekNumber, weekday, ...timeObject(gregObj) };
-}
-
-export function weekToGregorian(weekData, minDaysInFirstWeek = 4, startOfWeek = 1) {
-  const { weekYear, weekNumber, weekday } = weekData,
-    weekdayOfJan4 = isoWeekdayToLocal(dayOfWeek(weekYear, 1, minDaysInFirstWeek), startOfWeek),
-    yearInDays = daysInYear(weekYear);
-
-  let ordinal = weekNumber * 7 + weekday - weekdayOfJan4 - 7 + minDaysInFirstWeek,
-    year;
-
-  if (ordinal < 1) {
-    year = weekYear - 1;
-    ordinal += daysInYear(year);
-  } else if (ordinal > yearInDays) {
-    year = weekYear + 1;
-    ordinal -= daysInYear(weekYear);
-  } else {
-    year = weekYear;
-  }
-
-  const { month, day } = uncomputeOrdinal(year, ordinal);
-  return { year, month, day, ...timeObject(weekData) };
-}
-
-export function gregorianToOrdinal(gregData) {
-  const { year, month, day } = gregData;
-  const ordinal = computeOrdinal(year, month, day);
-  return { year, ordinal, ...timeObject(gregData) };
-}
-
-export function ordinalToGregorian(ordinalData) {
-  const { year, ordinal } = ordinalData;
-  const { month, day } = uncomputeOrdinal(year, ordinal);
-  return { year, month, day, ...timeObject(ordinalData) };
-}
-
-/**
- * Check if local week units like localWeekday are used in obj.
- * If so, validates that they are not mixed with ISO week units and then copies them to the normal week unit properties.
- * Modifies obj in-place!
- * @param obj the object values
- */
-export function usesLocalWeekValues(obj, loc) {
-  const hasLocaleWeekData =
-    !isUndefined(obj.localWeekday) ||
-    !isUndefined(obj.localWeekNumber) ||
-    !isUndefined(obj.localWeekYear);
-  if (hasLocaleWeekData) {
-    const hasIsoWeekData =
-      !isUndefined(obj.weekday) || !isUndefined(obj.weekNumber) || !isUndefined(obj.weekYear);
-
-    if (hasIsoWeekData) {
-      throw new ConflictingSpecificationError(
-        "Cannot mix locale-based week fields with ISO-based week fields"
-      );
-    }
-    if (!isUndefined(obj.localWeekday)) obj.weekday = obj.localWeekday;
-    if (!isUndefined(obj.localWeekNumber)) obj.weekNumber = obj.localWeekNumber;
-    if (!isUndefined(obj.localWeekYear)) obj.weekYear = obj.localWeekYear;
-    delete obj.localWeekday;
-    delete obj.localWeekNumber;
-    delete obj.localWeekYear;
-    return {
-      minDaysInFirstWeek: loc.getMinDaysInFirstWeek(),
-      startOfWeek: loc.getStartOfWeek(),
-    };
-  } else {
-    return { minDaysInFirstWeek: 4, startOfWeek: 1 };
-  }
-}
-
-export function hasInvalidWeekData(obj, minDaysInFirstWeek = 4, startOfWeek = 1) {
-  const validYear = isInteger(obj.weekYear),
-    validWeek = integerBetween(
-      obj.weekNumber,
-      1,
-      weeksInWeekYear(obj.weekYear, minDaysInFirstWeek, startOfWeek)
-    ),
-    validWeekday = integerBetween(obj.weekday, 1, 7);
-
-  if (!validYear) {
-    return unitOutOfRange("weekYear", obj.weekYear);
-  } else if (!validWeek) {
-    return unitOutOfRange("week", obj.weekNumber);
-  } else if (!validWeekday) {
-    return unitOutOfRange("weekday", obj.weekday);
-  } else return false;
-}
-
-export function hasInvalidOrdinalData(obj) {
-  const validYear = isInteger(obj.year),
-    validOrdinal = integerBetween(obj.ordinal, 1, daysInYear(obj.year));
-
-  if (!validYear) {
-    return unitOutOfRange("year", obj.year);
-  } else if (!validOrdinal) {
-    return unitOutOfRange("ordinal", obj.ordinal);
-  } else return false;
-}
-
-export function hasInvalidGregorianData(obj) {
-  const validYear = isInteger(obj.year),
-    validMonth = integerBetween(obj.month, 1, 12),
-    validDay = integerBetween(obj.day, 1, daysInMonth(obj.year, obj.month));
-
-  if (!validYear) {
-    return unitOutOfRange("year", obj.year);
-  } else if (!validMonth) {
-    return unitOutOfRange("month", obj.month);
-  } else if (!validDay) {
-    return unitOutOfRange("day", obj.day);
-  } else return false;
-}
-
-export function hasInvalidTimeData(obj) {
-  const { hour, minute, second, millisecond } = obj;
-  const validHour =
-      integerBetween(hour, 0, 23) ||
-      (hour === 24 && minute === 0 && second === 0 && millisecond === 0),
-    validMinute = integerBetween(minute, 0, 59),
-    validSecond = integerBetween(second, 0, 59),
-    validMillisecond = integerBetween(millisecond, 0, 999);
-
-  if (!validHour) {
-    return unitOutOfRange("hour", hour);
-  } else if (!validMinute) {
-    return unitOutOfRange("minute", minute);
-  } else if (!validSecond) {
-    return unitOutOfRange("second", second);
-  } else if (!validMillisecond) {
-    return unitOutOfRange("millisecond", millisecond);
-  } else return false;
-}

data/lib/feelin/js/node_modules/luxon/src/impl/diff.js

@@ -1,95 +0,0 @@
-import Duration from "../duration.js";
-
-function dayDiff(earlier, later) {
-  const utcDayStart = (dt) => dt.toUTC(0, { keepLocalTime: true }).startOf("day").valueOf(),
-    ms = utcDayStart(later) - utcDayStart(earlier);
-  return Math.floor(Duration.fromMillis(ms).as("days"));
-}
-
-function highOrderDiffs(cursor, later, units) {
-  const differs = [
-    ["years", (a, b) => b.year - a.year],
-    ["quarters", (a, b) => b.quarter - a.quarter + (b.year - a.year) * 4],
-    ["months", (a, b) => b.month - a.month + (b.year - a.year) * 12],
-    [
-      "weeks",
-      (a, b) => {
-        const days = dayDiff(a, b);
-        return (days - (days % 7)) / 7;
-      },
-    ],
-    ["days", dayDiff],
-  ];
-
-  const results = {};
-  const earlier = cursor;
-  let lowestOrder, highWater;
-
-  /* This loop tries to diff using larger units first.
-     If we overshoot, we backtrack and try the next smaller unit.
-     "cursor" starts out at the earlier timestamp and moves closer and closer to "later"
-     as we use smaller and smaller units.
-     highWater keeps track of where we would be if we added one more of the smallest unit,
-     this is used later to potentially convert any difference smaller than the smallest higher order unit
-     into a fraction of that smallest higher order unit
-  */
-  for (const [unit, differ] of differs) {
-    if (units.indexOf(unit) >= 0) {
-      lowestOrder = unit;
-
-      results[unit] = differ(cursor, later);
-      highWater = earlier.plus(results);
-
-      if (highWater > later) {
-        // we overshot the end point, backtrack cursor by 1
-        results[unit]--;
-        cursor = earlier.plus(results);
-
-        // if we are still overshooting now, we need to backtrack again
-        // this happens in certain situations when diffing times in different zones,
-        // because this calculation ignores time zones
-        if (cursor > later) {
-          // keep the "overshot by 1" around as highWater
-          highWater = cursor;
-          // backtrack cursor by 1
-          results[unit]--;
-          cursor = earlier.plus(results);
-        }
-      } else {
-        cursor = highWater;
-      }
-    }
-  }
-
-  return [cursor, results, highWater, lowestOrder];
-}
-
-export default function (earlier, later, units, opts) {
-  let [cursor, results, highWater, lowestOrder] = highOrderDiffs(earlier, later, units);
-
-  const remainingMillis = later - cursor;
-
-  const lowerOrderUnits = units.filter(
-    (u) => ["hours", "minutes", "seconds", "milliseconds"].indexOf(u) >= 0
-  );
-
-  if (lowerOrderUnits.length === 0) {
-    if (highWater < later) {
-      highWater = cursor.plus({ [lowestOrder]: 1 });
-    }
-
-    if (highWater !== cursor) {
-      results[lowestOrder] = (results[lowestOrder] || 0) + remainingMillis / (highWater - cursor);
-    }
-  }
-
-  const duration = Duration.fromObject(results, opts);
-
-  if (lowerOrderUnits.length > 0) {
-    return Duration.fromMillis(remainingMillis, opts)
-      .shiftTo(...lowerOrderUnits)
-      .plus(duration);
-  } else {
-    return duration;
-  }
-}

data/lib/feelin/js/node_modules/luxon/src/impl/digits.js

@@ -1,90 +0,0 @@
-const numberingSystems = {
-  arab: "[\u0660-\u0669]",
-  arabext: "[\u06F0-\u06F9]",
-  bali: "[\u1B50-\u1B59]",
-  beng: "[\u09E6-\u09EF]",
-  deva: "[\u0966-\u096F]",
-  fullwide: "[\uFF10-\uFF19]",
-  gujr: "[\u0AE6-\u0AEF]",
-  hanidec: "[〇|一|二|三|四|五|六|七|八|九]",
-  khmr: "[\u17E0-\u17E9]",
-  knda: "[\u0CE6-\u0CEF]",
-  laoo: "[\u0ED0-\u0ED9]",
-  limb: "[\u1946-\u194F]",
-  mlym: "[\u0D66-\u0D6F]",
-  mong: "[\u1810-\u1819]",
-  mymr: "[\u1040-\u1049]",
-  orya: "[\u0B66-\u0B6F]",
-  tamldec: "[\u0BE6-\u0BEF]",
-  telu: "[\u0C66-\u0C6F]",
-  thai: "[\u0E50-\u0E59]",
-  tibt: "[\u0F20-\u0F29]",
-  latn: "\\d",
-};
-
-const numberingSystemsUTF16 = {
-  arab: [1632, 1641],
-  arabext: [1776, 1785],
-  bali: [6992, 7001],
-  beng: [2534, 2543],
-  deva: [2406, 2415],
-  fullwide: [65296, 65303],
-  gujr: [2790, 2799],
-  khmr: [6112, 6121],
-  knda: [3302, 3311],
-  laoo: [3792, 3801],
-  limb: [6470, 6479],
-  mlym: [3430, 3439],
-  mong: [6160, 6169],
-  mymr: [4160, 4169],
-  orya: [2918, 2927],
-  tamldec: [3046, 3055],
-  telu: [3174, 3183],
-  thai: [3664, 3673],
-  tibt: [3872, 3881],
-};
-
-const hanidecChars = numberingSystems.hanidec.replace(/[\[|\]]/g, "").split("");
-
-export function parseDigits(str) {
-  let value = parseInt(str, 10);
-  if (isNaN(value)) {
-    value = "";
-    for (let i = 0; i < str.length; i++) {
-      const code = str.charCodeAt(i);
-
-      if (str[i].search(numberingSystems.hanidec) !== -1) {
-        value += hanidecChars.indexOf(str[i]);
-      } else {
-        for (const key in numberingSystemsUTF16) {
-          const [min, max] = numberingSystemsUTF16[key];
-          if (code >= min && code <= max) {
-            value += code - min;
-          }
-        }
-      }
-    }
-    return parseInt(value, 10);
-  } else {
-    return value;
-  }
-}
-
-// cache of {numberingSystem: {append: regex}}
-let digitRegexCache = {};
-export function resetDigitRegexCache() {
-  digitRegexCache = {};
-}
-
-export function digitRegex({ numberingSystem }, append = "") {
-  const ns = numberingSystem || "latn";
-
-  if (!digitRegexCache[ns]) {
-    digitRegexCache[ns] = {};
-  }
-  if (!digitRegexCache[ns][append]) {
-    digitRegexCache[ns][append] = new RegExp(`${numberingSystems[ns]}${append}`);
-  }
-
-  return digitRegexCache[ns][append];
-}

data/lib/feelin/js/node_modules/luxon/src/impl/english.js

@@ -1,233 +0,0 @@
-import * as Formats from "./formats.js";
-import { pick } from "./util.js";
-
-function stringify(obj) {
-  return JSON.stringify(obj, Object.keys(obj).sort());
-}
-
-/**
- * @private
- */
-
-export const monthsLong = [
-  "January",
-  "February",
-  "March",
-  "April",
-  "May",
-  "June",
-  "July",
-  "August",
-  "September",
-  "October",
-  "November",
-  "December",
-];
-
-export const monthsShort = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec",
-];
-
-export const monthsNarrow = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
-
-export function months(length) {
-  switch (length) {
-    case "narrow":
-      return [...monthsNarrow];
-    case "short":
-      return [...monthsShort];
-    case "long":
-      return [...monthsLong];
-    case "numeric":
-      return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
-    case "2-digit":
-      return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"];
-    default:
-      return null;
-  }
-}
-
-export const weekdaysLong = [
-  "Monday",
-  "Tuesday",
-  "Wednesday",
-  "Thursday",
-  "Friday",
-  "Saturday",
-  "Sunday",
-];
-
-export const weekdaysShort = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
-
-export const weekdaysNarrow = ["M", "T", "W", "T", "F", "S", "S"];
-
-export function weekdays(length) {
-  switch (length) {
-    case "narrow":
-      return [...weekdaysNarrow];
-    case "short":
-      return [...weekdaysShort];
-    case "long":
-      return [...weekdaysLong];
-    case "numeric":
-      return ["1", "2", "3", "4", "5", "6", "7"];
-    default:
-      return null;
-  }
-}
-
-export const meridiems = ["AM", "PM"];
-
-export const erasLong = ["Before Christ", "Anno Domini"];
-
-export const erasShort = ["BC", "AD"];
-
-export const erasNarrow = ["B", "A"];
-
-export function eras(length) {
-  switch (length) {
-    case "narrow":
-      return [...erasNarrow];
-    case "short":
-      return [...erasShort];
-    case "long":
-      return [...erasLong];
-    default:
-      return null;
-  }
-}
-
-export function meridiemForDateTime(dt) {
-  return meridiems[dt.hour < 12 ? 0 : 1];
-}
-
-export function weekdayForDateTime(dt, length) {
-  return weekdays(length)[dt.weekday - 1];
-}
-
-export function monthForDateTime(dt, length) {
-  return months(length)[dt.month - 1];
-}
-
-export function eraForDateTime(dt, length) {
-  return eras(length)[dt.year < 0 ? 0 : 1];
-}
-
-export function formatRelativeTime(unit, count, numeric = "always", narrow = false) {
-  const units = {
-    years: ["year", "yr."],
-    quarters: ["quarter", "qtr."],
-    months: ["month", "mo."],
-    weeks: ["week", "wk."],
-    days: ["day", "day", "days"],
-    hours: ["hour", "hr."],
-    minutes: ["minute", "min."],
-    seconds: ["second", "sec."],
-  };
-
-  const lastable = ["hours", "minutes", "seconds"].indexOf(unit) === -1;
-
-  if (numeric === "auto" && lastable) {
-    const isDay = unit === "days";
-    switch (count) {
-      case 1:
-        return isDay ? "tomorrow" : `next ${units[unit][0]}`;
-      case -1:
-        return isDay ? "yesterday" : `last ${units[unit][0]}`;
-      case 0:
-        return isDay ? "today" : `this ${units[unit][0]}`;
-      default: // fall through
-    }
-  }
-
-  const isInPast = Object.is(count, -0) || count < 0,
-    fmtValue = Math.abs(count),
-    singular = fmtValue === 1,
-    lilUnits = units[unit],
-    fmtUnit = narrow
-      ? singular
-        ? lilUnits[1]
-        : lilUnits[2] || lilUnits[1]
-      : singular
-      ? units[unit][0]
-      : unit;
-  return isInPast ? `${fmtValue} ${fmtUnit} ago` : `in ${fmtValue} ${fmtUnit}`;
-}
-
-export function formatString(knownFormat) {
-  // these all have the offsets removed because we don't have access to them
-  // without all the intl stuff this is backfilling
-  const filtered = pick(knownFormat, [
-      "weekday",
-      "era",
-      "year",
-      "month",
-      "day",
-      "hour",
-      "minute",
-      "second",
-      "timeZoneName",
-      "hourCycle",
-    ]),
-    key = stringify(filtered),
-    dateTimeHuge = "EEEE, LLLL d, yyyy, h:mm a";
-  switch (key) {
-    case stringify(Formats.DATE_SHORT):
-      return "M/d/yyyy";
-    case stringify(Formats.DATE_MED):
-      return "LLL d, yyyy";
-    case stringify(Formats.DATE_MED_WITH_WEEKDAY):
-      return "EEE, LLL d, yyyy";
-    case stringify(Formats.DATE_FULL):
-      return "LLLL d, yyyy";
-    case stringify(Formats.DATE_HUGE):
-      return "EEEE, LLLL d, yyyy";
-    case stringify(Formats.TIME_SIMPLE):
-      return "h:mm a";
-    case stringify(Formats.TIME_WITH_SECONDS):
-      return "h:mm:ss a";
-    case stringify(Formats.TIME_WITH_SHORT_OFFSET):
-      return "h:mm a";
-    case stringify(Formats.TIME_WITH_LONG_OFFSET):
-      return "h:mm a";
-    case stringify(Formats.TIME_24_SIMPLE):
-      return "HH:mm";
-    case stringify(Formats.TIME_24_WITH_SECONDS):
-      return "HH:mm:ss";
-    case stringify(Formats.TIME_24_WITH_SHORT_OFFSET):
-      return "HH:mm";
-    case stringify(Formats.TIME_24_WITH_LONG_OFFSET):
-      return "HH:mm";
-    case stringify(Formats.DATETIME_SHORT):
-      return "M/d/yyyy, h:mm a";
-    case stringify(Formats.DATETIME_MED):
-      return "LLL d, yyyy, h:mm a";
-    case stringify(Formats.DATETIME_FULL):
-      return "LLLL d, yyyy, h:mm a";
-    case stringify(Formats.DATETIME_HUGE):
-      return dateTimeHuge;
-    case stringify(Formats.DATETIME_SHORT_WITH_SECONDS):
-      return "M/d/yyyy, h:mm:ss a";
-    case stringify(Formats.DATETIME_MED_WITH_SECONDS):
-      return "LLL d, yyyy, h:mm:ss a";
-    case stringify(Formats.DATETIME_MED_WITH_WEEKDAY):
-      return "EEE, d LLL yyyy, h:mm a";
-    case stringify(Formats.DATETIME_FULL_WITH_SECONDS):
-      return "LLLL d, yyyy, h:mm:ss a";
-    case stringify(Formats.DATETIME_HUGE_WITH_SECONDS):
-      return "EEEE, LLLL d, yyyy, h:mm:ss a";
-    default:
-      return dateTimeHuge;
-  }
-}