bt-core-app 2.1.37 → 2.2.0

package/dist/bt-core/core/node_modules/luxon/src/zone.mjs

@@ -0,0 +1,88 @@
+import { ZoneIsAbstractError as t } from "./errors.mjs";
+class n {
+  /**
+   * The type of zone
+   * @abstract
+   * @type {string}
+   */
+  get type() {
+    throw new t();
+  }
+  /**
+   * The name of this zone.
+   * @abstract
+   * @type {string}
+   */
+  get name() {
+    throw new t();
+  }
+  /**
+   * The IANA name of this zone.
+   * Defaults to `name` if not overwritten by a subclass.
+   * @abstract
+   * @type {string}
+   */
+  get ianaName() {
+    return this.name;
+  }
+  /**
+   * Returns whether the offset is known to be fixed for the whole year.
+   * @abstract
+   * @type {boolean}
+   */
+  get isUniversal() {
+    throw new t();
+  }
+  /**
+   * Returns the offset's common name (such as EST) at the specified timestamp
+   * @abstract
+   * @param {number} ts - Epoch milliseconds for which to get the name
+   * @param {Object} opts - Options to affect the format
+   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
+   * @param {string} opts.locale - What locale to return the offset name in.
+   * @return {string}
+   */
+  offsetName(e, o) {
+    throw new t();
+  }
+  /**
+   * Returns the offset's value as a string
+   * @abstract
+   * @param {number} ts - Epoch milliseconds for which to get the offset
+   * @param {string} format - What style of offset to return.
+   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
+   * @return {string}
+   */
+  formatOffset(e, o) {
+    throw new t();
+  }
+  /**
+   * Return the offset in minutes for this zone at the specified timestamp.
+   * @abstract
+   * @param {number} ts - Epoch milliseconds for which to compute the offset
+   * @return {number}
+   */
+  offset(e) {
+    throw new t();
+  }
+  /**
+   * Return whether this Zone is equal to another zone
+   * @abstract
+   * @param {Zone} otherZone - the zone to compare
+   * @return {boolean}
+   */
+  equals(e) {
+    throw new t();
+  }
+  /**
+   * Return whether this Zone is valid.
+   * @abstract
+   * @type {boolean}
+   */
+  get isValid() {
+    throw new t();
+  }
+}
+export {
+  n as default
+};

package/dist/bt-core/core/node_modules/luxon/src/zones/IANAZone.mjs

