@indielayer/ui 1.5.2 → 1.6.1

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/locale/en-US/_lib/localize.js

@@ -0,0 +1,155 @@
+import { buildLocalizeFn as e } from "../../_lib/buildLocalizeFn.js";
+const a = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+}, r = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+}, o = {
+  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+  abbreviated: [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ],
+  wide: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ]
+}, d = {
+  narrow: ["S", "M", "T", "W", "T", "F", "S"],
+  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  wide: [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ]
+}, m = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  }
+}, g = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  }
+}, u = (i, h) => {
+  const n = Number(i), t = n % 100;
+  if (t > 20 || t < 10)
+    switch (t % 10) {
+      case 1:
+        return n + "st";
+      case 2:
+        return n + "nd";
+      case 3:
+        return n + "rd";
+    }
+  return n + "th";
+}, l = {
+  ordinalNumber: u,
+  era: e({
+    values: a,
+    defaultWidth: "wide"
+  }),
+  quarter: e({
+    values: r,
+    defaultWidth: "wide",
+    argumentCallback: (i) => i - 1
+  }),
+  month: e({
+    values: o,
+    defaultWidth: "wide"
+  }),
+  day: e({
+    values: d,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: e({
+    values: m,
+    defaultWidth: "wide",
+    formattingValues: g,
+    defaultFormattingWidth: "wide"
+  })
+};
+export {
+  l as localize
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/locale/en-US/_lib/match.js

@@ -0,0 +1,110 @@
+import { buildMatchFn as a } from "../../_lib/buildMatchFn.js";
+import { buildMatchPatternFn as i } from "../../_lib/buildMatchPatternFn.js";
+const n = /^(\d+)(th|st|nd|rd)?/i, e = /\d+/i, r = {
+  narrow: /^(b|a)/i,
+  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+  wide: /^(before christ|before common era|anno domini|common era)/i
+}, s = {
+  any: [/^b/i, /^(a|c)/i]
+}, o = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+}, d = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+}, m = {
+  narrow: /^[jfmasond]/i,
+  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+}, h = {
+  narrow: [
+    /^j/i,
+    /^f/i,
+    /^m/i,
+    /^a/i,
+    /^m/i,
+    /^j/i,
+    /^j/i,
+    /^a/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ],
+  any: [
+    /^ja/i,
+    /^f/i,
+    /^mar/i,
+    /^ap/i,
+    /^may/i,
+    /^jun/i,
+    /^jul/i,
+    /^au/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ]
+}, c = {
+  narrow: /^[smtwf]/i,
+  short: /^(su|mo|tu|we|th|fr|sa)/i,
+  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+}, u = {
+  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+}, P = {
+  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+}, y = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^mi/i,
+    noon: /^no/i,
+    morning: /morning/i,
+    afternoon: /afternoon/i,
+    evening: /evening/i,
+    night: /night/i
+  }
+}, l = {
+  ordinalNumber: i({
+    matchPattern: n,
+    parsePattern: e,
+    valueCallback: (t) => parseInt(t, 10)
+  }),
+  era: a({
+    matchPatterns: r,
+    defaultMatchWidth: "wide",
+    parsePatterns: s,
+    defaultParseWidth: "any"
+  }),
+  quarter: a({
+    matchPatterns: o,
+    defaultMatchWidth: "wide",
+    parsePatterns: d,
+    defaultParseWidth: "any",
+    valueCallback: (t) => t + 1
+  }),
+  month: a({
+    matchPatterns: m,
+    defaultMatchWidth: "wide",
+    parsePatterns: h,
+    defaultParseWidth: "any"
+  }),
+  day: a({
+    matchPatterns: c,
+    defaultMatchWidth: "wide",
+    parsePatterns: u,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: a({
+    matchPatterns: P,
+    defaultMatchWidth: "any",
+    parsePatterns: y,
+    defaultParseWidth: "any"
+  })
+};
+export {
+  l as match
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/locale/en-US.js

@@ -0,0 +1,21 @@
+import { formatDistance as o } from "./en-US/_lib/formatDistance.js";
+import { formatLong as t } from "./en-US/_lib/formatLong.js";
+import { formatRelative as a } from "./en-US/_lib/formatRelative.js";
+import { localize as r } from "./en-US/_lib/localize.js";
+import { match as e } from "./en-US/_lib/match.js";
+const s = {
+  code: "en-US",
+  formatDistance: o,
+  formatLong: t,
+  formatRelative: a,
+  localize: r,
+  match: e,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+export {
+  s as default,
+  s as enUS
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/Parser.js

@@ -0,0 +1,22 @@
+import { ValueSetter as u } from "./Setter.js";
+class n {
+  run(r, e, s, i) {
+    const t = this.parse(r, e, s, i);
+    return t ? {
+      setter: new u(
+        t.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: t.rest
+    } : null;
+  }
+  validate(r, e, s) {
+    return !0;
+  }
+}
+export {
+  n as Parser
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/Setter.js

@@ -0,0 +1,40 @@
+var l = Object.defineProperty;
+var n = (r, e, t) => e in r ? l(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var i = (r, e, t) => (n(r, typeof e != "symbol" ? e + "" : e, t), t);
+import { transpose as c } from "../../transpose.js";
+import { constructFrom as h } from "../../constructFrom.js";
+const m = 10;
+class u {
+  constructor() {
+    i(this, "subPriority", 0);
+  }
+  validate(e, t) {
+    return !0;
+  }
+}
+class I extends u {
+  constructor(e, t, s, o, a) {
+    super(), this.value = e, this.validateValue = t, this.setValue = s, this.priority = o, a && (this.subPriority = a);
+  }
+  validate(e, t) {
+    return this.validateValue(e, this.value, t);
+  }
+  set(e, t, s) {
+    return this.setValue(e, t, this.value, s);
+  }
+}
+class S extends u {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", m);
+    i(this, "subPriority", -1);
+  }
+  set(t, s) {
+    return s.timestampIsSet ? t : h(t, c(t, Date));
+  }
+}
+export {
+  S as DateToSystemTimezoneSetter,
+  u as Setter,
+  I as ValueSetter
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/constants.js

@@ -0,0 +1,49 @@
+const d = {
+  month: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  date: /^(3[0-1]|[0-2]?\d)/,
+  // 0 to 31
+  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
+  // 0 to 366
+  week: /^(5[0-3]|[0-4]?\d)/,
+  // 0 to 53
+  hour23h: /^(2[0-3]|[0-1]?\d)/,
+  // 0 to 23
+  hour24h: /^(2[0-4]|[0-1]?\d)/,
+  // 0 to 24
+  hour11h: /^(1[0-1]|0?\d)/,
+  // 0 to 11
+  hour12h: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  minute: /^[0-5]?\d/,
+  // 0 to 59
+  second: /^[0-5]?\d/,
+  // 0 to 59
+  singleDigit: /^\d/,
+  // 0 to 9
+  twoDigits: /^\d{1,2}/,
+  // 0 to 99
+  threeDigits: /^\d{1,3}/,
+  // 0 to 999
+  fourDigits: /^\d{1,4}/,
+  // 0 to 9999
+  anyDigitsSigned: /^-?\d+/,
+  singleDigitSigned: /^-?\d/,
+  // 0 to 9, -0 to -9
+  twoDigitsSigned: /^-?\d{1,2}/,
+  // 0 to 99, -0 to -99
+  threeDigitsSigned: /^-?\d{1,3}/,
+  // 0 to 999, -0 to -999
+  fourDigitsSigned: /^-?\d{1,4}/
+  // 0 to 9999, -0 to -9999
+}, i = {
+  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+  basic: /^([+-])(\d{2})(\d{2})|Z/,
+  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
+};
+export {
+  d as numericPatterns,
+  i as timezonePatterns
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.js

@@ -0,0 +1,49 @@
+var b = Object.defineProperty;
+var d = (t, o, r) => o in t ? b(t, o, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[o] = r;
+var i = (t, o, r) => (d(t, typeof o != "symbol" ? o + "" : o, r), r);
+import { Parser as n } from "../Parser.js";
+import { dayPeriodEnumToHours as s } from "../utils.js";
+class c extends n {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 80);
+    i(this, "incompatibleTokens", ["a", "B", "H", "k", "t", "T"]);
+  }
+  parse(r, a, e) {
+    switch (a) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return e.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || e.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return e.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return e.dayPeriod(r, {
+          width: "wide",
+          context: "formatting"
+        }) || e.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || e.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(r, a, e) {
+    return r.setHours(s(e), 0, 0, 0), r;
+  }
+}
+export {
+  c as AMPMMidnightParser
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/parsers/AMPMParser.js

@@ -0,0 +1,49 @@
+var d = Object.defineProperty;
+var n = (e, a, r) => a in e ? d(e, a, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[a] = r;
+var t = (e, a, r) => (n(e, typeof a != "symbol" ? a + "" : a, r), r);
+import { Parser as s } from "../Parser.js";
+import { dayPeriodEnumToHours as w } from "../utils.js";
+class u extends s {
+  constructor() {
+    super(...arguments);
+    t(this, "priority", 80);
+    t(this, "incompatibleTokens", ["b", "B", "H", "k", "t", "T"]);
+  }
+  parse(r, i, o) {
+    switch (i) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return o.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return o.dayPeriod(r, {
+          width: "wide",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(r, i, o) {
+    return r.setHours(w(o), 0, 0, 0), r;
+  }
+}
+export {
+  u as AMPMParser
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/parsers/DateParser.js

@@ -0,0 +1,61 @@
+var c = Object.defineProperty;
+var m = (s, e, r) => e in s ? c(s, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : s[e] = r;
+var o = (s, e, r) => (m(s, typeof e != "symbol" ? e + "" : e, r), r);
+import { numericPatterns as p } from "../constants.js";
+import { Parser as u } from "../Parser.js";
+import { parseNDigits as l, parseNumericPattern as N, isLeapYearIndex as Y } from "../utils.js";
+const _ = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], f = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class A extends u {
+  constructor() {
+    super(...arguments);
+    o(this, "priority", 90);
+    o(this, "subPriority", 1);
+    o(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(r, t, n) {
+    switch (t) {
+      case "d":
+        return N(p.date, r);
+      case "do":
+        return n.ordinalNumber(r, { unit: "date" });
+      default:
+        return l(t.length, r);
+    }
+  }
+  validate(r, t) {
+    const n = r.getFullYear(), a = Y(n), i = r.getMonth();
+    return a ? t >= 1 && t <= f[i] : t >= 1 && t <= _[i];
+  }
+  set(r, t, n) {
+    return r.setDate(n), r.setHours(0, 0, 0, 0), r;
+  }
+}
+export {
+  A as DateParser
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.js

@@ -0,0 +1,51 @@
+var n = Object.defineProperty;
+var o = (t, e, r) => e in t ? n(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var i = (t, e, r) => (o(t, typeof e != "symbol" ? e + "" : e, r), r);
+import { numericPatterns as p } from "../constants.js";
+import { Parser as c } from "../Parser.js";
+import { parseNDigits as u, parseNumericPattern as m, isLeapYearIndex as f } from "../utils.js";
+class L extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "subpriority", 1);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "E",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(r, s, a) {
+    switch (s) {
+      case "D":
+      case "DD":
+        return m(p.dayOfYear, r);
+      case "Do":
+        return a.ordinalNumber(r, { unit: "date" });
+      default:
+        return u(s.length, r);
+    }
+  }
+  validate(r, s) {
+    const a = r.getFullYear();
+    return f(a) ? s >= 1 && s <= 366 : s >= 1 && s <= 365;
+  }
+  set(r, s, a) {
+    return r.setMonth(0, a), r.setHours(0, 0, 0, 0), r;
+  }
+}
+export {
+  L as DayOfYearParser
+};

package/lib/node_modules/.pnpm/date-fns@3.3.1/node_modules/date-fns/parse/_lib/parsers/DayParser.js

@@ -0,0 +1,45 @@
+var s = Object.defineProperty;
+var E = (e, o, t) => o in e ? s(e, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[o] = t;
+var n = (e, o, t) => (E(e, typeof o != "symbol" ? o + "" : o, t), t);
+import { setDay as w } from "../../../setDay.js";
+import { Parser as d } from "../Parser.js";
+class c extends d {
+  constructor() {
+    super(...arguments);
+    n(this, "priority", 90);
+    n(this, "incompatibleTokens", ["D", "i", "e", "c", "t", "T"]);
+  }
+  parse(t, a, r) {
+    switch (a) {
+      case "E":
+      case "EE":
+      case "EEE":
+        return r.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
+      case "EEEEE":
+        return r.day(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "EEEEEE":
+        return r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
+      case "EEEE":
+      default:
+        return r.day(t, { width: "wide", context: "formatting" }) || r.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(t, a) {
+    return a >= 0 && a <= 6;
+  }
+  set(t, a, r, i) {
+    return t = w(t, r, i), t.setHours(0, 0, 0, 0), t;
+  }
+}
+export {
+  c as DayParser
+};