@anoki/fse-ui 1.0.0-beta1.21

package/dist/index.es3.js

@@ -0,0 +1,724 @@
+import { InvalidArgumentError as f, InvalidDurationError as S, InvalidUnitError as I } from "./index.es209.js";
+import T from "./index.es200.js";
+import O from "./index.es210.js";
+import V from "./index.es202.js";
+import { parseISODuration as j, parseISOTimeOnly as q } from "./index.es5.js";
+import { normalizeObject as g, isNumber as y, isUndefined as v, roundTo as M, hasOwnProperty as p, asNumber as U } from "./index.es203.js";
+import A from "./index.es4.js";
+import z from "./index.es197.js";
+const N = "Invalid Duration", k = {
+  weeks: {
+    days: 7,
+    hours: 7 * 24,
+    minutes: 7 * 24 * 60,
+    seconds: 7 * 24 * 60 * 60,
+    milliseconds: 7 * 24 * 60 * 60 * 1e3
+  },
+  days: {
+    hours: 24,
+    minutes: 24 * 60,
+    seconds: 24 * 60 * 60,
+    milliseconds: 24 * 60 * 60 * 1e3
+  },
+  hours: { minutes: 60, seconds: 60 * 60, milliseconds: 60 * 60 * 1e3 },
+  minutes: { seconds: 60, milliseconds: 60 * 1e3 },
+  seconds: { milliseconds: 1e3 }
+}, $ = {
+  years: {
+    quarters: 4,
+    months: 12,
+    weeks: 52,
+    days: 365,
+    hours: 365 * 24,
+    minutes: 365 * 24 * 60,
+    seconds: 365 * 24 * 60 * 60,
+    milliseconds: 365 * 24 * 60 * 60 * 1e3
+  },
+  quarters: {
+    months: 3,
+    weeks: 13,
+    days: 91,
+    hours: 91 * 24,
+    minutes: 91 * 24 * 60,
+    seconds: 91 * 24 * 60 * 60,
+    milliseconds: 91 * 24 * 60 * 60 * 1e3
+  },
+  months: {
+    weeks: 4,
+    days: 30,
+    hours: 30 * 24,
+    minutes: 30 * 24 * 60,
+    seconds: 30 * 24 * 60 * 60,
+    milliseconds: 30 * 24 * 60 * 60 * 1e3
+  },
+  ...k
+}, o = 146097 / 400, m = 146097 / 4800, F = {
+  years: {
+    quarters: 4,
+    months: 12,
+    weeks: o / 7,
+    days: o,
+    hours: o * 24,
+    minutes: o * 24 * 60,
+    seconds: o * 24 * 60 * 60,
+    milliseconds: o * 24 * 60 * 60 * 1e3
+  },
+  quarters: {
+    months: 3,
+    weeks: o / 28,
+    days: o / 4,
+    hours: o * 24 / 4,
+    minutes: o * 24 * 60 / 4,
+    seconds: o * 24 * 60 * 60 / 4,
+    milliseconds: o * 24 * 60 * 60 * 1e3 / 4
+  },
+  months: {
+    weeks: m / 7,
+    days: m,
+    hours: m * 24,
+    minutes: m * 24 * 60,
+    seconds: m * 24 * 60 * 60,
+    milliseconds: m * 24 * 60 * 60 * 1e3
+  },
+  ...k
+}, h = [
+  "years",
+  "quarters",
+  "months",
+  "weeks",
+  "days",
+  "hours",
+  "minutes",
+  "seconds",
+  "milliseconds"
+], D = h.slice(0).reverse();
+function u(l, s, e = !1) {
+  const t = {
+    values: e ? s.values : { ...l.values, ...s.values || {} },
+    loc: l.loc.clone(s.loc),
+    conversionAccuracy: s.conversionAccuracy || l.conversionAccuracy,
+    matrix: s.matrix || l.matrix
+  };
+  return new n(t);
+}
+function x(l, s) {
+  let e = s.milliseconds ?? 0;
+  for (const t of D.slice(1))
+    s[t] && (e += s[t] * l[t].milliseconds);
+  return e;
+}
+function b(l, s) {
+  const e = x(l, s) < 0 ? -1 : 1;
+  h.reduceRight((t, i) => {
+    if (v(s[i]))
+      return t;
+    if (t) {
+      const a = s[t] * e, r = l[i][t], c = Math.floor(a / r);
+      s[i] += c * e, s[t] -= c * r * e;
+    }
+    return i;
+  }, null), h.reduce((t, i) => {
+    if (v(s[i]))
+      return t;
+    if (t) {
+      const a = s[t] % 1;
+      s[t] -= a, s[i] += a * l[t][i];
+    }
+    return i;
+  }, null);
+}
+function E(l) {
+  const s = {};
+  for (const [e, t] of Object.entries(l))
+    t !== 0 && (s[e] = t);
+  return s;
+}
+class n {
+  /**
+   * @private
+   */
+  constructor(s) {
+    const e = s.conversionAccuracy === "longterm" || !1;
+    let t = e ? F : $;
+    s.matrix && (t = s.matrix), this.values = s.values, this.loc = s.loc || V.create(), this.conversionAccuracy = e ? "longterm" : "casual", this.invalid = s.invalid || null, this.matrix = t, this.isLuxonDuration = !0;
+  }
+  /**
+   * Create Duration from a number of milliseconds.
+   * @param {number} count of milliseconds
+   * @param {Object} opts - options for parsing
+   * @param {string} [opts.locale='en-US'] - the locale to use
+   * @param {string} opts.numberingSystem - the numbering system to use
+   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
+   * @return {Duration}
+   */
+  static fromMillis(s, e) {
+    return n.fromObject({ milliseconds: s }, e);
+  }
+  /**
+   * Create a Duration from a JavaScript object with keys like 'years' and 'hours'.
+   * If this object is empty then a zero milliseconds duration is returned.
+   * @param {Object} obj - the object to create the DateTime from
+   * @param {number} obj.years
+   * @param {number} obj.quarters
+   * @param {number} obj.months
+   * @param {number} obj.weeks
+   * @param {number} obj.days
+   * @param {number} obj.hours
+   * @param {number} obj.minutes
+   * @param {number} obj.seconds
+   * @param {number} obj.milliseconds
+   * @param {Object} [opts=[]] - options for creating this Duration
+   * @param {string} [opts.locale='en-US'] - the locale to use
+   * @param {string} opts.numberingSystem - the numbering system to use
+   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
+   * @param {string} [opts.matrix=Object] - the custom conversion system to use
+   * @return {Duration}
+   */
+  static fromObject(s, e = {}) {
+    if (s == null || typeof s != "object")
+      throw new f(
+        `Duration.fromObject: argument expected to be an object, got ${s === null ? "null" : typeof s}`
+      );
+    return new n({
+      values: g(s, n.normalizeUnit),
+      loc: V.fromObject(e),
+      conversionAccuracy: e.conversionAccuracy,
+      matrix: e.matrix
+    });
+  }
+  /**
+   * Create a Duration from DurationLike.
+   *
+   * @param {Object | number | Duration} durationLike
+   * One of:
+   * - object with keys like 'years' and 'hours'.
+   * - number representing milliseconds
+   * - Duration instance
+   * @return {Duration}
+   */
+  static fromDurationLike(s) {
+    if (y(s))
+      return n.fromMillis(s);
+    if (n.isDuration(s))
+      return s;
+    if (typeof s == "object")
+      return n.fromObject(s);
+    throw new f(
+      `Unknown duration argument ${s} of type ${typeof s}`
+    );
+  }
+  /**
+   * Create a Duration from an ISO 8601 duration string.
+   * @param {string} text - text to parse
+   * @param {Object} opts - options for parsing
+   * @param {string} [opts.locale='en-US'] - the locale to use
+   * @param {string} opts.numberingSystem - the numbering system to use
+   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
+   * @param {string} [opts.matrix=Object] - the preset conversion system to use
+   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
+   * @example Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
+   * @example Duration.fromISO('PT23H').toObject() //=> { hours: 23 }
+   * @example Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 }
+   * @return {Duration}
+   */
+  static fromISO(s, e) {
+    const [t] = j(s);
+    return t ? n.fromObject(t, e) : n.invalid("unparsable", `the input "${s}" can't be parsed as ISO 8601`);
+  }
+  /**
+   * Create a Duration from an ISO 8601 time string.
+   * @param {string} text - text to parse
+   * @param {Object} opts - options for parsing
+   * @param {string} [opts.locale='en-US'] - the locale to use
+   * @param {string} opts.numberingSystem - the numbering system to use
+   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
+   * @param {string} [opts.matrix=Object] - the conversion system to use
+   * @see https://en.wikipedia.org/wiki/ISO_8601#Times
+   * @example Duration.fromISOTime('11:22:33.444').toObject() //=> { hours: 11, minutes: 22, seconds: 33, milliseconds: 444 }
+   * @example Duration.fromISOTime('11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
+   * @example Duration.fromISOTime('T11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
+   * @example Duration.fromISOTime('1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
+   * @example Duration.fromISOTime('T1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
+   * @return {Duration}
+   */
+  static fromISOTime(s, e) {
+    const [t] = q(s);
+    return t ? n.fromObject(t, e) : n.invalid("unparsable", `the input "${s}" can't be parsed as ISO 8601`);
+  }
+  /**
+   * Create an invalid Duration.
+   * @param {string} reason - simple string of why this datetime is invalid. Should not contain parameters or anything else data-dependent
+   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
+   * @return {Duration}
+   */
+  static invalid(s, e = null) {
+    if (!s)
+      throw new f("need to specify a reason the Duration is invalid");
+    const t = s instanceof O ? s : new O(s, e);
+    if (A.throwOnInvalid)
+      throw new S(t);
+    return new n({ invalid: t });
+  }
+  /**
+   * @private
+   */
+  static normalizeUnit(s) {
+    const e = {
+      year: "years",
+      years: "years",
+      quarter: "quarters",
+      quarters: "quarters",
+      month: "months",
+      months: "months",
+      week: "weeks",
+      weeks: "weeks",
+      day: "days",
+      days: "days",
+      hour: "hours",
+      hours: "hours",
+      minute: "minutes",
+      minutes: "minutes",
+      second: "seconds",
+      seconds: "seconds",
+      millisecond: "milliseconds",
+      milliseconds: "milliseconds"
+    }[s && s.toLowerCase()];
+    if (!e) throw new I(s);
+    return e;
+  }
+  /**
+   * Check if an object is a Duration. Works across context boundaries
+   * @param {object} o
+   * @return {boolean}
+   */
+  static isDuration(s) {
+    return s && s.isLuxonDuration || !1;
+  }
+  /**
+   * Get  the locale of a Duration, such 'en-GB'
+   * @type {string}
+   */
+  get locale() {
+    return this.isValid ? this.loc.locale : null;
+  }
+  /**
+   * Get the numbering system of a Duration, such 'beng'. The numbering system is used when formatting the Duration
+   *
+   * @type {string}
+   */
+  get numberingSystem() {
+    return this.isValid ? this.loc.numberingSystem : null;
+  }
+  /**
+   * Returns a string representation of this Duration formatted according to the specified format string. You may use these tokens:
+   * * `S` for milliseconds
+   * * `s` for seconds
+   * * `m` for minutes
+   * * `h` for hours
+   * * `d` for days
+   * * `w` for weeks
+   * * `M` for months
+   * * `y` for years
+   * Notes:
+   * * Add padding by repeating the token, e.g. "yy" pads the years to two digits, "hhhh" pads the hours out to four digits
+   * * Tokens can be escaped by wrapping with single quotes.
+   * * The duration will be converted to the set of units in the format string using {@link Duration#shiftTo} and the Durations's conversion accuracy setting.
+   * @param {string} fmt - the format string
+   * @param {Object} opts - options
+   * @param {boolean} [opts.floor=true] - floor numerical values
+   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("y d s") //=> "1 6 2"
+   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("yy dd sss") //=> "01 06 002"
+   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("M S") //=> "12 518402000"
+   * @return {string}
+   */
+  toFormat(s, e = {}) {
+    const t = {
+      ...e,
+      floor: e.round !== !1 && e.floor !== !1
+    };
+    return this.isValid ? T.create(this.loc, t).formatDurationFromString(this, s) : N;
+  }
+  /**
+   * Returns a string representation of a Duration with all units included.
+   * To modify its behavior, use `listStyle` and any Intl.NumberFormat option, though `unitDisplay` is especially relevant.
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
+   * @param {Object} opts - Formatting options. Accepts the same keys as the options parameter of the native `Intl.NumberFormat` constructor, as well as `listStyle`.
+   * @param {string} [opts.listStyle='narrow'] - How to format the merged list. Corresponds to the `style` property of the options parameter of the native `Intl.ListFormat` constructor.
+   * @example
+   * ```js
+   * var dur = Duration.fromObject({ days: 1, hours: 5, minutes: 6 })
+   * dur.toHuman() //=> '1 day, 5 hours, 6 minutes'
+   * dur.toHuman({ listStyle: "long" }) //=> '1 day, 5 hours, and 6 minutes'
+   * dur.toHuman({ unitDisplay: "short" }) //=> '1 day, 5 hr, 6 min'
+   * ```
+   */
+  toHuman(s = {}) {
+    if (!this.isValid) return N;
+    const e = h.map((t) => {
+      const i = this.values[t];
+      return v(i) ? null : this.loc.numberFormatter({ style: "unit", unitDisplay: "long", ...s, unit: t.slice(0, -1) }).format(i);
+    }).filter((t) => t);
+    return this.loc.listFormatter({ type: "conjunction", style: s.listStyle || "narrow", ...s }).format(e);
+  }
+  /**
+   * Returns a JavaScript object with this Duration's values.
+   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toObject() //=> { years: 1, days: 6, seconds: 2 }
+   * @return {Object}
+   */
+  toObject() {
+    return this.isValid ? { ...this.values } : {};
+  }
+  /**
+   * Returns an ISO 8601-compliant string representation of this Duration.
+   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
+   * @example Duration.fromObject({ years: 3, seconds: 45 }).toISO() //=> 'P3YT45S'
+   * @example Duration.fromObject({ months: 4, seconds: 45 }).toISO() //=> 'P4MT45S'
+   * @example Duration.fromObject({ months: 5 }).toISO() //=> 'P5M'
+   * @example Duration.fromObject({ minutes: 5 }).toISO() //=> 'PT5M'
+   * @example Duration.fromObject({ milliseconds: 6 }).toISO() //=> 'PT0.006S'
+   * @return {string}
+   */
+  toISO() {
+    if (!this.isValid) return null;
+    let s = "P";
+    return this.years !== 0 && (s += this.years + "Y"), (this.months !== 0 || this.quarters !== 0) && (s += this.months + this.quarters * 3 + "M"), this.weeks !== 0 && (s += this.weeks + "W"), this.days !== 0 && (s += this.days + "D"), (this.hours !== 0 || this.minutes !== 0 || this.seconds !== 0 || this.milliseconds !== 0) && (s += "T"), this.hours !== 0 && (s += this.hours + "H"), this.minutes !== 0 && (s += this.minutes + "M"), (this.seconds !== 0 || this.milliseconds !== 0) && (s += M(this.seconds + this.milliseconds / 1e3, 3) + "S"), s === "P" && (s += "T0S"), s;
+  }
+  /**
+   * Returns an ISO 8601-compliant string representation of this Duration, formatted as a time of day.
+   * Note that this will return null if the duration is invalid, negative, or equal to or greater than 24 hours.
+   * @see https://en.wikipedia.org/wiki/ISO_8601#Times
+   * @param {Object} opts - options
+   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
+   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
+   * @param {boolean} [opts.includePrefix=false] - include the `T` prefix
+   * @param {string} [opts.format='extended'] - choose between the basic and extended format
+   * @example Duration.fromObject({ hours: 11 }).toISOTime() //=> '11:00:00.000'
+   * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressMilliseconds: true }) //=> '11:00:00'
+   * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressSeconds: true }) //=> '11:00'
+   * @example Duration.fromObject({ hours: 11 }).toISOTime({ includePrefix: true }) //=> 'T11:00:00.000'
+   * @example Duration.fromObject({ hours: 11 }).toISOTime({ format: 'basic' }) //=> '110000.000'
+   * @return {string}
+   */
+  toISOTime(s = {}) {
+    if (!this.isValid) return null;
+    const e = this.toMillis();
+    return e < 0 || e >= 864e5 ? null : (s = {
+      suppressMilliseconds: !1,
+      suppressSeconds: !1,
+      includePrefix: !1,
+      format: "extended",
+      ...s,
+      includeOffset: !1
+    }, z.fromMillis(e, { zone: "UTC" }).toISOTime(s));
+  }
+  /**
+   * Returns an ISO 8601 representation of this Duration appropriate for use in JSON.
+   * @return {string}
+   */
+  toJSON() {
+    return this.toISO();
+  }
+  /**
+   * Returns an ISO 8601 representation of this Duration appropriate for use in debugging.
+   * @return {string}
+   */
+  toString() {
+    return this.toISO();
+  }
+  /**
+   * Returns a string representation of this Duration appropriate for the REPL.
+   * @return {string}
+   */
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.isValid ? `Duration { values: ${JSON.stringify(this.values)} }` : `Duration { Invalid, reason: ${this.invalidReason} }`;
+  }
+  /**
+   * Returns an milliseconds value of this Duration.
+   * @return {number}
+   */
+  toMillis() {
+    return this.isValid ? x(this.matrix, this.values) : NaN;
+  }
+  /**
+   * Returns an milliseconds value of this Duration. Alias of {@link toMillis}
+   * @return {number}
+   */
+  valueOf() {
+    return this.toMillis();
+  }
+  /**
+   * Make this Duration longer by the specified amount. Return a newly-constructed Duration.
+   * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
+   * @return {Duration}
+   */
+  plus(s) {
+    if (!this.isValid) return this;
+    const e = n.fromDurationLike(s), t = {};
+    for (const i of h)
+      (p(e.values, i) || p(this.values, i)) && (t[i] = e.get(i) + this.get(i));
+    return u(this, { values: t }, !0);
+  }
+  /**
+   * Make this Duration shorter by the specified amount. Return a newly-constructed Duration.
+   * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
+   * @return {Duration}
+   */
+  minus(s) {
+    if (!this.isValid) return this;
+    const e = n.fromDurationLike(s);
+    return this.plus(e.negate());
+  }
+  /**
+   * Scale this Duration by the specified amount. Return a newly-constructed Duration.
+   * @param {function} fn - The function to apply to each unit. Arity is 1 or 2: the value of the unit and, optionally, the unit name. Must return a number.
+   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits(x => x * 2) //=> { hours: 2, minutes: 60 }
+   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits((x, u) => u === "hours" ? x * 2 : x) //=> { hours: 2, minutes: 30 }
+   * @return {Duration}
+   */
+  mapUnits(s) {
+    if (!this.isValid) return this;
+    const e = {};
+    for (const t of Object.keys(this.values))
+      e[t] = U(s(this.values[t], t));
+    return u(this, { values: e }, !0);
+  }
+  /**
+   * Get the value of unit.
+   * @param {string} unit - a unit such as 'minute' or 'day'
+   * @example Duration.fromObject({years: 2, days: 3}).get('years') //=> 2
+   * @example Duration.fromObject({years: 2, days: 3}).get('months') //=> 0
+   * @example Duration.fromObject({years: 2, days: 3}).get('days') //=> 3
+   * @return {number}
+   */
+  get(s) {
+    return this[n.normalizeUnit(s)];
+  }
+  /**
+   * "Set" the values of specified units. Return a newly-constructed Duration.
+   * @param {Object} values - a mapping of units to numbers
+   * @example dur.set({ years: 2017 })
+   * @example dur.set({ hours: 8, minutes: 30 })
+   * @return {Duration}
+   */
+  set(s) {
+    if (!this.isValid) return this;
+    const e = { ...this.values, ...g(s, n.normalizeUnit) };
+    return u(this, { values: e });
+  }
+  /**
+   * "Set" the locale and/or numberingSystem.  Returns a newly-constructed Duration.
+   * @example dur.reconfigure({ locale: 'en-GB' })
+   * @return {Duration}
+   */
+  reconfigure({ locale: s, numberingSystem: e, conversionAccuracy: t, matrix: i } = {}) {
+    const r = { loc: this.loc.clone({ locale: s, numberingSystem: e }), matrix: i, conversionAccuracy: t };
+    return u(this, r);
+  }
+  /**
+   * Return the length of the duration in the specified unit.
+   * @param {string} unit - a unit such as 'minutes' or 'days'
+   * @example Duration.fromObject({years: 1}).as('days') //=> 365
+   * @example Duration.fromObject({years: 1}).as('months') //=> 12
+   * @example Duration.fromObject({hours: 60}).as('days') //=> 2.5
+   * @return {number}
+   */
+  as(s) {
+    return this.isValid ? this.shiftTo(s).get(s) : NaN;
+  }
+  /**
+   * Reduce this Duration to its canonical representation in its current units.
+   * Assuming the overall value of the Duration is positive, this means:
+   * - excessive values for lower-order units are converted to higher-order units (if possible, see first and second example)
+   * - negative lower-order units are converted to higher order units (there must be such a higher order unit, otherwise
+   *   the overall value would be negative, see third example)
+   * - fractional values for higher-order units are converted to lower-order units (if possible, see fourth example)
+   *
+   * If the overall value is negative, the result of this method is equivalent to `this.negate().normalize().negate()`.
+   * @example Duration.fromObject({ years: 2, days: 5000 }).normalize().toObject() //=> { years: 15, days: 255 }
+   * @example Duration.fromObject({ days: 5000 }).normalize().toObject() //=> { days: 5000 }
+   * @example Duration.fromObject({ hours: 12, minutes: -45 }).normalize().toObject() //=> { hours: 11, minutes: 15 }
+   * @example Duration.fromObject({ years: 2.5, days: 0, hours: 0 }).normalize().toObject() //=> { years: 2, days: 182, hours: 12 }
+   * @return {Duration}
+   */
+  normalize() {
+    if (!this.isValid) return this;
+    const s = this.toObject();
+    return b(this.matrix, s), u(this, { values: s }, !0);
+  }
+  /**
+   * Rescale units to its largest representation
+   * @example Duration.fromObject({ milliseconds: 90000 }).rescale().toObject() //=> { minutes: 1, seconds: 30 }
+   * @return {Duration}
+   */
+  rescale() {
+    if (!this.isValid) return this;
+    const s = E(this.normalize().shiftToAll().toObject());
+    return u(this, { values: s }, !0);
+  }
+  /**
+   * Convert this Duration into its representation in a different set of units.
+   * @example Duration.fromObject({ hours: 1, seconds: 30 }).shiftTo('minutes', 'milliseconds').toObject() //=> { minutes: 60, milliseconds: 30000 }
+   * @return {Duration}
+   */
+  shiftTo(...s) {
+    if (!this.isValid) return this;
+    if (s.length === 0)
+      return this;
+    s = s.map((r) => n.normalizeUnit(r));
+    const e = {}, t = {}, i = this.toObject();
+    let a;
+    for (const r of h)
+      if (s.indexOf(r) >= 0) {
+        a = r;
+        let c = 0;
+        for (const d in t)
+          c += this.matrix[d][r] * t[d], t[d] = 0;
+        y(i[r]) && (c += i[r]);
+        const w = Math.trunc(c);
+        e[r] = w, t[r] = (c * 1e3 - w * 1e3) / 1e3;
+      } else y(i[r]) && (t[r] = i[r]);
+    for (const r in t)
+      t[r] !== 0 && (e[a] += r === a ? t[r] : t[r] / this.matrix[a][r]);
+    return b(this.matrix, e), u(this, { values: e }, !0);
+  }
+  /**
+   * Shift this Duration to all available units.
+   * Same as shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds")
+   * @return {Duration}
+   */
+  shiftToAll() {
+    return this.isValid ? this.shiftTo(
+      "years",
+      "months",
+      "weeks",
+      "days",
+      "hours",
+      "minutes",
+      "seconds",
+      "milliseconds"
+    ) : this;
+  }
+  /**
+   * Return the negative of this Duration.
+   * @example Duration.fromObject({ hours: 1, seconds: 30 }).negate().toObject() //=> { hours: -1, seconds: -30 }
+   * @return {Duration}
+   */
+  negate() {
+    if (!this.isValid) return this;
+    const s = {};
+    for (const e of Object.keys(this.values))
+      s[e] = this.values[e] === 0 ? 0 : -this.values[e];
+    return u(this, { values: s }, !0);
+  }
+  /**
+   * Get the years.
+   * @type {number}
+   */
+  get years() {
+    return this.isValid ? this.values.years || 0 : NaN;
+  }
+  /**
+   * Get the quarters.
+   * @type {number}
+   */
+  get quarters() {
+    return this.isValid ? this.values.quarters || 0 : NaN;
+  }
+  /**
+   * Get the months.
+   * @type {number}
+   */
+  get months() {
+    return this.isValid ? this.values.months || 0 : NaN;
+  }
+  /**
+   * Get the weeks
+   * @type {number}
+   */
+  get weeks() {
+    return this.isValid ? this.values.weeks || 0 : NaN;
+  }
+  /**
+   * Get the days.
+   * @type {number}
+   */
+  get days() {
+    return this.isValid ? this.values.days || 0 : NaN;
+  }
+  /**
+   * Get the hours.
+   * @type {number}
+   */
+  get hours() {
+    return this.isValid ? this.values.hours || 0 : NaN;
+  }
+  /**
+   * Get the minutes.
+   * @type {number}
+   */
+  get minutes() {
+    return this.isValid ? this.values.minutes || 0 : NaN;
+  }
+  /**
+   * Get the seconds.
+   * @return {number}
+   */
+  get seconds() {
+    return this.isValid ? this.values.seconds || 0 : NaN;
+  }
+  /**
+   * Get the milliseconds.
+   * @return {number}
+   */
+  get milliseconds() {
+    return this.isValid ? this.values.milliseconds || 0 : NaN;
+  }
+  /**
+   * Returns whether the Duration is invalid. Invalid durations are returned by diff operations
+   * on invalid DateTimes or Intervals.
+   * @return {boolean}
+   */
+  get isValid() {
+    return this.invalid === null;
+  }
+  /**
+   * Returns an error code if this Duration became invalid, or null if the Duration is valid
+   * @return {string}
+   */
+  get invalidReason() {
+    return this.invalid ? this.invalid.reason : null;
+  }
+  /**
+   * Returns an explanation of why this Duration became invalid, or null if the Duration is valid
+   * @type {string}
+   */
+  get invalidExplanation() {
+    return this.invalid ? this.invalid.explanation : null;
+  }
+  /**
+   * Equality check
+   * Two Durations are equal iff they have the same units and the same values for each unit.
+   * @param {Duration} other
+   * @return {boolean}
+   */
+  equals(s) {
+    if (!this.isValid || !s.isValid || !this.loc.equals(s.loc))
+      return !1;
+    function e(t, i) {
+      return t === void 0 || t === 0 ? i === void 0 || i === 0 : t === i;
+    }
+    for (const t of h)
+      if (!e(this.values[t], s.values[t]))
+        return !1;
+    return !0;
+  }
+}
+export {
+  F as accurateMatrix,
+  $ as casualMatrix,
+  m as daysInMonthAccurate,
+  o as daysInYearAccurate,
+  n as default,
+  k as lowOrderMatrix
+};
+//# sourceMappingURL=index.es3.js.map