@@ -0,0 +1,183 @@
+import { parseZoneInfo as y, formatOffset as T, objToLocalTS as v, isUndefined as w } from "../impl/util.mjs";
+import C from "../zone.mjs";
+const h = /* @__PURE__ */ new Map();
+function D(n) {
+  let t = h.get(n);
+  return t === void 0 && (t = new Intl.DateTimeFormat("en-US", {
+    hour12: !1,
+    timeZone: n,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    era: "short"
+  }), h.set(n, t)), t;
+}
+const N = {
+  year: 0,
+  month: 1,
+  day: 2,
+  era: 3,
+  hour: 4,
+  minute: 5,
+  second: 6
+};
+function O(n, t) {
+  const e = n.format(t).replace(/\u200E/g, ""), r = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(e), [, a, i, o, s, f, d, u] = r;
+  return [o, a, i, s, f, d, u];
+}
+function S(n, t) {
+  const e = n.formatToParts(t), r = [];
+  for (let a = 0; a < e.length; a++) {
+    const { type: i, value: o } = e[a], s = N[i];
+    i === "era" ? r[s] = o : w(s) || (r[s] = parseInt(o, 10));
+  }
+  return r;
+}
+const m = /* @__PURE__ */ new Map();
+class p extends C {
+  /**
+   * @param {string} name - Zone name
+   * @return {IANAZone}
+   */
+  static create(t) {
+    let e = m.get(t);
+    return e === void 0 && m.set(t, e = new p(t)), e;
+  }
+  /**
+   * Reset local caches. Should only be necessary in testing scenarios.
+   * @return {void}
+   */
+  static resetCache() {
+    m.clear(), h.clear();
+  }
+  /**
+   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
+   * @param {string} s - The string to check validity on
+   * @example IANAZone.isValidSpecifier("America/New_York") //=> true
+   * @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
+   * @deprecated For backward compatibility, this forwards to isValidZone, better use `isValidZone()` directly instead.
+   * @return {boolean}
+   */
+  static isValidSpecifier(t) {
+    return this.isValidZone(t);
+  }
+  /**
+   * Returns whether the provided string identifies a real zone
+   * @param {string} zone - The string to check
+   * @example IANAZone.isValidZone("America/New_York") //=> true
+   * @example IANAZone.isValidZone("Fantasia/Castle") //=> false
+   * @example IANAZone.isValidZone("Sport~~blorp") //=> false
+   * @return {boolean}
+   */
+  static isValidZone(t) {
+    if (!t)
+      return !1;
+    try {
+      return new Intl.DateTimeFormat("en-US", { timeZone: t }).format(), !0;
+    } catch {
+      return !1;
+    }
+  }
+  constructor(t) {
+    super(), this.zoneName = t, this.valid = p.isValidZone(t);
+  }
+  /**
+   * The type of zone. `iana` for all instances of `IANAZone`.
+   * @override
+   * @type {string}
+   */
+  get type() {
+    return "iana";
+  }
+  /**
+   * The name of this zone (i.e. the IANA zone name).
+   * @override
+   * @type {string}
+   */
+  get name() {
+    return this.zoneName;
+  }
+  /**
+   * Returns whether the offset is known to be fixed for the whole year:
+   * Always returns false for all IANA zones.
+   * @override
+   * @type {boolean}
+   */
+  get isUniversal() {
+    return !1;
+  }
+  /**
+   * Returns the offset's common name (such as EST) at the specified timestamp
+   * @override
+   * @param {number} ts - Epoch milliseconds for which to get the name
+   * @param {Object} opts - Options to affect the format
+   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
+   * @param {string} opts.locale - What locale to return the offset name in.
+   * @return {string}
+   */
+  offsetName(t, { format: e, locale: r }) {
+    return y(t, e, r, this.name);
+  }
+  /**
+   * Returns the offset's value as a string
+   * @override
+   * @param {number} ts - Epoch milliseconds for which to get the offset
+   * @param {string} format - What style of offset to return.
+   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
+   * @return {string}
+   */
+  formatOffset(t, e) {
+    return T(this.offset(t), e);
+  }
+  /**
+   * Return the offset in minutes for this zone at the specified timestamp.
+   * @override
+   * @param {number} ts - Epoch milliseconds for which to compute the offset
+   * @return {number}
+   */
+  offset(t) {
+    if (!this.valid)
+      return NaN;
+    const e = new Date(t);
+    if (isNaN(e))
+      return NaN;
+    const r = D(this.name);
+    let [a, i, o, s, f, d, u] = r.formatToParts ? S(r, e) : O(r, e);
+    s === "BC" && (a = -Math.abs(a) + 1);
+    const g = v({
+      year: a,
+      month: i,
+      day: o,
+      hour: f === 24 ? 0 : f,
+      minute: d,
+      second: u,
+      millisecond: 0
+    });
+    let c = +e;
+    const l = c % 1e3;
+    return c -= l >= 0 ? l : 1e3 + l, (g - c) / (60 * 1e3);
+  }
+  /**
+   * Return whether this Zone is equal to another zone
+   * @override
+   * @param {Zone} otherZone - the zone to compare
+   * @return {boolean}
+   */
+  equals(t) {
+    return t.type === "iana" && t.name === this.name;
+  }
+  /**
+   * Return whether this Zone is valid.
+   * @override
+   * @type {boolean}
+   */
+  get isValid() {
+    return this.valid;
+  }
+}
+export {
+  p as default
+};

package/dist/bt-core/core/node_modules/luxon/src/zones/fixedOffsetZone.mjs

@@ -0,0 +1,125 @@
+import { signedOffset as s, formatOffset as i } from "../impl/util.mjs";
+import u from "../zone.mjs";
+let n = null;
+class r extends u {
+  /**
+   * Get a singleton instance of UTC
+   * @return {FixedOffsetZone}
+   */
+  static get utcInstance() {
+    return n === null && (n = new r(0)), n;
+  }
+  /**
+   * Get an instance with a specified offset
+   * @param {number} offset - The offset in minutes
+   * @return {FixedOffsetZone}
+   */
+  static instance(t) {
+    return t === 0 ? r.utcInstance : new r(t);
+  }
+  /**
+   * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
+   * @param {string} s - The offset string to parse
+   * @example FixedOffsetZone.parseSpecifier("UTC+6")
+   * @example FixedOffsetZone.parseSpecifier("UTC+06")
+   * @example FixedOffsetZone.parseSpecifier("UTC-6:00")
+   * @return {FixedOffsetZone}
+   */
+  static parseSpecifier(t) {
+    if (t) {
+      const e = t.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);
+      if (e)
+        return new r(s(e[1], e[2]));
+    }
+    return null;
+  }
+  constructor(t) {
+    super(), this.fixed = t;
+  }
+  /**
+   * The type of zone. `fixed` for all instances of `FixedOffsetZone`.
+   * @override
+   * @type {string}
+   */
+  get type() {
+    return "fixed";
+  }
+  /**
+   * The name of this zone.
+   * All fixed zones' names always start with "UTC" (plus optional offset)
+   * @override
+   * @type {string}
+   */
+  get name() {
+    return this.fixed === 0 ? "UTC" : `UTC${i(this.fixed, "narrow")}`;
+  }
+  /**
+   * The IANA name of this zone, i.e. `Etc/UTC` or `Etc/GMT+/-nn`
+   *
+   * @override
+   * @type {string}
+   */
+  get ianaName() {
+    return this.fixed === 0 ? "Etc/UTC" : `Etc/GMT${i(-this.fixed, "narrow")}`;
+  }
+  /**
+   * Returns the offset's common name at the specified timestamp.
+   *
+   * For fixed offset zones this equals to the zone name.
+   * @override
+   */
+  offsetName() {
+    return this.name;
+  }
+  /**
+   * Returns the offset's value as a string
+   * @override
+   * @param {number} ts - Epoch milliseconds for which to get the offset
+   * @param {string} format - What style of offset to return.
+   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
+   * @return {string}
+   */
+  formatOffset(t, e) {
+    return i(this.fixed, e);
+  }
+  /**
+   * Returns whether the offset is known to be fixed for the whole year:
+   * Always returns true for all fixed offset zones.
+   * @override
+   * @type {boolean}
+   */
+  get isUniversal() {
+    return !0;
+  }
+  /**
+   * Return the offset in minutes for this zone at the specified timestamp.
+   *
+   * For fixed offset zones, this is constant and does not depend on a timestamp.
+   * @override
+   * @return {number}
+   */
+  offset() {
+    return this.fixed;
+  }
+  /**
+   * Return whether this Zone is equal to another zone (i.e. also fixed and same offset)
+   * @override
+   * @param {Zone} otherZone - the zone to compare
+   * @return {boolean}
+   */
+  equals(t) {
+    return t.type === "fixed" && t.fixed === this.fixed;
+  }
+  /**
+   * Return whether this Zone is valid:
+   * All fixed offset zones are valid.
+   * @override
+   * @type {boolean}
+   */
+  get isValid() {
+    return !0;
+  }
+}
+export {
+  r as default
+};

package/dist/bt-core/core/node_modules/luxon/src/zones/invalidZone.mjs

@@ -0,0 +1,41 @@
+import t from "../zone.mjs";
+class s extends t {
+  constructor(e) {
+    super(), this.zoneName = e;
+  }
+  /** @override **/
+  get type() {
+    return "invalid";
+  }
+  /** @override **/
+  get name() {
+    return this.zoneName;
+  }
+  /** @override **/
+  get isUniversal() {
+    return !1;
+  }
+  /** @override **/
+  offsetName() {
+    return null;
+  }
+  /** @override **/
+  formatOffset() {
+    return "";
+  }
+  /** @override **/
+  offset() {
+    return NaN;
+  }
+  /** @override **/
+  equals() {
+    return !1;
+  }
+  /** @override **/
+  get isValid() {
+    return !1;
+  }
+}
+export {
+  s as default
+};

package/dist/bt-core/core/node_modules/luxon/src/zones/systemZone.mjs

@@ -0,0 +1,47 @@
+import { parseZoneInfo as f, formatOffset as o } from "../impl/util.mjs";
+import a from "../zone.mjs";
+let r = null;
+class n extends a {
+  /**
+   * Get a singleton instance of the local zone
+   * @return {SystemZone}
+   */
+  static get instance() {
+    return r === null && (r = new n()), r;
+  }
+  /** @override **/
+  get type() {
+    return "system";
+  }
+  /** @override **/
+  get name() {
+    return new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  }
+  /** @override **/
+  get isUniversal() {
+    return !1;
+  }
+  /** @override **/
+  offsetName(e, { format: t, locale: s }) {
+    return f(e, t, s);
+  }
+  /** @override **/
+  formatOffset(e, t) {
+    return o(this.offset(e), t);
+  }
+  /** @override **/
+  offset(e) {
+    return -new Date(e).getTimezoneOffset();
+  }
+  /** @override **/
+  equals(e) {
+    return e.type === "system";
+  }
+  /** @override **/
+  get isValid() {
+    return !0;
+  }
+}
+export {
+  n as default
+};

package/dist/bt-core/core/node_modules/merge-images/dist/index.es2015.mjs

@@ -0,0 +1,47 @@
+var v = {
+  format: "image/png",
+  quality: 0.92,
+  width: void 0,
+  height: void 0,
+  Canvas: void 0,
+  crossOrigin: void 0
+}, l = function(f, a) {
+  return f === void 0 && (f = []), a === void 0 && (a = {}), new Promise(function(c) {
+    a = Object.assign({}, v, a);
+    var t = a.Canvas ? new a.Canvas() : window.document.createElement("canvas"), g = a.Canvas ? a.Canvas.Image : window.Image;
+    a.Canvas && (a.quality *= 100);
+    var d = f.map(function(r) {
+      return new Promise(function(i, n) {
+        r.constructor.name !== "Object" && (r = { src: r });
+        var e = new g();
+        e.crossOrigin = a.crossOrigin, e.onerror = function() {
+          return n(new Error("Couldn't load image"));
+        }, e.onload = function() {
+          return i(Object.assign({}, r, { img: e }));
+        }, e.src = r.src;
+      });
+    }), u = t.getContext("2d");
+    c(Promise.all(d).then(function(r) {
+      var i = function(n) {
+        return a[n] || Math.max.apply(Math, r.map(function(e) {
+          return e.img[n];
+        }));
+      };
+      return t.width = i("width"), t.height = i("height"), r.forEach(function(n) {
+        return u.globalAlpha = n.opacity ? n.opacity : 1, u.drawImage(n.img, n.x || 0, n.y || 0);
+      }), a.Canvas && a.format === "image/jpeg" ? new Promise(function(n) {
+        t.toDataURL(a.format, {
+          quality: a.quality,
+          progressive: !1
+        }, function(e, m) {
+          if (e)
+            throw e;
+          n(m);
+        });
+      }) : t.toDataURL(a.format, a.quality);
+    }));
+  });
+};
+export {
+  l as default
+};